blob: 467381a245de6d38d3756da554edb3e80c57218a [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
Daniel Malea93a64302012-12-05 00:20:57 +000010#include "lldb/lldb-python.h"
11
Chris Lattner30fdc8d2010-06-08 16:52:24 +000012#include "lldb/Target/Process.h"
13
14#include "lldb/lldb-private-log.h"
15
16#include "lldb/Breakpoint/StoppointCallbackContext.h"
17#include "lldb/Breakpoint/BreakpointLocation.h"
18#include "lldb/Core/Event.h"
Caroline Ticeef5c6d02010-11-16 05:07:41 +000019#include "lldb/Core/ConnectionFileDescriptor.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000020#include "lldb/Core/Debugger.h"
21#include "lldb/Core/Log.h"
Greg Clayton1f746072012-08-29 21:13:06 +000022#include "lldb/Core/Module.h"
Jim Ingham1460e4b2014-01-10 23:46:59 +000023#include "lldb/Symbol/Symbol.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000024#include "lldb/Core/PluginManager.h"
25#include "lldb/Core/State.h"
Greg Clayton44d93782014-01-27 23:43:24 +000026#include "lldb/Core/StreamFile.h"
Greg Claytoneb0103f2011-04-07 22:46:35 +000027#include "lldb/Expression/ClangUserExpression.h"
Caroline Tice3df9a8d2010-09-04 00:03:46 +000028#include "lldb/Interpreter/CommandInterpreter.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000029#include "lldb/Host/Host.h"
Greg Clayton44d93782014-01-27 23:43:24 +000030#include "lldb/Host/Terminal.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000031#include "lldb/Target/ABI.h"
Greg Clayton8f343b02010-11-04 01:54:29 +000032#include "lldb/Target/DynamicLoader.h"
Andrew MacPherson17220c12014-03-05 10:12:43 +000033#include "lldb/Target/JITLoader.h"
Greg Clayton56d9a1b2011-08-22 02:49:39 +000034#include "lldb/Target/OperatingSystem.h"
Jim Ingham22777012010-09-23 02:01:19 +000035#include "lldb/Target/LanguageRuntime.h"
36#include "lldb/Target/CPPLanguageRuntime.h"
37#include "lldb/Target/ObjCLanguageRuntime.h"
Greg Claytone996fd32011-03-08 22:40:15 +000038#include "lldb/Target/Platform.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000039#include "lldb/Target/RegisterContext.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000040#include "lldb/Target/StopInfo.h"
Jason Molendaeef51062013-11-05 03:57:19 +000041#include "lldb/Target/SystemRuntime.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000042#include "lldb/Target/Target.h"
43#include "lldb/Target/TargetList.h"
44#include "lldb/Target/Thread.h"
45#include "lldb/Target/ThreadPlan.h"
Jim Ingham076b3042012-04-10 01:21:57 +000046#include "lldb/Target/ThreadPlanBase.h"
Jim Ingham1460e4b2014-01-10 23:46:59 +000047#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000048
Charles Davis510938e2013-08-27 05:04:57 +000049#ifndef LLDB_DISABLE_POSIX
50#include <spawn.h>
51#endif
52
Chris Lattner30fdc8d2010-06-08 16:52:24 +000053using namespace lldb;
54using namespace lldb_private;
55
Greg Clayton67cc0632012-08-22 17:17:09 +000056
57// Comment out line below to disable memory caching, overriding the process setting
58// target.process.disable-memory-cache
59#define ENABLE_MEMORY_CACHING
60
61#ifdef ENABLE_MEMORY_CACHING
62#define DISABLE_MEM_CACHE_DEFAULT false
63#else
64#define DISABLE_MEM_CACHE_DEFAULT true
65#endif
66
67class ProcessOptionValueProperties : public OptionValueProperties
68{
69public:
70 ProcessOptionValueProperties (const ConstString &name) :
71 OptionValueProperties (name)
72 {
73 }
74
75 // This constructor is used when creating ProcessOptionValueProperties when it
76 // is part of a new lldb_private::Process instance. It will copy all current
77 // global property values as needed
78 ProcessOptionValueProperties (ProcessProperties *global_properties) :
79 OptionValueProperties(*global_properties->GetValueProperties())
80 {
81 }
82
83 virtual const Property *
84 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
85 {
86 // When gettings the value for a key from the process options, we will always
87 // try and grab the setting from the current process if there is one. Else we just
88 // use the one from this instance.
89 if (exe_ctx)
90 {
91 Process *process = exe_ctx->GetProcessPtr();
92 if (process)
93 {
94 ProcessOptionValueProperties *instance_properties = static_cast<ProcessOptionValueProperties *>(process->GetValueProperties().get());
95 if (this != instance_properties)
96 return instance_properties->ProtectedGetPropertyAtIndex (idx);
97 }
98 }
99 return ProtectedGetPropertyAtIndex (idx);
100 }
101};
102
103static PropertyDefinition
104g_properties[] =
105{
106 { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, NULL, NULL, "Disable reading and caching of memory in fixed-size units." },
Jim Ingham8c3f2762012-11-29 00:41:12 +0000107 { "extra-startup-command", OptionValue::eTypeArray , false, OptionValue::eTypeString, NULL, NULL, "A list containing extra commands understood by the particular process plugin used. "
108 "For instance, to turn on debugserver logging set this to \"QSetLogging:bitmask=LOG_DEFAULT;\"" },
Jim Inghamafc1b122013-01-31 19:48:57 +0000109 { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, breakpoints will be ignored during expression evaluation." },
110 { "unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, errors in expression evaluation will unwind the stack back to the state before the call." },
Greg Claytone1e835c2012-11-29 18:48:47 +0000111 { "python-os-plugin-path", OptionValue::eTypeFileSpec, false, true, NULL, NULL, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class." },
Jim Ingham29950772013-01-26 02:19:28 +0000112 { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, stop when a shared library is loaded or unloaded." },
Jim Inghamacff8952013-05-02 00:27:30 +0000113 { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, detach will attempt to keep the process stopped." },
Greg Clayton67cc0632012-08-22 17:17:09 +0000114 { NULL , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL }
115};
116
117enum {
118 ePropertyDisableMemCache,
Greg Claytonc9d645d2012-10-18 22:40:37 +0000119 ePropertyExtraStartCommand,
Jim Ingham184e9812013-01-15 02:47:48 +0000120 ePropertyIgnoreBreakpointsInExpressions,
121 ePropertyUnwindOnErrorInExpressions,
Jim Ingham29950772013-01-26 02:19:28 +0000122 ePropertyPythonOSPluginPath,
Jim Inghamacff8952013-05-02 00:27:30 +0000123 ePropertyStopOnSharedLibraryEvents,
124 ePropertyDetachKeepsStopped
Greg Clayton67cc0632012-08-22 17:17:09 +0000125};
126
127ProcessProperties::ProcessProperties (bool is_global) :
128 Properties ()
129{
130 if (is_global)
131 {
132 m_collection_sp.reset (new ProcessOptionValueProperties(ConstString("process")));
133 m_collection_sp->Initialize(g_properties);
134 m_collection_sp->AppendProperty(ConstString("thread"),
Jim Ingham29950772013-01-26 02:19:28 +0000135 ConstString("Settings specific to threads."),
Greg Clayton67cc0632012-08-22 17:17:09 +0000136 true,
137 Thread::GetGlobalProperties()->GetValueProperties());
138 }
139 else
140 m_collection_sp.reset (new ProcessOptionValueProperties(Process::GetGlobalProperties().get()));
141}
142
143ProcessProperties::~ProcessProperties()
144{
145}
146
147bool
148ProcessProperties::GetDisableMemoryCache() const
149{
150 const uint32_t idx = ePropertyDisableMemCache;
151 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
152}
153
154Args
155ProcessProperties::GetExtraStartupCommands () const
156{
157 Args args;
158 const uint32_t idx = ePropertyExtraStartCommand;
159 m_collection_sp->GetPropertyAtIndexAsArgs(NULL, idx, args);
160 return args;
161}
162
163void
164ProcessProperties::SetExtraStartupCommands (const Args &args)
165{
166 const uint32_t idx = ePropertyExtraStartCommand;
167 m_collection_sp->SetPropertyAtIndexFromArgs(NULL, idx, args);
168}
169
Greg Claytonc9d645d2012-10-18 22:40:37 +0000170FileSpec
171ProcessProperties::GetPythonOSPluginPath () const
172{
173 const uint32_t idx = ePropertyPythonOSPluginPath;
174 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx);
175}
176
177void
178ProcessProperties::SetPythonOSPluginPath (const FileSpec &file)
179{
180 const uint32_t idx = ePropertyPythonOSPluginPath;
181 m_collection_sp->SetPropertyAtIndexAsFileSpec(NULL, idx, file);
182}
183
Jim Ingham184e9812013-01-15 02:47:48 +0000184
185bool
186ProcessProperties::GetIgnoreBreakpointsInExpressions () const
187{
188 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
189 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
190}
191
192void
193ProcessProperties::SetIgnoreBreakpointsInExpressions (bool ignore)
194{
195 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
196 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
197}
198
199bool
200ProcessProperties::GetUnwindOnErrorInExpressions () const
201{
202 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
203 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
204}
205
206void
207ProcessProperties::SetUnwindOnErrorInExpressions (bool ignore)
208{
209 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
210 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
211}
212
Jim Ingham29950772013-01-26 02:19:28 +0000213bool
214ProcessProperties::GetStopOnSharedLibraryEvents () const
215{
216 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
217 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
218}
219
220void
221ProcessProperties::SetStopOnSharedLibraryEvents (bool stop)
222{
223 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
224 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
225}
226
Jim Inghamacff8952013-05-02 00:27:30 +0000227bool
228ProcessProperties::GetDetachKeepsStopped () const
229{
230 const uint32_t idx = ePropertyDetachKeepsStopped;
231 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
232}
233
234void
235ProcessProperties::SetDetachKeepsStopped (bool stop)
236{
237 const uint32_t idx = ePropertyDetachKeepsStopped;
238 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
239}
240
Greg Clayton32e0a752011-03-30 18:16:51 +0000241void
Greg Clayton8b82f082011-04-12 05:54:46 +0000242ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000243{
244 const char *cstr;
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000245 if (m_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000246 s.Printf (" pid = %" PRIu64 "\n", m_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000247
248 if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000249 s.Printf (" parent = %" PRIu64 "\n", m_parent_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000250
251 if (m_executable)
252 {
253 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString());
254 s.PutCString (" file = ");
255 m_executable.Dump(&s);
256 s.EOL();
257 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000258 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000259 if (argc > 0)
260 {
261 for (uint32_t i=0; i<argc; i++)
262 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000263 const char *arg = m_arguments.GetArgumentAtIndex(i);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000264 if (i < 10)
Greg Clayton8b82f082011-04-12 05:54:46 +0000265 s.Printf (" arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000266 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000267 s.Printf ("arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000268 }
269 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000270
271 const uint32_t envc = m_environment.GetArgumentCount();
272 if (envc > 0)
273 {
274 for (uint32_t i=0; i<envc; i++)
275 {
276 const char *env = m_environment.GetArgumentAtIndex(i);
277 if (i < 10)
278 s.Printf (" env[%u] = %s\n", i, env);
279 else
280 s.Printf ("env[%u] = %s\n", i, env);
281 }
282 }
283
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000284 if (m_arch.IsValid())
285 s.Printf (" arch = %s\n", m_arch.GetTriple().str().c_str());
286
Greg Clayton8b82f082011-04-12 05:54:46 +0000287 if (m_uid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000288 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000289 cstr = platform->GetUserName (m_uid);
290 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000291 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000292 if (m_gid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000293 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000294 cstr = platform->GetGroupName (m_gid);
295 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000296 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000297 if (m_euid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000298 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000299 cstr = platform->GetUserName (m_euid);
300 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000301 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000302 if (m_egid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000303 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000304 cstr = platform->GetGroupName (m_egid);
305 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000306 }
307}
308
309void
Greg Clayton8b82f082011-04-12 05:54:46 +0000310ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
Greg Clayton32e0a752011-03-30 18:16:51 +0000311{
Greg Clayton8b82f082011-04-12 05:54:46 +0000312 const char *label;
313 if (show_args || verbose)
314 label = "ARGUMENTS";
315 else
316 label = "NAME";
317
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000318 if (verbose)
319 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000320 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000321 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
322 }
323 else
324 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000325 s.Printf ("PID PARENT USER ARCH %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000326 s.PutCString ("====== ====== ========== ======= ============================\n");
327 }
Greg Clayton32e0a752011-03-30 18:16:51 +0000328}
329
330void
Greg Clayton8b82f082011-04-12 05:54:46 +0000331ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000332{
333 if (m_pid != LLDB_INVALID_PROCESS_ID)
334 {
335 const char *cstr;
Daniel Malead01b2952012-11-29 21:49:15 +0000336 s.Printf ("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000337
Greg Clayton32e0a752011-03-30 18:16:51 +0000338
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000339 if (verbose)
340 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000341 cstr = platform->GetUserName (m_uid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000342 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
343 s.Printf ("%-10s ", cstr);
344 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000345 s.Printf ("%-10u ", m_uid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000346
Greg Clayton8b82f082011-04-12 05:54:46 +0000347 cstr = platform->GetGroupName (m_gid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000348 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
349 s.Printf ("%-10s ", cstr);
350 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000351 s.Printf ("%-10u ", m_gid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000352
Greg Clayton8b82f082011-04-12 05:54:46 +0000353 cstr = platform->GetUserName (m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000354 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
355 s.Printf ("%-10s ", cstr);
356 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000357 s.Printf ("%-10u ", m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000358
Greg Clayton8b82f082011-04-12 05:54:46 +0000359 cstr = platform->GetGroupName (m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000360 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
361 s.Printf ("%-10s ", cstr);
362 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000363 s.Printf ("%-10u ", m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000364 s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
365 }
366 else
367 {
Jason Molendafd54b362011-09-20 21:44:10 +0000368 s.Printf ("%-10s %-7d %s ",
Greg Clayton8b82f082011-04-12 05:54:46 +0000369 platform->GetUserName (m_euid),
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000370 (int)m_arch.GetTriple().getArchName().size(),
371 m_arch.GetTriple().getArchName().data());
372 }
373
Greg Clayton8b82f082011-04-12 05:54:46 +0000374 if (verbose || show_args)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000375 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000376 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000377 if (argc > 0)
378 {
379 for (uint32_t i=0; i<argc; i++)
380 {
381 if (i > 0)
382 s.PutChar (' ');
Greg Clayton8b82f082011-04-12 05:54:46 +0000383 s.PutCString (m_arguments.GetArgumentAtIndex(i));
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000384 }
385 }
386 }
387 else
388 {
389 s.PutCString (GetName());
390 }
391
392 s.EOL();
Greg Clayton32e0a752011-03-30 18:16:51 +0000393 }
394}
395
Greg Clayton8b82f082011-04-12 05:54:46 +0000396
397void
Greg Clayton45392552012-10-17 22:57:12 +0000398ProcessInfo::SetArguments (char const **argv, bool first_arg_is_executable)
Greg Clayton982c9762011-11-03 21:22:33 +0000399{
400 m_arguments.SetArguments (argv);
401
402 // Is the first argument the executable?
403 if (first_arg_is_executable)
404 {
405 const char *first_arg = m_arguments.GetArgumentAtIndex (0);
406 if (first_arg)
407 {
408 // Yes the first argument is an executable, set it as the executable
409 // in the launch options. Don't resolve the file path as the path
410 // could be a remote platform path
411 const bool resolve = false;
412 m_executable.SetFile(first_arg, resolve);
Greg Clayton982c9762011-11-03 21:22:33 +0000413 }
414 }
415}
416void
Greg Clayton45392552012-10-17 22:57:12 +0000417ProcessInfo::SetArguments (const Args& args, bool first_arg_is_executable)
Greg Clayton8b82f082011-04-12 05:54:46 +0000418{
419 // Copy all arguments
420 m_arguments = args;
421
422 // Is the first argument the executable?
423 if (first_arg_is_executable)
424 {
Greg Clayton982c9762011-11-03 21:22:33 +0000425 const char *first_arg = m_arguments.GetArgumentAtIndex (0);
Greg Clayton8b82f082011-04-12 05:54:46 +0000426 if (first_arg)
427 {
428 // Yes the first argument is an executable, set it as the executable
429 // in the launch options. Don't resolve the file path as the path
430 // could be a remote platform path
431 const bool resolve = false;
432 m_executable.SetFile(first_arg, resolve);
Greg Clayton8b82f082011-04-12 05:54:46 +0000433 }
434 }
435}
436
Greg Clayton1d885962011-11-08 02:43:13 +0000437void
Greg Claytonee95ed52011-11-17 22:14:31 +0000438ProcessLaunchInfo::FinalizeFileActions (Target *target, bool default_to_use_pty)
Greg Clayton1d885962011-11-08 02:43:13 +0000439{
440 // If notthing was specified, then check the process for any default
441 // settings that were set with "settings set"
442 if (m_file_actions.empty())
443 {
Greg Clayton1d885962011-11-08 02:43:13 +0000444 if (m_flags.Test(eLaunchFlagDisableSTDIO))
445 {
Greg Clayton9845a8d2012-03-06 04:01:04 +0000446 AppendSuppressFileAction (STDIN_FILENO , true, false);
447 AppendSuppressFileAction (STDOUT_FILENO, false, true);
448 AppendSuppressFileAction (STDERR_FILENO, false, true);
Greg Clayton1d885962011-11-08 02:43:13 +0000449 }
450 else
451 {
452 // Check for any values that might have gotten set with any of:
453 // (lldb) settings set target.input-path
454 // (lldb) settings set target.output-path
455 // (lldb) settings set target.error-path
Greg Clayton67cc0632012-08-22 17:17:09 +0000456 FileSpec in_path;
457 FileSpec out_path;
458 FileSpec err_path;
Greg Clayton1d885962011-11-08 02:43:13 +0000459 if (target)
460 {
Greg Clayton9845a8d2012-03-06 04:01:04 +0000461 in_path = target->GetStandardInputPath();
462 out_path = target->GetStandardOutputPath();
463 err_path = target->GetStandardErrorPath();
Greg Claytonee95ed52011-11-17 22:14:31 +0000464 }
465
Greg Clayton67cc0632012-08-22 17:17:09 +0000466 if (in_path || out_path || err_path)
467 {
468 char path[PATH_MAX];
469 if (in_path && in_path.GetPath(path, sizeof(path)))
470 AppendOpenFileAction(STDIN_FILENO, path, true, false);
471
472 if (out_path && out_path.GetPath(path, sizeof(path)))
473 AppendOpenFileAction(STDOUT_FILENO, path, false, true);
474
475 if (err_path && err_path.GetPath(path, sizeof(path)))
476 AppendOpenFileAction(STDERR_FILENO, path, false, true);
477 }
478 else if (default_to_use_pty)
Greg Claytonee95ed52011-11-17 22:14:31 +0000479 {
480 if (m_pty.OpenFirstAvailableMaster (O_RDWR|O_NOCTTY, NULL, 0))
Greg Clayton1d885962011-11-08 02:43:13 +0000481 {
Greg Clayton67cc0632012-08-22 17:17:09 +0000482 const char *slave_path = m_pty.GetSlaveName (NULL, 0);
483 AppendOpenFileAction(STDIN_FILENO, slave_path, true, false);
484 AppendOpenFileAction(STDOUT_FILENO, slave_path, false, true);
485 AppendOpenFileAction(STDERR_FILENO, slave_path, false, true);
Greg Clayton1d885962011-11-08 02:43:13 +0000486 }
487 }
Greg Clayton1d885962011-11-08 02:43:13 +0000488 }
489 }
490}
491
Greg Clayton144f3a92011-11-15 03:53:30 +0000492
493bool
Greg Claytond1cf11a2012-04-14 01:42:46 +0000494ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell (Error &error,
495 bool localhost,
496 bool will_debug,
Jim Inghamdf0ae222013-09-10 02:09:47 +0000497 bool first_arg_is_full_shell_command,
498 int32_t num_resumes)
Greg Clayton144f3a92011-11-15 03:53:30 +0000499{
500 error.Clear();
501
502 if (GetFlags().Test (eLaunchFlagLaunchInShell))
503 {
504 const char *shell_executable = GetShell();
505 if (shell_executable)
506 {
507 char shell_resolved_path[PATH_MAX];
508
509 if (localhost)
510 {
511 FileSpec shell_filespec (shell_executable, true);
512
513 if (!shell_filespec.Exists())
514 {
515 // Resolve the path in case we just got "bash", "sh" or "tcsh"
516 if (!shell_filespec.ResolveExecutableLocation ())
517 {
518 error.SetErrorStringWithFormat("invalid shell path '%s'", shell_executable);
519 return false;
520 }
521 }
522 shell_filespec.GetPath (shell_resolved_path, sizeof(shell_resolved_path));
523 shell_executable = shell_resolved_path;
524 }
525
Greg Clayton45392552012-10-17 22:57:12 +0000526 const char **argv = GetArguments().GetConstArgumentVector ();
527 if (argv == NULL || argv[0] == NULL)
528 return false;
Greg Clayton144f3a92011-11-15 03:53:30 +0000529 Args shell_arguments;
530 std::string safe_arg;
531 shell_arguments.AppendArgument (shell_executable);
Greg Clayton144f3a92011-11-15 03:53:30 +0000532 shell_arguments.AppendArgument ("-c");
Greg Claytond1cf11a2012-04-14 01:42:46 +0000533 StreamString shell_command;
534 if (will_debug)
Greg Clayton144f3a92011-11-15 03:53:30 +0000535 {
Greg Clayton45392552012-10-17 22:57:12 +0000536 // Add a modified PATH environment variable in case argv[0]
537 // is a relative path
538 const char *argv0 = argv[0];
539 if (argv0 && (argv0[0] != '/' && argv0[0] != '~'))
540 {
541 // We have a relative path to our executable which may not work if
542 // we just try to run "a.out" (without it being converted to "./a.out")
543 const char *working_dir = GetWorkingDirectory();
Greg Clayton8938f8d2013-02-14 03:54:39 +0000544 // Be sure to put quotes around PATH's value in case any paths have spaces...
545 std::string new_path("PATH=\"");
Greg Clayton45392552012-10-17 22:57:12 +0000546 const size_t empty_path_len = new_path.size();
547
548 if (working_dir && working_dir[0])
549 {
550 new_path += working_dir;
551 }
552 else
553 {
554 char current_working_dir[PATH_MAX];
555 const char *cwd = getcwd(current_working_dir, sizeof(current_working_dir));
556 if (cwd && cwd[0])
557 new_path += cwd;
558 }
559 const char *curr_path = getenv("PATH");
560 if (curr_path)
561 {
562 if (new_path.size() > empty_path_len)
563 new_path += ':';
564 new_path += curr_path;
565 }
Greg Clayton8938f8d2013-02-14 03:54:39 +0000566 new_path += "\" ";
Greg Clayton45392552012-10-17 22:57:12 +0000567 shell_command.PutCString(new_path.c_str());
568 }
569
Greg Claytond1cf11a2012-04-14 01:42:46 +0000570 shell_command.PutCString ("exec");
Greg Clayton45392552012-10-17 22:57:12 +0000571
Greg Clayton45392552012-10-17 22:57:12 +0000572 // Only Apple supports /usr/bin/arch being able to specify the architecture
Greg Claytond1cf11a2012-04-14 01:42:46 +0000573 if (GetArchitecture().IsValid())
574 {
575 shell_command.Printf(" /usr/bin/arch -arch %s", GetArchitecture().GetArchitectureName());
Greg Clayton45392552012-10-17 22:57:12 +0000576 // Set the resume count to 2:
Greg Claytond1cf11a2012-04-14 01:42:46 +0000577 // 1 - stop in shell
578 // 2 - stop in /usr/bin/arch
579 // 3 - then we will stop in our program
Jim Inghamdf0ae222013-09-10 02:09:47 +0000580 SetResumeCount(num_resumes + 1);
Greg Claytond1cf11a2012-04-14 01:42:46 +0000581 }
582 else
583 {
Greg Clayton45392552012-10-17 22:57:12 +0000584 // Set the resume count to 1:
Greg Claytond1cf11a2012-04-14 01:42:46 +0000585 // 1 - stop in shell
586 // 2 - then we will stop in our program
Jim Inghamdf0ae222013-09-10 02:09:47 +0000587 SetResumeCount(num_resumes);
Greg Claytond1cf11a2012-04-14 01:42:46 +0000588 }
Greg Clayton144f3a92011-11-15 03:53:30 +0000589 }
Greg Clayton45392552012-10-17 22:57:12 +0000590
591 if (first_arg_is_full_shell_command)
Greg Clayton144f3a92011-11-15 03:53:30 +0000592 {
Greg Clayton45392552012-10-17 22:57:12 +0000593 // There should only be one argument that is the shell command itself to be used as is
594 if (argv[0] && !argv[1])
595 shell_command.Printf("%s", argv[0]);
Greg Claytond1cf11a2012-04-14 01:42:46 +0000596 else
Greg Clayton45392552012-10-17 22:57:12 +0000597 return false;
Greg Clayton144f3a92011-11-15 03:53:30 +0000598 }
Greg Claytond1cf11a2012-04-14 01:42:46 +0000599 else
600 {
Greg Clayton45392552012-10-17 22:57:12 +0000601 for (size_t i=0; argv[i] != NULL; ++i)
602 {
603 const char *arg = Args::GetShellSafeArgument (argv[i], safe_arg);
604 shell_command.Printf(" %s", arg);
605 }
Greg Claytond1cf11a2012-04-14 01:42:46 +0000606 }
Greg Clayton45392552012-10-17 22:57:12 +0000607 shell_arguments.AppendArgument (shell_command.GetString().c_str());
Greg Clayton144f3a92011-11-15 03:53:30 +0000608 m_executable.SetFile(shell_executable, false);
609 m_arguments = shell_arguments;
610 return true;
611 }
612 else
613 {
614 error.SetErrorString ("invalid shell path");
615 }
616 }
617 else
618 {
619 error.SetErrorString ("not launching in shell");
620 }
621 return false;
622}
623
624
Greg Clayton32e0a752011-03-30 18:16:51 +0000625bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000626ProcessLaunchInfo::FileAction::Open (int fd, const char *path, bool read, bool write)
627{
628 if ((read || write) && fd >= 0 && path && path[0])
629 {
630 m_action = eFileActionOpen;
631 m_fd = fd;
632 if (read && write)
Greg Clayton144f3a92011-11-15 03:53:30 +0000633 m_arg = O_NOCTTY | O_CREAT | O_RDWR;
Greg Clayton8b82f082011-04-12 05:54:46 +0000634 else if (read)
Greg Clayton144f3a92011-11-15 03:53:30 +0000635 m_arg = O_NOCTTY | O_RDONLY;
Greg Clayton8b82f082011-04-12 05:54:46 +0000636 else
Greg Clayton144f3a92011-11-15 03:53:30 +0000637 m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
Greg Clayton8b82f082011-04-12 05:54:46 +0000638 m_path.assign (path);
639 return true;
640 }
641 else
642 {
643 Clear();
644 }
645 return false;
646}
647
648bool
649ProcessLaunchInfo::FileAction::Close (int fd)
650{
651 Clear();
652 if (fd >= 0)
653 {
654 m_action = eFileActionClose;
655 m_fd = fd;
656 }
657 return m_fd >= 0;
658}
659
660
661bool
662ProcessLaunchInfo::FileAction::Duplicate (int fd, int dup_fd)
663{
664 Clear();
665 if (fd >= 0 && dup_fd >= 0)
666 {
667 m_action = eFileActionDuplicate;
668 m_fd = fd;
669 m_arg = dup_fd;
670 }
671 return m_fd >= 0;
672}
673
674
675
Virgile Bellob2f1fb22013-08-23 12:44:05 +0000676#ifndef LLDB_DISABLE_POSIX
Greg Clayton8b82f082011-04-12 05:54:46 +0000677bool
Charles Davis510938e2013-08-27 05:04:57 +0000678ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (void *_file_actions,
Greg Clayton8b82f082011-04-12 05:54:46 +0000679 const FileAction *info,
680 Log *log,
681 Error& error)
682{
683 if (info == NULL)
684 return false;
685
Charles Davis510938e2013-08-27 05:04:57 +0000686 posix_spawn_file_actions_t *file_actions = reinterpret_cast<posix_spawn_file_actions_t *>(_file_actions);
687
Greg Clayton8b82f082011-04-12 05:54:46 +0000688 switch (info->m_action)
689 {
690 case eFileActionNone:
691 error.Clear();
692 break;
693
694 case eFileActionClose:
695 if (info->m_fd == -1)
696 error.SetErrorString ("invalid fd for posix_spawn_file_actions_addclose(...)");
697 else
698 {
699 error.SetError (::posix_spawn_file_actions_addclose (file_actions, info->m_fd),
700 eErrorTypePOSIX);
701 if (log && (error.Fail() || log))
702 error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000703 static_cast<void*>(file_actions), info->m_fd);
Greg Clayton8b82f082011-04-12 05:54:46 +0000704 }
705 break;
706
707 case eFileActionDuplicate:
708 if (info->m_fd == -1)
709 error.SetErrorString ("invalid fd for posix_spawn_file_actions_adddup2(...)");
710 else if (info->m_arg == -1)
711 error.SetErrorString ("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)");
712 else
713 {
714 error.SetError (::posix_spawn_file_actions_adddup2 (file_actions, info->m_fd, info->m_arg),
715 eErrorTypePOSIX);
716 if (log && (error.Fail() || log))
717 error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000718 static_cast<void*>(file_actions), info->m_fd,
719 info->m_arg);
Greg Clayton8b82f082011-04-12 05:54:46 +0000720 }
721 break;
722
723 case eFileActionOpen:
724 if (info->m_fd == -1)
725 error.SetErrorString ("invalid fd in posix_spawn_file_actions_addopen(...)");
726 else
727 {
728 int oflag = info->m_arg;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000729
Greg Clayton8b82f082011-04-12 05:54:46 +0000730 mode_t mode = 0;
731
Greg Clayton144f3a92011-11-15 03:53:30 +0000732 if (oflag & O_CREAT)
733 mode = 0640;
734
Greg Clayton8b82f082011-04-12 05:54:46 +0000735 error.SetError (::posix_spawn_file_actions_addopen (file_actions,
736 info->m_fd,
737 info->m_path.c_str(),
738 oflag,
739 mode),
740 eErrorTypePOSIX);
741 if (error.Fail() || log)
742 error.PutToLog(log,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000743 "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
744 static_cast<void*>(file_actions), info->m_fd,
745 info->m_path.c_str(), oflag, mode);
Greg Clayton8b82f082011-04-12 05:54:46 +0000746 }
747 break;
Greg Clayton8b82f082011-04-12 05:54:46 +0000748 }
749 return error.Success();
750}
Virgile Bellob2f1fb22013-08-23 12:44:05 +0000751#endif
Greg Clayton8b82f082011-04-12 05:54:46 +0000752
753Error
Greg Claytonf6b8b582011-04-13 00:18:08 +0000754ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
Greg Clayton8b82f082011-04-12 05:54:46 +0000755{
756 Error error;
Greg Clayton3bcdfc02012-12-04 00:32:51 +0000757 const int short_option = m_getopt_table[option_idx].val;
Greg Clayton8b82f082011-04-12 05:54:46 +0000758
759 switch (short_option)
760 {
761 case 's': // Stop at program entry point
762 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
763 break;
764
Greg Clayton8b82f082011-04-12 05:54:46 +0000765 case 'i': // STDIN for read only
766 {
767 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000768 if (action.Open (STDIN_FILENO, option_arg, true, false))
Greg Clayton8b82f082011-04-12 05:54:46 +0000769 launch_info.AppendFileAction (action);
770 }
771 break;
772
773 case 'o': // Open STDOUT for write only
774 {
775 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000776 if (action.Open (STDOUT_FILENO, option_arg, false, true))
777 launch_info.AppendFileAction (action);
778 }
779 break;
780
781 case 'e': // STDERR for write only
782 {
783 ProcessLaunchInfo::FileAction action;
784 if (action.Open (STDERR_FILENO, option_arg, false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000785 launch_info.AppendFileAction (action);
786 }
787 break;
788
Greg Clayton9845a8d2012-03-06 04:01:04 +0000789
Greg Clayton8b82f082011-04-12 05:54:46 +0000790 case 'p': // Process plug-in name
791 launch_info.SetProcessPluginName (option_arg);
792 break;
793
794 case 'n': // Disable STDIO
795 {
796 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000797 if (action.Open (STDIN_FILENO, "/dev/null", true, false))
Greg Clayton8b82f082011-04-12 05:54:46 +0000798 launch_info.AppendFileAction (action);
Greg Clayton9845a8d2012-03-06 04:01:04 +0000799 if (action.Open (STDOUT_FILENO, "/dev/null", false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000800 launch_info.AppendFileAction (action);
Greg Clayton9845a8d2012-03-06 04:01:04 +0000801 if (action.Open (STDERR_FILENO, "/dev/null", false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000802 launch_info.AppendFileAction (action);
803 }
804 break;
805
806 case 'w':
807 launch_info.SetWorkingDirectory (option_arg);
808 break;
809
810 case 't': // Open process in new terminal window
811 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
812 break;
813
814 case 'a':
Greg Clayton70512312012-05-08 01:45:38 +0000815 if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
816 launch_info.GetArchitecture().SetTriple (option_arg);
Greg Clayton8b82f082011-04-12 05:54:46 +0000817 break;
818
819 case 'A':
820 launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
821 break;
822
Greg Clayton982c9762011-11-03 21:22:33 +0000823 case 'c':
Greg Clayton144f3a92011-11-15 03:53:30 +0000824 if (option_arg && option_arg[0])
825 launch_info.SetShell (option_arg);
826 else
Ed Masteb8ca4a22013-09-03 23:04:53 +0000827 launch_info.SetShell (LLDB_DEFAULT_SHELL);
Greg Clayton982c9762011-11-03 21:22:33 +0000828 break;
829
Greg Clayton8b82f082011-04-12 05:54:46 +0000830 case 'v':
831 launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
832 break;
833
834 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000835 error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
Greg Clayton8b82f082011-04-12 05:54:46 +0000836 break;
837
838 }
839 return error;
840}
841
842OptionDefinition
843ProcessLaunchCommandOptions::g_option_table[] =
844{
Virgile Belloe2607b52013-09-05 16:42:23 +0000845{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process."},
846{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."},
847{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
848{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', OptionParser::eRequiredArgument, NULL, 0, eArgTypeDirectoryName, "Set the current working directory to <path> when running the inferior."},
849{ LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."},
850{ LLDB_OPT_SET_ALL, false, "environment", 'v', OptionParser::eRequiredArgument, NULL, 0, eArgTypeNone, "Specify an environment variable name/value string (--environment NAME=VALUE). Can be specified multiple times for subsequent environment entries."},
851{ LLDB_OPT_SET_ALL, false, "shell", 'c', OptionParser::eOptionalArgument, NULL, 0, eArgTypeFilename, "Run the process in a shell (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000852
Virgile Belloe2607b52013-09-05 16:42:23 +0000853{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>."},
854{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>."},
855{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000856
Virgile Belloe2607b52013-09-05 16:42:23 +0000857{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000858
Virgile Belloe2607b52013-09-05 16:42:23 +0000859{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000860
861{ 0 , false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
862};
863
864
865
866bool
867ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000868{
869 if (m_name_match_type == eNameMatchIgnore || process_name == NULL)
870 return true;
871 const char *match_name = m_match_info.GetName();
872 if (!match_name)
873 return true;
874
875 return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
876}
877
878bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000879ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000880{
881 if (!NameMatches (proc_info.GetName()))
882 return false;
883
884 if (m_match_info.ProcessIDIsValid() &&
885 m_match_info.GetProcessID() != proc_info.GetProcessID())
886 return false;
887
888 if (m_match_info.ParentProcessIDIsValid() &&
889 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
890 return false;
891
Greg Clayton8b82f082011-04-12 05:54:46 +0000892 if (m_match_info.UserIDIsValid () &&
893 m_match_info.GetUserID() != proc_info.GetUserID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000894 return false;
895
Greg Clayton8b82f082011-04-12 05:54:46 +0000896 if (m_match_info.GroupIDIsValid () &&
897 m_match_info.GetGroupID() != proc_info.GetGroupID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000898 return false;
899
900 if (m_match_info.EffectiveUserIDIsValid () &&
901 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
902 return false;
903
904 if (m_match_info.EffectiveGroupIDIsValid () &&
905 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
906 return false;
907
908 if (m_match_info.GetArchitecture().IsValid() &&
Sean Callananbf4b7be2012-12-13 22:07:14 +0000909 !m_match_info.GetArchitecture().IsCompatibleMatch(proc_info.GetArchitecture()))
Greg Clayton32e0a752011-03-30 18:16:51 +0000910 return false;
911 return true;
912}
913
914bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000915ProcessInstanceInfoMatch::MatchAllProcesses () const
Greg Clayton32e0a752011-03-30 18:16:51 +0000916{
917 if (m_name_match_type != eNameMatchIgnore)
918 return false;
919
920 if (m_match_info.ProcessIDIsValid())
921 return false;
922
923 if (m_match_info.ParentProcessIDIsValid())
924 return false;
925
Greg Clayton8b82f082011-04-12 05:54:46 +0000926 if (m_match_info.UserIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000927 return false;
928
Greg Clayton8b82f082011-04-12 05:54:46 +0000929 if (m_match_info.GroupIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000930 return false;
931
932 if (m_match_info.EffectiveUserIDIsValid ())
933 return false;
934
935 if (m_match_info.EffectiveGroupIDIsValid ())
936 return false;
937
938 if (m_match_info.GetArchitecture().IsValid())
939 return false;
940
941 if (m_match_all_users)
942 return false;
943
944 return true;
945
946}
947
948void
Greg Clayton8b82f082011-04-12 05:54:46 +0000949ProcessInstanceInfoMatch::Clear()
Greg Clayton32e0a752011-03-30 18:16:51 +0000950{
951 m_match_info.Clear();
952 m_name_match_type = eNameMatchIgnore;
953 m_match_all_users = false;
954}
Greg Clayton58be07b2011-01-07 06:08:19 +0000955
Greg Claytonc3776bf2012-02-09 06:16:32 +0000956ProcessSP
957Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener, const FileSpec *crash_file_path)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000958{
Greg Clayton949e8222013-01-16 17:29:04 +0000959 static uint32_t g_process_unique_id = 0;
960
Greg Claytonc3776bf2012-02-09 06:16:32 +0000961 ProcessSP process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000962 ProcessCreateInstance create_callback = NULL;
963 if (plugin_name)
964 {
Greg Clayton57abc5d2013-05-10 21:47:16 +0000965 ConstString const_plugin_name(plugin_name);
966 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (const_plugin_name);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000967 if (create_callback)
968 {
Greg Claytonc3776bf2012-02-09 06:16:32 +0000969 process_sp = create_callback(target, listener, crash_file_path);
970 if (process_sp)
971 {
Greg Clayton949e8222013-01-16 17:29:04 +0000972 if (process_sp->CanDebug(target, true))
973 {
974 process_sp->m_process_unique_id = ++g_process_unique_id;
975 }
976 else
Greg Claytonc3776bf2012-02-09 06:16:32 +0000977 process_sp.reset();
978 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000979 }
980 }
981 else
982 {
Greg Claytonc982c762010-07-09 20:39:50 +0000983 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000984 {
Greg Claytonc3776bf2012-02-09 06:16:32 +0000985 process_sp = create_callback(target, listener, crash_file_path);
986 if (process_sp)
987 {
Greg Clayton949e8222013-01-16 17:29:04 +0000988 if (process_sp->CanDebug(target, false))
989 {
990 process_sp->m_process_unique_id = ++g_process_unique_id;
Greg Claytonc3776bf2012-02-09 06:16:32 +0000991 break;
Greg Clayton949e8222013-01-16 17:29:04 +0000992 }
993 else
994 process_sp.reset();
Greg Claytonc3776bf2012-02-09 06:16:32 +0000995 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000996 }
997 }
Greg Claytonc3776bf2012-02-09 06:16:32 +0000998 return process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000999}
1000
Jim Ingham4bddaeb2012-02-16 06:50:00 +00001001ConstString &
1002Process::GetStaticBroadcasterClass ()
1003{
1004 static ConstString class_name ("lldb.process");
1005 return class_name;
1006}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001007
1008//----------------------------------------------------------------------
1009// Process constructor
1010//----------------------------------------------------------------------
1011Process::Process(Target &target, Listener &listener) :
Greg Clayton67cc0632012-08-22 17:17:09 +00001012 ProcessProperties (false),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001013 UserID (LLDB_INVALID_PROCESS_ID),
Jim Ingham4bddaeb2012-02-16 06:50:00 +00001014 Broadcaster (&(target.GetDebugger()), "lldb.process"),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001015 m_target (target),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001016 m_public_state (eStateUnloaded),
1017 m_private_state (eStateUnloaded),
Jim Ingham4bddaeb2012-02-16 06:50:00 +00001018 m_private_state_broadcaster (NULL, "lldb.process.internal_state_broadcaster"),
1019 m_private_state_control_broadcaster (NULL, "lldb.process.internal_state_control_broadcaster"),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001020 m_private_state_listener ("lldb.process.internal_state_listener"),
1021 m_private_state_control_wait(),
1022 m_private_state_thread (LLDB_INVALID_HOST_THREAD),
Jim Ingham4b536182011-08-09 02:12:22 +00001023 m_mod_id (),
Greg Clayton949e8222013-01-16 17:29:04 +00001024 m_process_unique_id(0),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001025 m_thread_index_id (0),
Han Ming Ongc2c423e2013-01-08 22:10:01 +00001026 m_thread_id_to_index_id_map (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001027 m_exit_status (-1),
1028 m_exit_string (),
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001029 m_thread_mutex (Mutex::eMutexTypeRecursive),
1030 m_thread_list_real (this),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001031 m_thread_list (this),
Jason Molenda864f1cc2013-11-11 05:20:44 +00001032 m_extended_thread_list (this),
Jason Molenda4ff13262013-11-20 00:31:38 +00001033 m_extended_thread_stop_id (0),
Jason Molenda5e8dce42013-12-13 00:29:16 +00001034 m_queue_list (this),
1035 m_queue_list_stop_id (0),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001036 m_notifications (),
Greg Clayton3af9ea52010-11-18 05:57:03 +00001037 m_image_tokens (),
1038 m_listener (listener),
1039 m_breakpoint_site_list (),
Greg Clayton3af9ea52010-11-18 05:57:03 +00001040 m_dynamic_checkers_ap (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +00001041 m_unix_signals (),
Greg Clayton3af9ea52010-11-18 05:57:03 +00001042 m_abi_sp (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +00001043 m_process_input_reader (),
Greg Clayton3e06bd92011-01-09 21:07:35 +00001044 m_stdio_communication ("process.stdio"),
Greg Clayton3af9ea52010-11-18 05:57:03 +00001045 m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
Greg Clayton58be07b2011-01-07 06:08:19 +00001046 m_stdout_data (),
Greg Clayton93e86192011-11-13 04:45:22 +00001047 m_stderr_data (),
Han Ming Ongab3b8b22012-11-17 00:21:04 +00001048 m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
1049 m_profile_data (),
Greg Claytond495c532011-05-17 03:37:42 +00001050 m_memory_cache (*this),
1051 m_allocated_memory_cache (*this),
Greg Claytone24c4ac2011-11-17 04:46:02 +00001052 m_should_detach (false),
Sean Callanan90539452011-09-20 23:01:51 +00001053 m_next_event_action_ap(),
Greg Clayton96249852013-04-18 16:57:27 +00001054 m_public_run_lock (),
Greg Clayton96249852013-04-18 16:57:27 +00001055 m_private_run_lock (),
Jim Inghamaacc3182012-06-06 00:29:30 +00001056 m_currently_handling_event(false),
Jim Ingham4fc6cb92012-08-22 21:34:33 +00001057 m_finalize_called(false),
Greg Claytonf9b57b92013-05-10 23:48:10 +00001058 m_clear_thread_plans_on_stop (false),
Jim Ingham1460e4b2014-01-10 23:46:59 +00001059 m_force_next_event_delivery(false),
Jim Ingham0161b492013-02-09 01:29:05 +00001060 m_last_broadcast_state (eStateInvalid),
Jason Molenda69b6b632013-03-05 03:33:59 +00001061 m_destroy_in_process (false),
1062 m_can_jit(eCanJITDontKnow)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001063{
Jim Ingham4bddaeb2012-02-16 06:50:00 +00001064 CheckInWithManager ();
Caroline Tice1559a462010-09-27 00:30:10 +00001065
Greg Clayton5160ce52013-03-27 23:08:40 +00001066 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001067 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001068 log->Printf ("%p Process::Process()", static_cast<void*>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001069
Greg Claytoncfd1ace2010-10-31 03:01:06 +00001070 SetEventName (eBroadcastBitStateChanged, "state-changed");
1071 SetEventName (eBroadcastBitInterrupt, "interrupt");
1072 SetEventName (eBroadcastBitSTDOUT, "stdout-available");
1073 SetEventName (eBroadcastBitSTDERR, "stderr-available");
Han Ming Ongab3b8b22012-11-17 00:21:04 +00001074 SetEventName (eBroadcastBitProfileData, "profile-data-available");
Greg Claytoncfd1ace2010-10-31 03:01:06 +00001075
Greg Clayton35a4cc52012-10-29 20:52:08 +00001076 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop , "control-stop" );
1077 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" );
1078 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume");
1079
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001080 listener.StartListeningForEvents (this,
1081 eBroadcastBitStateChanged |
1082 eBroadcastBitInterrupt |
1083 eBroadcastBitSTDOUT |
Han Ming Ongab3b8b22012-11-17 00:21:04 +00001084 eBroadcastBitSTDERR |
1085 eBroadcastBitProfileData);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001086
1087 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster,
Jim Inghamcfc09352012-07-27 23:57:19 +00001088 eBroadcastBitStateChanged |
1089 eBroadcastBitInterrupt);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001090
1091 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster,
1092 eBroadcastInternalStateControlStop |
1093 eBroadcastInternalStateControlPause |
1094 eBroadcastInternalStateControlResume);
1095}
1096
1097//----------------------------------------------------------------------
1098// Destructor
1099//----------------------------------------------------------------------
1100Process::~Process()
1101{
Greg Clayton5160ce52013-03-27 23:08:40 +00001102 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001103 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001104 log->Printf ("%p Process::~Process()", static_cast<void*>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001105 StopPrivateStateThread();
1106}
1107
Greg Clayton67cc0632012-08-22 17:17:09 +00001108const ProcessPropertiesSP &
1109Process::GetGlobalProperties()
1110{
1111 static ProcessPropertiesSP g_settings_sp;
1112 if (!g_settings_sp)
1113 g_settings_sp.reset (new ProcessProperties (true));
1114 return g_settings_sp;
1115}
1116
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001117void
1118Process::Finalize()
1119{
Greg Claytone24c4ac2011-11-17 04:46:02 +00001120 switch (GetPrivateState())
1121 {
1122 case eStateConnected:
1123 case eStateAttaching:
1124 case eStateLaunching:
1125 case eStateStopped:
1126 case eStateRunning:
1127 case eStateStepping:
1128 case eStateCrashed:
1129 case eStateSuspended:
1130 if (GetShouldDetach())
Jim Inghamacff8952013-05-02 00:27:30 +00001131 {
1132 // FIXME: This will have to be a process setting:
1133 bool keep_stopped = false;
1134 Detach(keep_stopped);
1135 }
Greg Claytone24c4ac2011-11-17 04:46:02 +00001136 else
1137 Destroy();
1138 break;
1139
1140 case eStateInvalid:
1141 case eStateUnloaded:
1142 case eStateDetached:
1143 case eStateExited:
1144 break;
1145 }
1146
Greg Clayton1ed54f52011-10-01 00:45:15 +00001147 // Clear our broadcaster before we proceed with destroying
1148 Broadcaster::Clear();
1149
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001150 // Do any cleanup needed prior to being destructed... Subclasses
1151 // that override this method should call this superclass method as well.
Jim Inghamd0a3e122011-02-16 17:54:55 +00001152
1153 // We need to destroy the loader before the derived Process class gets destroyed
1154 // since it is very likely that undoing the loader will require access to the real process.
Greg Clayton894f82f2012-01-20 23:08:34 +00001155 m_dynamic_checkers_ap.reset();
1156 m_abi_sp.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001157 m_os_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00001158 m_system_runtime_ap.reset();
Greg Clayton894f82f2012-01-20 23:08:34 +00001159 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00001160 m_jit_loaders_ap.reset();
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001161 m_thread_list_real.Destroy();
Greg Claytone1cd1be2012-01-29 20:56:30 +00001162 m_thread_list.Destroy();
Jason Molenda864f1cc2013-11-11 05:20:44 +00001163 m_extended_thread_list.Destroy();
Jason Molenda5e8dce42013-12-13 00:29:16 +00001164 m_queue_list.Clear();
1165 m_queue_list_stop_id = 0;
Greg Clayton894f82f2012-01-20 23:08:34 +00001166 std::vector<Notifications> empty_notifications;
1167 m_notifications.swap(empty_notifications);
1168 m_image_tokens.clear();
1169 m_memory_cache.Clear();
1170 m_allocated_memory_cache.Clear();
1171 m_language_runtimes.clear();
1172 m_next_event_action_ap.reset();
Greg Clayton35a4cc52012-10-29 20:52:08 +00001173//#ifdef LLDB_CONFIGURATION_DEBUG
1174// StreamFile s(stdout, false);
1175// EventSP event_sp;
1176// while (m_private_state_listener.GetNextEvent(event_sp))
1177// {
1178// event_sp->Dump (&s);
1179// s.EOL();
1180// }
1181//#endif
1182 // We have to be very careful here as the m_private_state_listener might
1183 // contain events that have ProcessSP values in them which can keep this
1184 // process around forever. These events need to be cleared out.
1185 m_private_state_listener.Clear();
Ed Maste64fad602013-07-29 20:58:06 +00001186 m_public_run_lock.TrySetRunning(); // This will do nothing if already locked
1187 m_public_run_lock.SetStopped();
1188 m_private_run_lock.TrySetRunning(); // This will do nothing if already locked
1189 m_private_run_lock.SetStopped();
Jim Ingham4fc6cb92012-08-22 21:34:33 +00001190 m_finalize_called = true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001191}
1192
1193void
1194Process::RegisterNotificationCallbacks (const Notifications& callbacks)
1195{
1196 m_notifications.push_back(callbacks);
1197 if (callbacks.initialize != NULL)
1198 callbacks.initialize (callbacks.baton, this);
1199}
1200
1201bool
1202Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
1203{
1204 std::vector<Notifications>::iterator pos, end = m_notifications.end();
1205 for (pos = m_notifications.begin(); pos != end; ++pos)
1206 {
1207 if (pos->baton == callbacks.baton &&
1208 pos->initialize == callbacks.initialize &&
1209 pos->process_state_changed == callbacks.process_state_changed)
1210 {
1211 m_notifications.erase(pos);
1212 return true;
1213 }
1214 }
1215 return false;
1216}
1217
1218void
1219Process::SynchronouslyNotifyStateChanged (StateType state)
1220{
1221 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
1222 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
1223 {
1224 if (notification_pos->process_state_changed)
1225 notification_pos->process_state_changed (notification_pos->baton, this, state);
1226 }
1227}
1228
1229// FIXME: We need to do some work on events before the general Listener sees them.
1230// For instance if we are continuing from a breakpoint, we need to ensure that we do
1231// the little "insert real insn, step & stop" trick. But we can't do that when the
1232// event is delivered by the broadcaster - since that is done on the thread that is
1233// waiting for new events, so if we needed more than one event for our handling, we would
1234// stall. So instead we do it when we fetch the event off of the queue.
1235//
1236
1237StateType
1238Process::GetNextEvent (EventSP &event_sp)
1239{
1240 StateType state = eStateInvalid;
1241
1242 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
1243 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
1244
1245 return state;
1246}
1247
1248
1249StateType
Greg Clayton44d93782014-01-27 23:43:24 +00001250Process::WaitForProcessToStop (const TimeValue *timeout, lldb::EventSP *event_sp_ptr, bool wait_always, Listener *hijack_listener)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001251{
Jim Ingham4b536182011-08-09 02:12:22 +00001252 // We can't just wait for a "stopped" event, because the stopped event may have restarted the target.
1253 // We have to actually check each event, and in the case of a stopped event check the restarted flag
1254 // on the event.
Greg Clayton85fb1b92012-09-11 02:33:37 +00001255 if (event_sp_ptr)
1256 event_sp_ptr->reset();
Jim Ingham4b536182011-08-09 02:12:22 +00001257 StateType state = GetState();
1258 // If we are exited or detached, we won't ever get back to any
1259 // other valid state...
1260 if (state == eStateDetached || state == eStateExited)
1261 return state;
1262
Daniel Malea9e9919f2013-10-09 16:56:28 +00001263 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1264 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001265 log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
1266 static_cast<const void*>(timeout));
Daniel Malea9e9919f2013-10-09 16:56:28 +00001267
1268 if (!wait_always &&
1269 StateIsStoppedState(state, true) &&
1270 StateIsStoppedState(GetPrivateState(), true)) {
1271 if (log)
1272 log->Printf("Process::%s returning without waiting for events; process private and public states are already 'stopped'.",
1273 __FUNCTION__);
1274 return state;
1275 }
1276
Jim Ingham4b536182011-08-09 02:12:22 +00001277 while (state != eStateInvalid)
1278 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00001279 EventSP event_sp;
Greg Clayton44d93782014-01-27 23:43:24 +00001280 state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener);
Greg Clayton85fb1b92012-09-11 02:33:37 +00001281 if (event_sp_ptr && event_sp)
1282 *event_sp_ptr = event_sp;
1283
Jim Ingham4b536182011-08-09 02:12:22 +00001284 switch (state)
1285 {
1286 case eStateCrashed:
1287 case eStateDetached:
1288 case eStateExited:
1289 case eStateUnloaded:
Greg Clayton44d93782014-01-27 23:43:24 +00001290 // We need to toggle the run lock as this won't get done in
1291 // SetPublicState() if the process is hijacked.
1292 if (hijack_listener)
1293 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +00001294 return state;
1295 case eStateStopped:
1296 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
1297 continue;
1298 else
Greg Clayton44d93782014-01-27 23:43:24 +00001299 {
1300 // We need to toggle the run lock as this won't get done in
1301 // SetPublicState() if the process is hijacked.
1302 if (hijack_listener)
1303 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +00001304 return state;
Greg Clayton44d93782014-01-27 23:43:24 +00001305 }
Jim Ingham4b536182011-08-09 02:12:22 +00001306 default:
1307 continue;
1308 }
1309 }
1310 return state;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001311}
1312
1313
1314StateType
1315Process::WaitForState
1316(
1317 const TimeValue *timeout,
Greg Clayton44d93782014-01-27 23:43:24 +00001318 const StateType *match_states,
1319 const uint32_t num_match_states
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001320)
1321{
1322 EventSP event_sp;
1323 uint32_t i;
Greg Clayton05faeb72010-10-07 04:19:01 +00001324 StateType state = GetState();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001325 while (state != eStateInvalid)
1326 {
Greg Clayton05faeb72010-10-07 04:19:01 +00001327 // If we are exited or detached, we won't ever get back to any
1328 // other valid state...
1329 if (state == eStateDetached || state == eStateExited)
1330 return state;
1331
Greg Clayton44d93782014-01-27 23:43:24 +00001332 state = WaitForStateChangedEvents (timeout, event_sp, NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001333
1334 for (i=0; i<num_match_states; ++i)
1335 {
1336 if (match_states[i] == state)
1337 return state;
1338 }
1339 }
1340 return state;
1341}
1342
Jim Ingham30f9b212010-10-11 23:53:14 +00001343bool
1344Process::HijackProcessEvents (Listener *listener)
1345{
1346 if (listener != NULL)
1347 {
Jim Inghamcfc09352012-07-27 23:57:19 +00001348 return HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Jim Ingham30f9b212010-10-11 23:53:14 +00001349 }
1350 else
1351 return false;
1352}
1353
1354void
1355Process::RestoreProcessEvents ()
1356{
1357 RestoreBroadcaster();
1358}
1359
Jim Ingham0f16e732011-02-08 05:20:59 +00001360bool
1361Process::HijackPrivateProcessEvents (Listener *listener)
1362{
1363 if (listener != NULL)
1364 {
Jim Inghamcfc09352012-07-27 23:57:19 +00001365 return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Jim Ingham0f16e732011-02-08 05:20:59 +00001366 }
1367 else
1368 return false;
1369}
1370
1371void
1372Process::RestorePrivateProcessEvents ()
1373{
1374 m_private_state_broadcaster.RestoreBroadcaster();
1375}
1376
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001377StateType
Greg Clayton44d93782014-01-27 23:43:24 +00001378Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, Listener *hijack_listener)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001379{
Greg Clayton5160ce52013-03-27 23:08:40 +00001380 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001381
1382 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001383 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1384 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001385
Greg Clayton44d93782014-01-27 23:43:24 +00001386 Listener *listener = hijack_listener;
1387 if (listener == NULL)
1388 listener = &m_listener;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001389
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001390 StateType state = eStateInvalid;
Greg Clayton44d93782014-01-27 23:43:24 +00001391 if (listener->WaitForEventForBroadcasterWithType (timeout,
1392 this,
1393 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
1394 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001395 {
1396 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1397 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1398 else if (log)
1399 log->Printf ("Process::%s got no event or was interrupted.", __FUNCTION__);
1400 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001401
1402 if (log)
1403 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001404 __FUNCTION__, static_cast<const void*>(timeout),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001405 StateAsCString(state));
1406 return state;
1407}
1408
1409Event *
1410Process::PeekAtStateChangedEvents ()
1411{
Greg Clayton5160ce52013-03-27 23:08:40 +00001412 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001413
1414 if (log)
1415 log->Printf ("Process::%s...", __FUNCTION__);
1416
1417 Event *event_ptr;
Greg Clayton3fcbed62010-10-19 03:25:40 +00001418 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this,
1419 eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001420 if (log)
1421 {
1422 if (event_ptr)
1423 {
1424 log->Printf ("Process::%s (event_ptr) => %s",
1425 __FUNCTION__,
1426 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
1427 }
1428 else
1429 {
1430 log->Printf ("Process::%s no events found",
1431 __FUNCTION__);
1432 }
1433 }
1434 return event_ptr;
1435}
1436
1437StateType
1438Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
1439{
Greg Clayton5160ce52013-03-27 23:08:40 +00001440 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001441
1442 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001443 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1444 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001445
1446 StateType state = eStateInvalid;
Greg Clayton6779606a2011-01-22 23:43:18 +00001447 if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout,
1448 &m_private_state_broadcaster,
Jim Inghamcfc09352012-07-27 23:57:19 +00001449 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
Greg Clayton6779606a2011-01-22 23:43:18 +00001450 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001451 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1452 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001453
1454 // This is a bit of a hack, but when we wait here we could very well return
1455 // to the command-line, and that could disable the log, which would render the
1456 // log we got above invalid.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001457 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001458 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1459 __FUNCTION__, static_cast<const void *>(timeout),
1460 state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001461 return state;
1462}
1463
1464bool
1465Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
1466{
Greg Clayton5160ce52013-03-27 23:08:40 +00001467 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001468
1469 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001470 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1471 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001472
1473 if (control_only)
1474 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
1475 else
1476 return m_private_state_listener.WaitForEvent(timeout, event_sp);
1477}
1478
1479bool
1480Process::IsRunning () const
1481{
1482 return StateIsRunningState (m_public_state.GetValue());
1483}
1484
1485int
1486Process::GetExitStatus ()
1487{
1488 if (m_public_state.GetValue() == eStateExited)
1489 return m_exit_status;
1490 return -1;
1491}
1492
Greg Clayton85851dd2010-12-04 00:10:17 +00001493
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001494const char *
1495Process::GetExitDescription ()
1496{
1497 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1498 return m_exit_string.c_str();
1499 return NULL;
1500}
1501
Greg Clayton6779606a2011-01-22 23:43:18 +00001502bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001503Process::SetExitStatus (int status, const char *cstr)
1504{
Greg Clayton5160ce52013-03-27 23:08:40 +00001505 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Greg Clayton414f5d32011-01-25 02:58:48 +00001506 if (log)
1507 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1508 status, status,
1509 cstr ? "\"" : "",
1510 cstr ? cstr : "NULL",
1511 cstr ? "\"" : "");
1512
Greg Clayton6779606a2011-01-22 23:43:18 +00001513 // We were already in the exited state
1514 if (m_private_state.GetValue() == eStateExited)
Greg Clayton414f5d32011-01-25 02:58:48 +00001515 {
Greg Clayton385d6032011-01-26 23:47:29 +00001516 if (log)
1517 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
Greg Clayton6779606a2011-01-22 23:43:18 +00001518 return false;
Greg Clayton414f5d32011-01-25 02:58:48 +00001519 }
Greg Clayton6779606a2011-01-22 23:43:18 +00001520
1521 m_exit_status = status;
1522 if (cstr)
1523 m_exit_string = cstr;
1524 else
1525 m_exit_string.clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001526
Greg Clayton6779606a2011-01-22 23:43:18 +00001527 DidExit ();
Greg Clayton10177aa2010-12-08 05:08:21 +00001528
Greg Clayton6779606a2011-01-22 23:43:18 +00001529 SetPrivateState (eStateExited);
1530 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001531}
1532
1533// This static callback can be used to watch for local child processes on
1534// the current host. The the child process exits, the process will be
1535// found in the global target list (we want to be completely sure that the
1536// lldb_private::Process doesn't go away before we can deliver the signal.
1537bool
Greg Claytone4e45922011-11-16 05:37:56 +00001538Process::SetProcessExitStatus (void *callback_baton,
1539 lldb::pid_t pid,
1540 bool exited,
1541 int signo, // Zero for no signal
1542 int exit_status // Exit value of process if signal is zero
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001543)
1544{
Greg Clayton5160ce52013-03-27 23:08:40 +00001545 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytone4e45922011-11-16 05:37:56 +00001546 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001547 log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n",
Greg Claytone4e45922011-11-16 05:37:56 +00001548 callback_baton,
1549 pid,
1550 exited,
1551 signo,
1552 exit_status);
1553
1554 if (exited)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001555 {
Greg Clayton66111032010-06-23 01:19:29 +00001556 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001557 if (target_sp)
1558 {
1559 ProcessSP process_sp (target_sp->GetProcessSP());
1560 if (process_sp)
1561 {
1562 const char *signal_cstr = NULL;
1563 if (signo)
1564 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo);
1565
1566 process_sp->SetExitStatus (exit_status, signal_cstr);
1567 }
1568 }
1569 return true;
1570 }
1571 return false;
1572}
1573
1574
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001575void
1576Process::UpdateThreadListIfNeeded ()
1577{
1578 const uint32_t stop_id = GetStopID();
1579 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
1580 {
Greg Clayton2637f822011-11-17 01:23:07 +00001581 const StateType state = GetPrivateState();
1582 if (StateIsStoppedState (state, true))
1583 {
1584 Mutex::Locker locker (m_thread_list.GetMutex ());
Greg Claytone24c4ac2011-11-17 04:46:02 +00001585 // m_thread_list does have its own mutex, but we need to
1586 // hold onto the mutex between the call to UpdateThreadList(...)
1587 // and the os->UpdateThreadList(...) so it doesn't change on us
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001588 ThreadList &old_thread_list = m_thread_list;
1589 ThreadList real_thread_list(this);
Greg Clayton2637f822011-11-17 01:23:07 +00001590 ThreadList new_thread_list(this);
1591 // Always update the thread list with the protocol specific
Greg Clayton9fc13552012-04-10 00:18:59 +00001592 // thread list, but only update if "true" is returned
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001593 if (UpdateThreadList (m_thread_list_real, real_thread_list))
Greg Clayton9fc13552012-04-10 00:18:59 +00001594 {
Jim Ingham09437922013-03-01 20:04:25 +00001595 // Don't call into the OperatingSystem to update the thread list if we are shutting down, since
1596 // that may call back into the SBAPI's, requiring the API lock which is already held by whoever is
1597 // shutting us down, causing a deadlock.
1598 if (!m_destroy_in_process)
1599 {
1600 OperatingSystem *os = GetOperatingSystem ();
1601 if (os)
Greg Claytonb3ae8762013-04-12 20:07:46 +00001602 {
1603 // Clear any old backing threads where memory threads might have been
1604 // backed by actual threads from the lldb_private::Process subclass
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001605 size_t num_old_threads = old_thread_list.GetSize(false);
Greg Claytonb3ae8762013-04-12 20:07:46 +00001606 for (size_t i=0; i<num_old_threads; ++i)
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001607 old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
Greg Claytonb3ae8762013-04-12 20:07:46 +00001608
1609 // Now let the OperatingSystem plug-in update the thread list
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001610 os->UpdateThreadList (old_thread_list, // Old list full of threads created by OS plug-in
1611 real_thread_list, // The actual thread list full of threads created by each lldb_private::Process subclass
1612 new_thread_list); // The new thread list that we will show to the user that gets filled in
Greg Claytonb3ae8762013-04-12 20:07:46 +00001613 }
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001614 else
1615 {
1616 // No OS plug-in, the new thread list is the same as the real thread list
1617 new_thread_list = real_thread_list;
1618 }
Jim Ingham09437922013-03-01 20:04:25 +00001619 }
Jim Ingham02ff8e02013-06-22 00:55:02 +00001620
1621 m_thread_list_real.Update(real_thread_list);
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001622 m_thread_list.Update (new_thread_list);
1623 m_thread_list.SetStopID (stop_id);
Jason Molendaa6e91302013-11-19 05:44:41 +00001624
Jason Molenda4ff13262013-11-20 00:31:38 +00001625 if (GetLastNaturalStopID () != m_extended_thread_stop_id)
1626 {
1627 // Clear any extended threads that we may have accumulated previously
1628 m_extended_thread_list.Clear();
1629 m_extended_thread_stop_id = GetLastNaturalStopID ();
Jason Molenda5e8dce42013-12-13 00:29:16 +00001630
1631 m_queue_list.Clear();
1632 m_queue_list_stop_id = GetLastNaturalStopID ();
Jason Molenda4ff13262013-11-20 00:31:38 +00001633 }
Greg Clayton9fc13552012-04-10 00:18:59 +00001634 }
Greg Clayton2637f822011-11-17 01:23:07 +00001635 }
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001636 }
1637}
1638
Jason Molenda5e8dce42013-12-13 00:29:16 +00001639void
1640Process::UpdateQueueListIfNeeded ()
1641{
1642 if (m_system_runtime_ap.get())
1643 {
1644 if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID())
1645 {
1646 const StateType state = GetPrivateState();
1647 if (StateIsStoppedState (state, true))
1648 {
1649 m_system_runtime_ap->PopulateQueueList (m_queue_list);
1650 m_queue_list_stop_id = GetLastNaturalStopID();
1651 }
1652 }
1653 }
1654}
1655
Greg Claytona4d87472013-01-18 23:41:08 +00001656ThreadSP
1657Process::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
1658{
1659 OperatingSystem *os = GetOperatingSystem ();
1660 if (os)
1661 return os->CreateThread(tid, context);
1662 return ThreadSP();
1663}
1664
Han Ming Ongc2c423e2013-01-08 22:10:01 +00001665uint32_t
1666Process::GetNextThreadIndexID (uint64_t thread_id)
1667{
1668 return AssignIndexIDToThread(thread_id);
1669}
1670
1671bool
1672Process::HasAssignedIndexIDToThread(uint64_t thread_id)
1673{
1674 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1675 if (iterator == m_thread_id_to_index_id_map.end())
1676 {
1677 return false;
1678 }
1679 else
1680 {
1681 return true;
1682 }
1683}
1684
1685uint32_t
1686Process::AssignIndexIDToThread(uint64_t thread_id)
1687{
1688 uint32_t result = 0;
1689 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1690 if (iterator == m_thread_id_to_index_id_map.end())
1691 {
1692 result = ++m_thread_index_id;
1693 m_thread_id_to_index_id_map[thread_id] = result;
1694 }
1695 else
1696 {
1697 result = iterator->second;
1698 }
1699
1700 return result;
1701}
1702
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001703StateType
1704Process::GetState()
1705{
1706 // If any other threads access this we will need a mutex for it
1707 return m_public_state.GetValue ();
1708}
1709
1710void
Jim Ingham221d51c2013-05-08 00:35:16 +00001711Process::SetPublicState (StateType new_state, bool restarted)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001712{
Greg Clayton5160ce52013-03-27 23:08:40 +00001713 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001714 if (log)
Jim Ingham221d51c2013-05-08 00:35:16 +00001715 log->Printf("Process::SetPublicState (state = %s, restarted = %i)", StateAsCString(new_state), restarted);
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001716 const StateType old_state = m_public_state.GetValue();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001717 m_public_state.SetValue (new_state);
Jim Ingham3b8285d2012-04-19 01:40:33 +00001718
1719 // On the transition from Run to Stopped, we unlock the writer end of the
1720 // run lock. The lock gets locked in Resume, which is the public API
1721 // to tell the program to run.
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001722 if (!IsHijackedForEvent(eBroadcastBitStateChanged))
1723 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001724 if (new_state == eStateDetached)
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001725 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001726 if (log)
1727 log->Printf("Process::SetPublicState (%s) -- unlocking run lock for detach", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001728 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001729 }
1730 else
1731 {
1732 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1733 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
Jim Ingham221d51c2013-05-08 00:35:16 +00001734 if ((old_state_is_stopped != new_state_is_stopped))
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001735 {
Jim Ingham221d51c2013-05-08 00:35:16 +00001736 if (new_state_is_stopped && !restarted)
Sean Callanan8b0737f2012-06-02 01:16:20 +00001737 {
1738 if (log)
1739 log->Printf("Process::SetPublicState (%s) -- unlocking run lock", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001740 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001741 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001742 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001743 }
1744 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001745}
1746
Jim Ingham3b8285d2012-04-19 01:40:33 +00001747Error
1748Process::Resume ()
1749{
Greg Clayton5160ce52013-03-27 23:08:40 +00001750 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Jim Ingham3b8285d2012-04-19 01:40:33 +00001751 if (log)
1752 log->Printf("Process::Resume -- locking run lock");
Ed Maste64fad602013-07-29 20:58:06 +00001753 if (!m_public_run_lock.TrySetRunning())
Jim Ingham3b8285d2012-04-19 01:40:33 +00001754 {
1755 Error error("Resume request failed - process still running.");
1756 if (log)
Ed Maste64fad602013-07-29 20:58:06 +00001757 log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
Jim Ingham3b8285d2012-04-19 01:40:33 +00001758 return error;
1759 }
1760 return PrivateResume();
1761}
1762
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001763StateType
1764Process::GetPrivateState ()
1765{
1766 return m_private_state.GetValue();
1767}
1768
1769void
1770Process::SetPrivateState (StateType new_state)
1771{
Greg Clayton5160ce52013-03-27 23:08:40 +00001772 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001773 bool state_changed = false;
1774
1775 if (log)
1776 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1777
Andrew Kaylor29d65742013-05-10 17:19:04 +00001778 Mutex::Locker thread_locker(m_thread_list.GetMutex());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001779 Mutex::Locker locker(m_private_state.GetMutex());
1780
1781 const StateType old_state = m_private_state.GetValueNoLock ();
1782 state_changed = old_state != new_state;
Ed Mastec29693f2013-07-02 16:35:47 +00001783
Greg Claytonaa49c832013-05-03 22:25:56 +00001784 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1785 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1786 if (old_state_is_stopped != new_state_is_stopped)
1787 {
1788 if (new_state_is_stopped)
Ed Maste64fad602013-07-29 20:58:06 +00001789 m_private_run_lock.SetStopped();
Greg Claytonaa49c832013-05-03 22:25:56 +00001790 else
Ed Maste64fad602013-07-29 20:58:06 +00001791 m_private_run_lock.SetRunning();
Greg Claytonaa49c832013-05-03 22:25:56 +00001792 }
Andrew Kaylor93132f52013-05-28 23:04:25 +00001793
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001794 if (state_changed)
1795 {
1796 m_private_state.SetValueNoLock (new_state);
Greg Clayton2637f822011-11-17 01:23:07 +00001797 if (StateIsStoppedState(new_state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001798 {
Andrew Kaylor29d65742013-05-10 17:19:04 +00001799 // Note, this currently assumes that all threads in the list
1800 // stop when the process stops. In the future we will want to
1801 // support a debugging model where some threads continue to run
1802 // while others are stopped. When that happens we will either need
1803 // a way for the thread list to identify which threads are stopping
1804 // or create a special thread list containing only threads which
1805 // actually stopped.
1806 //
1807 // The process plugin is responsible for managing the actual
1808 // behavior of the threads and should have stopped any threads
1809 // that are going to stop before we get here.
1810 m_thread_list.DidStop();
1811
Jim Ingham4b536182011-08-09 02:12:22 +00001812 m_mod_id.BumpStopID();
Greg Clayton58be07b2011-01-07 06:08:19 +00001813 m_memory_cache.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001814 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00001815 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001816 }
1817 // Use our target to get a shared pointer to ourselves...
Greg Clayton35a4cc52012-10-29 20:52:08 +00001818 if (m_finalize_called && PrivateStateThreadIsValid() == false)
1819 BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
1820 else
1821 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001822 }
1823 else
1824 {
1825 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00001826 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001827 }
1828}
1829
Jim Ingham0faa43f2011-11-08 03:00:11 +00001830void
1831Process::SetRunningUserExpression (bool on)
1832{
1833 m_mod_id.SetRunningUserExpression (on);
1834}
1835
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001836addr_t
1837Process::GetImageInfoAddress()
1838{
1839 return LLDB_INVALID_ADDRESS;
1840}
1841
Greg Clayton8f343b02010-11-04 01:54:29 +00001842//----------------------------------------------------------------------
1843// LoadImage
1844//
1845// This function provides a default implementation that works for most
1846// unix variants. Any Process subclasses that need to do shared library
1847// loading differently should override LoadImage and UnloadImage and
1848// do what is needed.
1849//----------------------------------------------------------------------
1850uint32_t
1851Process::LoadImage (const FileSpec &image_spec, Error &error)
1852{
Greg Claytonac7a3db2012-04-18 00:05:19 +00001853 char path[PATH_MAX];
1854 image_spec.GetPath(path, sizeof(path));
1855
Greg Clayton8f343b02010-11-04 01:54:29 +00001856 DynamicLoader *loader = GetDynamicLoader();
1857 if (loader)
1858 {
1859 error = loader->CanLoadImage();
1860 if (error.Fail())
1861 return LLDB_INVALID_IMAGE_TOKEN;
1862 }
1863
1864 if (error.Success())
1865 {
1866 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001867
1868 if (thread_sp)
1869 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001870 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001871
1872 if (frame_sp)
1873 {
1874 ExecutionContext exe_ctx;
1875 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001876 EvaluateExpressionOptions expr_options;
1877 expr_options.SetUnwindOnError(true);
1878 expr_options.SetIgnoreBreakpoints(true);
1879 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001880 StreamString expr;
Greg Clayton8f343b02010-11-04 01:54:29 +00001881 expr.Printf("dlopen (\"%s\", 2)", path);
1882 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001883 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001884 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001885 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001886 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001887 expr.GetData(),
1888 prefix,
1889 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001890 expr_error);
1891 if (expr_error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001892 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001893 error = result_valobj_sp->GetError();
1894 if (error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001895 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001896 Scalar scalar;
1897 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001898 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001899 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1900 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1901 {
1902 uint32_t image_token = m_image_tokens.size();
1903 m_image_tokens.push_back (image_ptr);
1904 return image_token;
1905 }
Greg Clayton8f343b02010-11-04 01:54:29 +00001906 }
1907 }
1908 }
Jim Ingham6c9ed912014-04-03 01:26:14 +00001909 else
1910 error = expr_error;
Greg Clayton8f343b02010-11-04 01:54:29 +00001911 }
1912 }
1913 }
Greg Claytonac7a3db2012-04-18 00:05:19 +00001914 if (!error.AsCString())
1915 error.SetErrorStringWithFormat("unable to load '%s'", path);
Greg Clayton8f343b02010-11-04 01:54:29 +00001916 return LLDB_INVALID_IMAGE_TOKEN;
1917}
1918
1919//----------------------------------------------------------------------
1920// UnloadImage
1921//
1922// This function provides a default implementation that works for most
1923// unix variants. Any Process subclasses that need to do shared library
1924// loading differently should override LoadImage and UnloadImage and
1925// do what is needed.
1926//----------------------------------------------------------------------
1927Error
1928Process::UnloadImage (uint32_t image_token)
1929{
1930 Error error;
1931 if (image_token < m_image_tokens.size())
1932 {
1933 const addr_t image_addr = m_image_tokens[image_token];
1934 if (image_addr == LLDB_INVALID_ADDRESS)
1935 {
1936 error.SetErrorString("image already unloaded");
1937 }
1938 else
1939 {
1940 DynamicLoader *loader = GetDynamicLoader();
1941 if (loader)
1942 error = loader->CanLoadImage();
1943
1944 if (error.Success())
1945 {
1946 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001947
1948 if (thread_sp)
1949 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001950 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001951
1952 if (frame_sp)
1953 {
1954 ExecutionContext exe_ctx;
1955 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001956 EvaluateExpressionOptions expr_options;
1957 expr_options.SetUnwindOnError(true);
1958 expr_options.SetIgnoreBreakpoints(true);
1959 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001960 StreamString expr;
Daniel Malead01b2952012-11-29 21:49:15 +00001961 expr.Printf("dlclose ((void *)0x%" PRIx64 ")", image_addr);
Greg Clayton8f343b02010-11-04 01:54:29 +00001962 const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001963 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001964 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001965 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001966 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001967 expr.GetData(),
1968 prefix,
1969 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001970 expr_error);
Greg Clayton8f343b02010-11-04 01:54:29 +00001971 if (result_valobj_sp->GetError().Success())
1972 {
1973 Scalar scalar;
Jim Ingham6035b672011-03-31 00:19:25 +00001974 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001975 {
1976 if (scalar.UInt(1))
1977 {
1978 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
1979 }
1980 else
1981 {
1982 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
1983 }
1984 }
1985 }
1986 else
1987 {
1988 error = result_valobj_sp->GetError();
1989 }
1990 }
1991 }
1992 }
1993 }
1994 }
1995 else
1996 {
1997 error.SetErrorString("invalid image token");
1998 }
1999 return error;
2000}
2001
Greg Clayton31f1d2f2011-05-11 18:39:18 +00002002const lldb::ABISP &
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002003Process::GetABI()
2004{
Greg Clayton31f1d2f2011-05-11 18:39:18 +00002005 if (!m_abi_sp)
2006 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
2007 return m_abi_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002008}
2009
Jim Ingham22777012010-09-23 02:01:19 +00002010LanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00002011Process::GetLanguageRuntime(lldb::LanguageType language, bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00002012{
2013 LanguageRuntimeCollection::iterator pos;
2014 pos = m_language_runtimes.find (language);
Jim Inghamab175242012-03-10 00:22:19 +00002015 if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second))
Jim Ingham22777012010-09-23 02:01:19 +00002016 {
Jim Inghamab175242012-03-10 00:22:19 +00002017 lldb::LanguageRuntimeSP runtime_sp(LanguageRuntime::FindPlugin(this, language));
Jim Ingham22777012010-09-23 02:01:19 +00002018
Jim Inghamab175242012-03-10 00:22:19 +00002019 m_language_runtimes[language] = runtime_sp;
2020 return runtime_sp.get();
Jim Ingham22777012010-09-23 02:01:19 +00002021 }
2022 else
2023 return (*pos).second.get();
2024}
2025
2026CPPLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00002027Process::GetCPPLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00002028{
Jim Inghamab175242012-03-10 00:22:19 +00002029 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00002030 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
2031 return static_cast<CPPLanguageRuntime *> (runtime);
2032 return NULL;
2033}
2034
2035ObjCLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00002036Process::GetObjCLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00002037{
Jim Inghamab175242012-03-10 00:22:19 +00002038 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00002039 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
2040 return static_cast<ObjCLanguageRuntime *> (runtime);
2041 return NULL;
2042}
2043
Enrico Granatafd4c84e2012-05-21 16:51:35 +00002044bool
2045Process::IsPossibleDynamicValue (ValueObject& in_value)
2046{
2047 if (in_value.IsDynamic())
2048 return false;
2049 LanguageType known_type = in_value.GetObjectRuntimeLanguage();
2050
2051 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
2052 {
2053 LanguageRuntime *runtime = GetLanguageRuntime (known_type);
2054 return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
2055 }
2056
2057 LanguageRuntime *cpp_runtime = GetLanguageRuntime (eLanguageTypeC_plus_plus);
2058 if (cpp_runtime && cpp_runtime->CouldHaveDynamicValue(in_value))
2059 return true;
2060
2061 LanguageRuntime *objc_runtime = GetLanguageRuntime (eLanguageTypeObjC);
2062 return objc_runtime ? objc_runtime->CouldHaveDynamicValue(in_value) : false;
2063}
2064
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002065BreakpointSiteList &
2066Process::GetBreakpointSiteList()
2067{
2068 return m_breakpoint_site_list;
2069}
2070
2071const BreakpointSiteList &
2072Process::GetBreakpointSiteList() const
2073{
2074 return m_breakpoint_site_list;
2075}
2076
2077
2078void
2079Process::DisableAllBreakpointSites ()
2080{
Greg Claytond8cf1a12013-06-12 00:46:38 +00002081 m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
2082// bp_site->SetEnabled(true);
2083 DisableBreakpointSite(bp_site);
2084 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002085}
2086
2087Error
2088Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
2089{
2090 Error error (DisableBreakpointSiteByID (break_id));
2091
2092 if (error.Success())
2093 m_breakpoint_site_list.Remove(break_id);
2094
2095 return error;
2096}
2097
2098Error
2099Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
2100{
2101 Error error;
2102 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
2103 if (bp_site_sp)
2104 {
2105 if (bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00002106 error = DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002107 }
2108 else
2109 {
Daniel Malead01b2952012-11-29 21:49:15 +00002110 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002111 }
2112
2113 return error;
2114}
2115
2116Error
2117Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
2118{
2119 Error error;
2120 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
2121 if (bp_site_sp)
2122 {
2123 if (!bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00002124 error = EnableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002125 }
2126 else
2127 {
Daniel Malead01b2952012-11-29 21:49:15 +00002128 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002129 }
2130 return error;
2131}
2132
Stephen Wilson50bd94f2010-07-17 00:56:13 +00002133lldb::break_id_t
Greg Claytone1cd1be2012-01-29 20:56:30 +00002134Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002135{
Jim Ingham1460e4b2014-01-10 23:46:59 +00002136 addr_t load_addr = LLDB_INVALID_ADDRESS;
2137
2138 bool show_error = true;
2139 switch (GetState())
2140 {
2141 case eStateInvalid:
2142 case eStateUnloaded:
2143 case eStateConnected:
2144 case eStateAttaching:
2145 case eStateLaunching:
2146 case eStateDetached:
2147 case eStateExited:
2148 show_error = false;
2149 break;
2150
2151 case eStateStopped:
2152 case eStateRunning:
2153 case eStateStepping:
2154 case eStateCrashed:
2155 case eStateSuspended:
2156 show_error = IsAlive();
2157 break;
2158 }
2159
2160 // Reset the IsIndirect flag here, in case the location changes from
2161 // pointing to a indirect symbol to a regular symbol.
2162 owner->SetIsIndirect (false);
2163
2164 if (owner->ShouldResolveIndirectFunctions())
2165 {
2166 Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
2167 if (symbol && symbol->IsIndirect())
2168 {
2169 Error error;
2170 load_addr = ResolveIndirectFunction (&symbol->GetAddress(), error);
2171 if (!error.Success() && show_error)
2172 {
Greg Clayton44d93782014-01-27 23:43:24 +00002173 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2174 symbol->GetAddress().GetLoadAddress(&m_target),
2175 owner->GetBreakpoint().GetID(),
2176 owner->GetID(),
2177 error.AsCString() ? error.AsCString() : "unkown error");
Jim Ingham1460e4b2014-01-10 23:46:59 +00002178 return LLDB_INVALID_BREAK_ID;
2179 }
2180 Address resolved_address(load_addr);
2181 load_addr = resolved_address.GetOpcodeLoadAddress (&m_target);
2182 owner->SetIsIndirect(true);
2183 }
2184 else
2185 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
2186 }
2187 else
2188 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
2189
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002190 if (load_addr != LLDB_INVALID_ADDRESS)
2191 {
2192 BreakpointSiteSP bp_site_sp;
2193
2194 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
2195 // create a new breakpoint site and add it.
2196
2197 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
2198
2199 if (bp_site_sp)
2200 {
2201 bp_site_sp->AddOwner (owner);
2202 owner->SetBreakpointSite (bp_site_sp);
2203 return bp_site_sp->GetID();
2204 }
2205 else
2206 {
Greg Claytonc7bece562013-01-25 18:06:21 +00002207 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, use_hardware));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002208 if (bp_site_sp)
2209 {
Greg Claytoneb023e72013-10-11 19:48:25 +00002210 Error error = EnableBreakpointSite (bp_site_sp.get());
2211 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002212 {
2213 owner->SetBreakpointSite (bp_site_sp);
2214 return m_breakpoint_site_list.Add (bp_site_sp);
2215 }
Greg Claytoneb023e72013-10-11 19:48:25 +00002216 else
2217 {
Greg Claytonfbb76342013-11-20 21:07:01 +00002218 if (show_error)
2219 {
2220 // Report error for setting breakpoint...
Greg Clayton44d93782014-01-27 23:43:24 +00002221 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2222 load_addr,
2223 owner->GetBreakpoint().GetID(),
2224 owner->GetID(),
2225 error.AsCString() ? error.AsCString() : "unkown error");
Greg Claytonfbb76342013-11-20 21:07:01 +00002226 }
Greg Claytoneb023e72013-10-11 19:48:25 +00002227 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002228 }
2229 }
2230 }
2231 // We failed to enable the breakpoint
2232 return LLDB_INVALID_BREAK_ID;
2233
2234}
2235
2236void
2237Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
2238{
2239 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
2240 if (num_owners == 0)
2241 {
Jim Inghamf1ff3bb2013-04-06 00:16:39 +00002242 // Don't try to disable the site if we don't have a live process anymore.
2243 if (IsAlive())
2244 DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002245 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
2246 }
2247}
2248
2249
2250size_t
2251Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
2252{
2253 size_t bytes_removed = 0;
Jim Ingham20c77192011-06-29 19:42:28 +00002254 BreakpointSiteList bp_sites_in_range;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002255
Jim Ingham20c77192011-06-29 19:42:28 +00002256 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002257 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002258 bp_sites_in_range.ForEach([bp_addr, size, buf, &bytes_removed](BreakpointSite *bp_site) -> void {
2259 if (bp_site->GetType() == BreakpointSite::eSoftware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002260 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002261 addr_t intersect_addr;
2262 size_t intersect_size;
2263 size_t opcode_offset;
2264 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
Jim Ingham20c77192011-06-29 19:42:28 +00002265 {
2266 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
2267 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
Greg Claytond8cf1a12013-06-12 00:46:38 +00002268 assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
Jim Ingham20c77192011-06-29 19:42:28 +00002269 size_t buf_offset = intersect_addr - bp_addr;
Greg Claytond8cf1a12013-06-12 00:46:38 +00002270 ::memcpy(buf + buf_offset, bp_site->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
Jim Ingham20c77192011-06-29 19:42:28 +00002271 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002272 }
Greg Claytond8cf1a12013-06-12 00:46:38 +00002273 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002274 }
2275 return bytes_removed;
2276}
2277
2278
Greg Claytonded470d2011-03-19 01:12:21 +00002279
2280size_t
2281Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
2282{
2283 PlatformSP platform_sp (m_target.GetPlatform());
2284 if (platform_sp)
2285 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
2286 return 0;
2287}
2288
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002289Error
2290Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
2291{
2292 Error error;
2293 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00002294 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002295 const addr_t bp_addr = bp_site->GetLoadAddress();
2296 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002297 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002298 if (bp_site->IsEnabled())
2299 {
2300 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002301 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 +00002302 return error;
2303 }
2304
2305 if (bp_addr == LLDB_INVALID_ADDRESS)
2306 {
2307 error.SetErrorString("BreakpointSite contains an invalid load address.");
2308 return error;
2309 }
2310 // Ask the lldb::Process subclass to fill in the correct software breakpoint
2311 // trap for the breakpoint site
2312 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
2313
2314 if (bp_opcode_size == 0)
2315 {
Daniel Malead01b2952012-11-29 21:49:15 +00002316 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%" PRIx64, bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002317 }
2318 else
2319 {
2320 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
2321
2322 if (bp_opcode_bytes == NULL)
2323 {
2324 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
2325 return error;
2326 }
2327
2328 // Save the original opcode by reading it
2329 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
2330 {
2331 // Write a software breakpoint in place of the original opcode
2332 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2333 {
2334 uint8_t verify_bp_opcode_bytes[64];
2335 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2336 {
2337 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
2338 {
2339 bp_site->SetEnabled(true);
2340 bp_site->SetType (BreakpointSite::eSoftware);
2341 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002342 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002343 bp_site->GetID(),
2344 (uint64_t)bp_addr);
2345 }
2346 else
Greg Clayton86edbf42011-10-26 00:56:27 +00002347 error.SetErrorString("failed to verify the breakpoint trap in memory.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002348 }
2349 else
2350 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
2351 }
2352 else
2353 error.SetErrorString("Unable to write breakpoint trap to memory.");
2354 }
2355 else
2356 error.SetErrorString("Unable to read memory at breakpoint address.");
2357 }
Stephen Wilson78a4feb2011-01-12 04:20:03 +00002358 if (log && error.Fail())
Daniel Malead01b2952012-11-29 21:49:15 +00002359 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002360 bp_site->GetID(),
2361 (uint64_t)bp_addr,
2362 error.AsCString());
2363 return error;
2364}
2365
2366Error
2367Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
2368{
2369 Error error;
2370 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00002371 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002372 addr_t bp_addr = bp_site->GetLoadAddress();
2373 lldb::user_id_t breakID = bp_site->GetID();
2374 if (log)
Jim Ingham299c0c12013-02-15 02:06:30 +00002375 log->Printf ("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 ") addr = 0x%" PRIx64, breakID, (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002376
2377 if (bp_site->IsHardware())
2378 {
2379 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
2380 }
2381 else if (bp_site->IsEnabled())
2382 {
2383 const size_t break_op_size = bp_site->GetByteSize();
2384 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
2385 if (break_op_size > 0)
2386 {
2387 // Clear a software breakoint instruction
Greg Claytonc982c762010-07-09 20:39:50 +00002388 uint8_t curr_break_op[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002389 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002390 bool break_op_found = false;
2391
2392 // Read the breakpoint opcode
2393 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
2394 {
2395 bool verify = false;
2396 // Make sure we have the a breakpoint opcode exists at this address
2397 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
2398 {
2399 break_op_found = true;
2400 // We found a valid breakpoint opcode at this address, now restore
2401 // the saved opcode.
2402 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
2403 {
2404 verify = true;
2405 }
2406 else
2407 error.SetErrorString("Memory write failed when restoring original opcode.");
2408 }
2409 else
2410 {
2411 error.SetErrorString("Original breakpoint trap is no longer in memory.");
2412 // Set verify to true and so we can check if the original opcode has already been restored
2413 verify = true;
2414 }
2415
2416 if (verify)
2417 {
Greg Claytonc982c762010-07-09 20:39:50 +00002418 uint8_t verify_opcode[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002419 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002420 // Verify that our original opcode made it back to the inferior
2421 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
2422 {
2423 // compare the memory we just read with the original opcode
2424 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
2425 {
2426 // SUCCESS
2427 bp_site->SetEnabled(false);
2428 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002429 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 +00002430 return error;
2431 }
2432 else
2433 {
2434 if (break_op_found)
2435 error.SetErrorString("Failed to restore original opcode.");
2436 }
2437 }
2438 else
2439 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
2440 }
2441 }
2442 else
2443 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
2444 }
2445 }
2446 else
2447 {
2448 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002449 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 +00002450 return error;
2451 }
2452
2453 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002454 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002455 bp_site->GetID(),
2456 (uint64_t)bp_addr,
2457 error.AsCString());
2458 return error;
2459
2460}
2461
Greg Clayton58be07b2011-01-07 06:08:19 +00002462// Uncomment to verify memory caching works after making changes to caching code
2463//#define VERIFY_MEMORY_READS
2464
Sean Callanan64c0cf22012-06-07 22:26:42 +00002465size_t
2466Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
2467{
Jason Molendaa7b5afa2013-11-15 00:17:32 +00002468 error.Clear();
Sean Callanan64c0cf22012-06-07 22:26:42 +00002469 if (!GetDisableMemoryCache())
2470 {
Greg Clayton58be07b2011-01-07 06:08:19 +00002471#if defined (VERIFY_MEMORY_READS)
Sean Callanan64c0cf22012-06-07 22:26:42 +00002472 // Memory caching is enabled, with debug verification
2473
2474 if (buf && size)
2475 {
2476 // Uncomment the line below to make sure memory caching is working.
2477 // I ran this through the test suite and got no assertions, so I am
2478 // pretty confident this is working well. If any changes are made to
2479 // memory caching, uncomment the line below and test your changes!
2480
2481 // Verify all memory reads by using the cache first, then redundantly
2482 // reading the same memory from the inferior and comparing to make sure
2483 // everything is exactly the same.
2484 std::string verify_buf (size, '\0');
2485 assert (verify_buf.size() == size);
2486 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
2487 Error verify_error;
2488 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
2489 assert (cache_bytes_read == verify_bytes_read);
2490 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
2491 assert (verify_error.Success() == error.Success());
2492 return cache_bytes_read;
2493 }
2494 return 0;
2495#else // !defined(VERIFY_MEMORY_READS)
2496 // Memory caching is enabled, without debug verification
2497
2498 return m_memory_cache.Read (addr, buf, size, error);
2499#endif // defined (VERIFY_MEMORY_READS)
Greg Clayton58be07b2011-01-07 06:08:19 +00002500 }
Sean Callanan64c0cf22012-06-07 22:26:42 +00002501 else
2502 {
2503 // Memory caching is disabled
2504
2505 return ReadMemoryFromInferior (addr, buf, size, error);
2506 }
Greg Clayton58be07b2011-01-07 06:08:19 +00002507}
Greg Clayton58be07b2011-01-07 06:08:19 +00002508
Greg Clayton4c82d422012-05-18 23:20:01 +00002509size_t
2510Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
2511{
Greg Claytonde87c0f2012-05-19 00:18:00 +00002512 char buf[256];
Greg Clayton4c82d422012-05-18 23:20:01 +00002513 out_str.clear();
2514 addr_t curr_addr = addr;
2515 while (1)
2516 {
2517 size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error);
2518 if (length == 0)
2519 break;
2520 out_str.append(buf, length);
2521 // If we got "length - 1" bytes, we didn't get the whole C string, we
2522 // need to read some more characters
2523 if (length == sizeof(buf) - 1)
2524 curr_addr += length;
2525 else
2526 break;
2527 }
2528 return out_str.size();
2529}
2530
Greg Clayton58be07b2011-01-07 06:08:19 +00002531
2532size_t
Ashok Thirumurthi6ac9d132013-04-19 15:58:38 +00002533Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
2534 size_t type_width)
2535{
2536 size_t total_bytes_read = 0;
2537 if (dst && max_bytes && type_width && max_bytes >= type_width)
2538 {
2539 // Ensure a null terminator independent of the number of bytes that is read.
2540 memset (dst, 0, max_bytes);
2541 size_t bytes_left = max_bytes - type_width;
2542
2543 const char terminator[4] = {'\0', '\0', '\0', '\0'};
2544 assert(sizeof(terminator) >= type_width &&
2545 "Attempting to validate a string with more than 4 bytes per character!");
2546
2547 addr_t curr_addr = addr;
2548 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2549 char *curr_dst = dst;
2550
2551 error.Clear();
2552 while (bytes_left > 0 && error.Success())
2553 {
2554 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2555 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2556 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2557
2558 if (bytes_read == 0)
2559 break;
2560
2561 // Search for a null terminator of correct size and alignment in bytes_read
2562 size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2563 for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width)
2564 if (::strncmp(&dst[i], terminator, type_width) == 0)
2565 {
2566 error.Clear();
2567 return i;
2568 }
2569
2570 total_bytes_read += bytes_read;
2571 curr_dst += bytes_read;
2572 curr_addr += bytes_read;
2573 bytes_left -= bytes_read;
2574 }
2575 }
2576 else
2577 {
2578 if (max_bytes)
2579 error.SetErrorString("invalid arguments");
2580 }
2581 return total_bytes_read;
2582}
2583
2584// Deprecated in favor of ReadStringFromMemory which has wchar support and correct code to find
2585// null terminators.
2586size_t
Greg Claytone91b7952011-12-15 03:14:23 +00002587Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Error &result_error)
Greg Clayton8b82f082011-04-12 05:54:46 +00002588{
2589 size_t total_cstr_len = 0;
2590 if (dst && dst_max_len)
2591 {
Greg Claytone91b7952011-12-15 03:14:23 +00002592 result_error.Clear();
Greg Clayton8b82f082011-04-12 05:54:46 +00002593 // NULL out everything just to be safe
2594 memset (dst, 0, dst_max_len);
2595 Error error;
2596 addr_t curr_addr = addr;
2597 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2598 size_t bytes_left = dst_max_len - 1;
2599 char *curr_dst = dst;
2600
2601 while (bytes_left > 0)
2602 {
2603 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2604 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2605 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2606
2607 if (bytes_read == 0)
2608 {
Greg Claytone91b7952011-12-15 03:14:23 +00002609 result_error = error;
Greg Clayton8b82f082011-04-12 05:54:46 +00002610 dst[total_cstr_len] = '\0';
2611 break;
2612 }
2613 const size_t len = strlen(curr_dst);
2614
2615 total_cstr_len += len;
2616
2617 if (len < bytes_to_read)
2618 break;
2619
2620 curr_dst += bytes_read;
2621 curr_addr += bytes_read;
2622 bytes_left -= bytes_read;
2623 }
2624 }
Greg Claytone91b7952011-12-15 03:14:23 +00002625 else
2626 {
2627 if (dst == NULL)
2628 result_error.SetErrorString("invalid arguments");
2629 else
2630 result_error.Clear();
2631 }
Greg Clayton8b82f082011-04-12 05:54:46 +00002632 return total_cstr_len;
2633}
2634
2635size_t
Greg Clayton58be07b2011-01-07 06:08:19 +00002636Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
2637{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002638 if (buf == NULL || size == 0)
2639 return 0;
2640
2641 size_t bytes_read = 0;
2642 uint8_t *bytes = (uint8_t *)buf;
2643
2644 while (bytes_read < size)
2645 {
2646 const size_t curr_size = size - bytes_read;
2647 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
2648 bytes + bytes_read,
2649 curr_size,
2650 error);
2651 bytes_read += curr_bytes_read;
2652 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2653 break;
2654 }
2655
2656 // Replace any software breakpoint opcodes that fall into this range back
2657 // into "buf" before we return
2658 if (bytes_read > 0)
2659 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
2660 return bytes_read;
2661}
2662
Greg Clayton58a4c462010-12-16 20:01:20 +00002663uint64_t
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002664Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
Greg Clayton58a4c462010-12-16 20:01:20 +00002665{
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002666 Scalar scalar;
2667 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
2668 return scalar.ULongLong(fail_value);
2669 return fail_value;
2670}
2671
2672addr_t
2673Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
2674{
2675 Scalar scalar;
2676 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
2677 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2678 return LLDB_INVALID_ADDRESS;
2679}
2680
2681
2682bool
2683Process::WritePointerToMemory (lldb::addr_t vm_addr,
2684 lldb::addr_t ptr_value,
2685 Error &error)
2686{
2687 Scalar scalar;
2688 const uint32_t addr_byte_size = GetAddressByteSize();
2689 if (addr_byte_size <= 4)
2690 scalar = (uint32_t)ptr_value;
Greg Clayton58a4c462010-12-16 20:01:20 +00002691 else
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002692 scalar = ptr_value;
2693 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Clayton58a4c462010-12-16 20:01:20 +00002694}
2695
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002696size_t
2697Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
2698{
2699 size_t bytes_written = 0;
2700 const uint8_t *bytes = (const uint8_t *)buf;
2701
2702 while (bytes_written < size)
2703 {
2704 const size_t curr_size = size - bytes_written;
2705 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
2706 bytes + bytes_written,
2707 curr_size,
2708 error);
2709 bytes_written += curr_bytes_written;
2710 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2711 break;
2712 }
2713 return bytes_written;
2714}
2715
2716size_t
2717Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
2718{
Greg Clayton58be07b2011-01-07 06:08:19 +00002719#if defined (ENABLE_MEMORY_CACHING)
2720 m_memory_cache.Flush (addr, size);
2721#endif
2722
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002723 if (buf == NULL || size == 0)
2724 return 0;
Jim Ingham78a685a2011-04-16 00:01:13 +00002725
Jim Ingham4b536182011-08-09 02:12:22 +00002726 m_mod_id.BumpMemoryID();
Jim Ingham78a685a2011-04-16 00:01:13 +00002727
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002728 // We need to write any data that would go where any current software traps
2729 // (enabled software breakpoints) any software traps (breakpoints) that we
2730 // may have placed in our tasks memory.
2731
Greg Claytond8cf1a12013-06-12 00:46:38 +00002732 BreakpointSiteList bp_sites_in_range;
2733
2734 if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002735 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002736 // No breakpoint sites overlap
2737 if (bp_sites_in_range.IsEmpty())
2738 return WriteMemoryPrivate (addr, buf, size, error);
2739 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002740 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002741 const uint8_t *ubuf = (const uint8_t *)buf;
2742 uint64_t bytes_written = 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002743
Greg Claytond8cf1a12013-06-12 00:46:38 +00002744 bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
2745
2746 if (error.Success())
2747 {
2748 addr_t intersect_addr;
2749 size_t intersect_size;
2750 size_t opcode_offset;
2751 const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2752 assert(intersects);
2753 assert(addr <= intersect_addr && intersect_addr < addr + size);
2754 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
2755 assert(opcode_offset + intersect_size <= bp->GetByteSize());
2756
2757 // Check for bytes before this breakpoint
2758 const addr_t curr_addr = addr + bytes_written;
2759 if (intersect_addr > curr_addr)
2760 {
2761 // There are some bytes before this breakpoint that we need to
2762 // just write to memory
2763 size_t curr_size = intersect_addr - curr_addr;
2764 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2765 ubuf + bytes_written,
2766 curr_size,
2767 error);
2768 bytes_written += curr_bytes_written;
2769 if (curr_bytes_written != curr_size)
2770 {
2771 // We weren't able to write all of the requested bytes, we
2772 // are done looping and will return the number of bytes that
2773 // we have written so far.
2774 if (error.Success())
2775 error.SetErrorToGenericError();
2776 }
2777 }
2778 // Now write any bytes that would cover up any software breakpoints
2779 // directly into the breakpoint opcode buffer
2780 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2781 bytes_written += intersect_size;
2782 }
2783 });
2784
2785 if (bytes_written < size)
2786 bytes_written += WriteMemoryPrivate (addr + bytes_written,
2787 ubuf + bytes_written,
2788 size - bytes_written,
2789 error);
2790 }
2791 }
2792 else
2793 {
2794 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002795 }
2796
2797 // Write any remaining bytes after the last breakpoint if we have any left
Greg Claytond8cf1a12013-06-12 00:46:38 +00002798 return 0; //bytes_written;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002799}
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002800
2801size_t
Greg Claytonc7bece562013-01-25 18:06:21 +00002802Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, size_t byte_size, Error &error)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002803{
2804 if (byte_size == UINT32_MAX)
2805 byte_size = scalar.GetByteSize();
2806 if (byte_size > 0)
2807 {
2808 uint8_t buf[32];
2809 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2810 if (mem_size > 0)
2811 return WriteMemory(addr, buf, mem_size, error);
2812 else
2813 error.SetErrorString ("failed to get scalar as memory data");
2814 }
2815 else
2816 {
2817 error.SetErrorString ("invalid scalar value");
2818 }
2819 return 0;
2820}
2821
2822size_t
2823Process::ReadScalarIntegerFromMemory (addr_t addr,
2824 uint32_t byte_size,
2825 bool is_signed,
2826 Scalar &scalar,
2827 Error &error)
2828{
Greg Clayton7060f892013-05-01 23:41:30 +00002829 uint64_t uval = 0;
2830 if (byte_size == 0)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002831 {
Greg Clayton7060f892013-05-01 23:41:30 +00002832 error.SetErrorString ("byte size is zero");
2833 }
2834 else if (byte_size & (byte_size - 1))
2835 {
2836 error.SetErrorStringWithFormat ("byte size %u is not a power of 2", byte_size);
2837 }
2838 else if (byte_size <= sizeof(uval))
2839 {
2840 const size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002841 if (bytes_read == byte_size)
2842 {
2843 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
Greg Claytonc7bece562013-01-25 18:06:21 +00002844 lldb::offset_t offset = 0;
Greg Clayton7060f892013-05-01 23:41:30 +00002845 if (byte_size <= 4)
2846 scalar = data.GetMaxU32 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002847 else
Greg Clayton7060f892013-05-01 23:41:30 +00002848 scalar = data.GetMaxU64 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002849 if (is_signed)
2850 scalar.SignExtend(byte_size * 8);
2851 return bytes_read;
2852 }
2853 }
2854 else
2855 {
2856 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2857 }
2858 return 0;
2859}
2860
Greg Claytond495c532011-05-17 03:37:42 +00002861#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002862addr_t
2863Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2864{
Jim Inghamf72ce3a2011-06-20 17:32:44 +00002865 if (GetPrivateState() != eStateStopped)
2866 return LLDB_INVALID_ADDRESS;
2867
Greg Claytond495c532011-05-17 03:37:42 +00002868#if defined (USE_ALLOCATE_MEMORY_CACHE)
2869 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2870#else
Greg Claytonb2daec92011-01-23 19:58:49 +00002871 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
Greg Clayton5160ce52013-03-27 23:08:40 +00002872 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002873 if (log)
Greg Clayton45989072013-10-23 18:24:30 +00002874 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 +00002875 (uint64_t)size,
Greg Claytond495c532011-05-17 03:37:42 +00002876 GetPermissionsAsCString (permissions),
Greg Claytonb2daec92011-01-23 19:58:49 +00002877 (uint64_t)allocated_addr,
Jim Ingham4b536182011-08-09 02:12:22 +00002878 m_mod_id.GetStopID(),
2879 m_mod_id.GetMemoryID());
Greg Claytonb2daec92011-01-23 19:58:49 +00002880 return allocated_addr;
Greg Claytond495c532011-05-17 03:37:42 +00002881#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002882}
2883
Sean Callanan90539452011-09-20 23:01:51 +00002884bool
2885Process::CanJIT ()
2886{
Sean Callanana7b443a2012-02-14 22:50:38 +00002887 if (m_can_jit == eCanJITDontKnow)
2888 {
2889 Error err;
2890
2891 uint64_t allocated_memory = AllocateMemory(8,
2892 ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2893 err);
2894
2895 if (err.Success())
2896 m_can_jit = eCanJITYes;
2897 else
2898 m_can_jit = eCanJITNo;
2899
2900 DeallocateMemory (allocated_memory);
2901 }
2902
Sean Callanan90539452011-09-20 23:01:51 +00002903 return m_can_jit == eCanJITYes;
2904}
2905
2906void
2907Process::SetCanJIT (bool can_jit)
2908{
2909 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2910}
2911
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002912Error
2913Process::DeallocateMemory (addr_t ptr)
2914{
Greg Claytond495c532011-05-17 03:37:42 +00002915 Error error;
2916#if defined (USE_ALLOCATE_MEMORY_CACHE)
2917 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
2918 {
Daniel Malead01b2952012-11-29 21:49:15 +00002919 error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
Greg Claytond495c532011-05-17 03:37:42 +00002920 }
2921#else
2922 error = DoDeallocateMemory (ptr);
Greg Claytonb2daec92011-01-23 19:58:49 +00002923
Greg Clayton5160ce52013-03-27 23:08:40 +00002924 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002925 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002926 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 +00002927 ptr,
2928 error.AsCString("SUCCESS"),
Jim Ingham4b536182011-08-09 02:12:22 +00002929 m_mod_id.GetStopID(),
2930 m_mod_id.GetMemoryID());
Greg Claytond495c532011-05-17 03:37:42 +00002931#endif
Greg Claytonb2daec92011-01-23 19:58:49 +00002932 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002933}
2934
Han Ming Ongc811d382012-11-17 00:33:14 +00002935
Greg Claytonc9660542012-02-05 02:38:54 +00002936ModuleSP
Greg Claytonc859e2d2012-02-13 23:10:39 +00002937Process::ReadModuleFromMemory (const FileSpec& file_spec,
Andrew MacPherson17220c12014-03-05 10:12:43 +00002938 lldb::addr_t header_addr,
2939 size_t size_to_read)
Greg Claytonc9660542012-02-05 02:38:54 +00002940{
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002941 ModuleSP module_sp (new Module (file_spec, ArchSpec()));
Greg Claytonc9660542012-02-05 02:38:54 +00002942 if (module_sp)
2943 {
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002944 Error error;
Andrew MacPherson17220c12014-03-05 10:12:43 +00002945 ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error, size_to_read);
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002946 if (objfile)
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002947 return module_sp;
Greg Claytonc9660542012-02-05 02:38:54 +00002948 }
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002949 return ModuleSP();
Greg Claytonc9660542012-02-05 02:38:54 +00002950}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002951
2952Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002953Process::EnableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002954{
2955 Error error;
2956 error.SetErrorString("watchpoints are not supported");
2957 return error;
2958}
2959
2960Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002961Process::DisableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002962{
2963 Error error;
2964 error.SetErrorString("watchpoints are not supported");
2965 return error;
2966}
2967
2968StateType
2969Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
2970{
2971 StateType state;
2972 // Now wait for the process to launch and return control to us, and then
2973 // call DidLaunch:
2974 while (1)
2975 {
Greg Clayton6779606a2011-01-22 23:43:18 +00002976 event_sp.reset();
2977 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
2978
Greg Clayton2637f822011-11-17 01:23:07 +00002979 if (StateIsStoppedState(state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002980 break;
Greg Clayton6779606a2011-01-22 23:43:18 +00002981
2982 // If state is invalid, then we timed out
2983 if (state == eStateInvalid)
2984 break;
2985
2986 if (event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002987 HandlePrivateEvent (event_sp);
2988 }
2989 return state;
2990}
2991
2992Error
Greg Claytonfbb76342013-11-20 21:07:01 +00002993Process::Launch (ProcessLaunchInfo &launch_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002994{
2995 Error error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002996 m_abi_sp.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002997 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002998 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002999 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003000 m_os_ap.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003001 m_process_input_reader.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003002
Greg Claytonaa149cb2011-08-11 02:48:45 +00003003 Module *exe_module = m_target.GetExecutableModulePointer();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003004 if (exe_module)
3005 {
Greg Clayton2289fa42011-04-30 01:09:13 +00003006 char local_exec_file_path[PATH_MAX];
3007 char platform_exec_file_path[PATH_MAX];
3008 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
3009 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003010 if (exe_module->GetFileSpec().Exists())
3011 {
Greg Claytonfbb76342013-11-20 21:07:01 +00003012 // Install anything that might need to be installed prior to launching.
3013 // For host systems, this will do nothing, but if we are connected to a
3014 // remote platform it will install any needed binaries
3015 error = GetTarget().Install(&launch_info);
3016 if (error.Fail())
3017 return error;
3018
Greg Clayton71337622011-02-24 22:24:29 +00003019 if (PrivateStateThreadIsValid ())
3020 PausePrivateStateThread ();
3021
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003022 error = WillLaunch (exe_module);
3023 if (error.Success())
3024 {
Jim Ingham221d51c2013-05-08 00:35:16 +00003025 const bool restarted = false;
3026 SetPublicState (eStateLaunching, restarted);
Greg Claytone24c4ac2011-11-17 04:46:02 +00003027 m_should_detach = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003028
Ed Maste64fad602013-07-29 20:58:06 +00003029 if (m_public_run_lock.TrySetRunning())
Greg Clayton69fd4be2012-09-04 20:29:05 +00003030 {
3031 // Now launch using these arguments.
3032 error = DoLaunch (exe_module, launch_info);
3033 }
3034 else
3035 {
3036 // This shouldn't happen
3037 error.SetErrorString("failed to acquire process run lock");
3038 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003039
3040 if (error.Fail())
3041 {
3042 if (GetID() != LLDB_INVALID_PROCESS_ID)
3043 {
3044 SetID (LLDB_INVALID_PROCESS_ID);
3045 const char *error_string = error.AsCString();
3046 if (error_string == NULL)
3047 error_string = "launch failed";
3048 SetExitStatus (-1, error_string);
3049 }
3050 }
3051 else
3052 {
3053 EventSP event_sp;
Greg Clayton1a38ea72011-06-22 01:42:17 +00003054 TimeValue timeout_time;
3055 timeout_time = TimeValue::Now();
3056 timeout_time.OffsetWithSeconds(10);
3057 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003058
Greg Clayton1a38ea72011-06-22 01:42:17 +00003059 if (state == eStateInvalid || event_sp.get() == NULL)
3060 {
3061 // We were able to launch the process, but we failed to
3062 // catch the initial stop.
3063 SetExitStatus (0, "failed to catch stop after launch");
3064 Destroy();
3065 }
3066 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003067 {
Greg Clayton93d3c8332011-02-16 04:46:07 +00003068
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003069 DidLaunch ();
3070
Greg Claytonc859e2d2012-02-13 23:10:39 +00003071 DynamicLoader *dyld = GetDynamicLoader ();
3072 if (dyld)
3073 dyld->DidLaunch();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003074
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003075 GetJITLoaders().DidLaunch();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003076
Jason Molendaeef51062013-11-05 03:57:19 +00003077 SystemRuntime *system_runtime = GetSystemRuntime ();
3078 if (system_runtime)
3079 system_runtime->DidLaunch();
3080
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003081 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003082 // This delays passing the stopped event to listeners till DidLaunch gets
3083 // a chance to complete...
3084 HandlePrivateEvent (event_sp);
Greg Clayton71337622011-02-24 22:24:29 +00003085
3086 if (PrivateStateThreadIsValid ())
3087 ResumePrivateStateThread ();
3088 else
3089 StartPrivateStateThread ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003090 }
3091 else if (state == eStateExited)
3092 {
3093 // We exited while trying to launch somehow. Don't call DidLaunch as that's
3094 // not likely to work, and return an invalid pid.
3095 HandlePrivateEvent (event_sp);
3096 }
3097 }
3098 }
3099 }
3100 else
3101 {
Greg Clayton86edbf42011-10-26 00:56:27 +00003102 error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003103 }
3104 }
3105 return error;
3106}
3107
Greg Claytonc3776bf2012-02-09 06:16:32 +00003108
3109Error
3110Process::LoadCore ()
3111{
3112 Error error = DoLoadCore();
3113 if (error.Success())
3114 {
3115 if (PrivateStateThreadIsValid ())
3116 ResumePrivateStateThread ();
3117 else
3118 StartPrivateStateThread ();
3119
Greg Claytonc859e2d2012-02-13 23:10:39 +00003120 DynamicLoader *dyld = GetDynamicLoader ();
3121 if (dyld)
3122 dyld->DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003123
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003124 GetJITLoaders().DidAttach();
Greg Claytonc859e2d2012-02-13 23:10:39 +00003125
Jason Molendaeef51062013-11-05 03:57:19 +00003126 SystemRuntime *system_runtime = GetSystemRuntime ();
3127 if (system_runtime)
3128 system_runtime->DidAttach();
3129
Greg Claytonc859e2d2012-02-13 23:10:39 +00003130 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Claytonc3776bf2012-02-09 06:16:32 +00003131 // We successfully loaded a core file, now pretend we stopped so we can
3132 // show all of the threads in the core file and explore the crashed
3133 // state.
3134 SetPrivateState (eStateStopped);
3135
3136 }
3137 return error;
3138}
3139
Greg Claytonc859e2d2012-02-13 23:10:39 +00003140DynamicLoader *
3141Process::GetDynamicLoader ()
3142{
3143 if (m_dyld_ap.get() == NULL)
3144 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
3145 return m_dyld_ap.get();
3146}
Greg Claytonc3776bf2012-02-09 06:16:32 +00003147
Andrew MacPherson17220c12014-03-05 10:12:43 +00003148JITLoaderList &
3149Process::GetJITLoaders ()
3150{
3151 if (!m_jit_loaders_ap)
3152 {
3153 m_jit_loaders_ap.reset(new JITLoaderList());
3154 JITLoader::LoadPlugins(this, *m_jit_loaders_ap);
3155 }
3156 return *m_jit_loaders_ap;
3157}
3158
Jason Molendaeef51062013-11-05 03:57:19 +00003159SystemRuntime *
3160Process::GetSystemRuntime ()
3161{
3162 if (m_system_runtime_ap.get() == NULL)
3163 m_system_runtime_ap.reset (SystemRuntime::FindPlugin(this));
3164 return m_system_runtime_ap.get();
3165}
3166
Greg Claytonc3776bf2012-02-09 06:16:32 +00003167
Jim Inghambb3a2832011-01-29 01:49:25 +00003168Process::NextEventAction::EventActionResult
3169Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003170{
Jim Inghambb3a2832011-01-29 01:49:25 +00003171 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
3172 switch (state)
Greg Clayton19388cf2010-10-18 01:45:30 +00003173 {
Greg Clayton513c26c2011-01-29 07:10:55 +00003174 case eStateRunning:
Greg Clayton71337622011-02-24 22:24:29 +00003175 case eStateConnected:
Greg Clayton513c26c2011-01-29 07:10:55 +00003176 return eEventActionRetry;
3177
3178 case eStateStopped:
3179 case eStateCrashed:
Greg Claytonc9ed4782011-11-12 02:10:56 +00003180 {
3181 // During attach, prior to sending the eStateStopped event,
Jim Inghamb1e2e842012-04-12 18:49:31 +00003182 // lldb_private::Process subclasses must set the new process ID.
Greg Claytonc9ed4782011-11-12 02:10:56 +00003183 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
Jim Ingham221d51c2013-05-08 00:35:16 +00003184 // We don't want these events to be reported, so go set the ShouldReportStop here:
3185 m_process->GetThreadList().SetShouldReportStop (eVoteNo);
3186
Greg Claytonc9ed4782011-11-12 02:10:56 +00003187 if (m_exec_count > 0)
3188 {
3189 --m_exec_count;
Jim Ingham221d51c2013-05-08 00:35:16 +00003190 RequestResume();
Greg Claytonc9ed4782011-11-12 02:10:56 +00003191 return eEventActionRetry;
3192 }
3193 else
3194 {
3195 m_process->CompleteAttach ();
3196 return eEventActionSuccess;
3197 }
3198 }
Greg Clayton513c26c2011-01-29 07:10:55 +00003199 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003200
Greg Clayton513c26c2011-01-29 07:10:55 +00003201 default:
3202 case eStateExited:
3203 case eStateInvalid:
Greg Clayton513c26c2011-01-29 07:10:55 +00003204 break;
Jim Inghambb3a2832011-01-29 01:49:25 +00003205 }
Greg Claytonc9ed4782011-11-12 02:10:56 +00003206
3207 m_exit_string.assign ("No valid Process");
3208 return eEventActionExit;
Jim Inghambb3a2832011-01-29 01:49:25 +00003209}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003210
Jim Inghambb3a2832011-01-29 01:49:25 +00003211Process::NextEventAction::EventActionResult
3212Process::AttachCompletionHandler::HandleBeingInterrupted()
3213{
3214 return eEventActionSuccess;
3215}
3216
3217const char *
3218Process::AttachCompletionHandler::GetExitString ()
3219{
3220 return m_exit_string.c_str();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003221}
3222
3223Error
Greg Clayton144f3a92011-11-15 03:53:30 +00003224Process::Attach (ProcessAttachInfo &attach_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003225{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003226 m_abi_sp.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003227 m_process_input_reader.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003228 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003229 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00003230 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003231 m_os_ap.reset();
Jim Ingham5aee1622010-08-09 23:31:02 +00003232
Greg Clayton144f3a92011-11-15 03:53:30 +00003233 lldb::pid_t attach_pid = attach_info.GetProcessID();
Greg Claytone996fd32011-03-08 22:40:15 +00003234 Error error;
Greg Clayton144f3a92011-11-15 03:53:30 +00003235 if (attach_pid == LLDB_INVALID_PROCESS_ID)
Jim Ingham5aee1622010-08-09 23:31:02 +00003236 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003237 char process_name[PATH_MAX];
Jim Ingham4299fdb2011-09-15 01:10:17 +00003238
Greg Clayton144f3a92011-11-15 03:53:30 +00003239 if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
Jim Ingham2ecb7422010-08-17 21:54:19 +00003240 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003241 const bool wait_for_launch = attach_info.GetWaitForLaunch();
3242
3243 if (wait_for_launch)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003244 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003245 error = WillAttachToProcessWithName(process_name, wait_for_launch);
3246 if (error.Success())
3247 {
Ed Maste64fad602013-07-29 20:58:06 +00003248 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00003249 {
3250 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00003251 const bool restarted = false;
3252 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00003253 // Now attach using these arguments.
Jean-Daniel Dupas9c517c02013-12-23 22:32:54 +00003254 error = DoAttachToProcessWithName (process_name, attach_info);
Greg Clayton926cce72012-10-12 16:10:12 +00003255 }
3256 else
3257 {
3258 // This shouldn't happen
3259 error.SetErrorString("failed to acquire process run lock");
3260 }
Greg Claytone24c4ac2011-11-17 04:46:02 +00003261
Greg Clayton144f3a92011-11-15 03:53:30 +00003262 if (error.Fail())
3263 {
3264 if (GetID() != LLDB_INVALID_PROCESS_ID)
3265 {
3266 SetID (LLDB_INVALID_PROCESS_ID);
3267 if (error.AsCString() == NULL)
3268 error.SetErrorString("attach failed");
3269
3270 SetExitStatus(-1, error.AsCString());
3271 }
3272 }
3273 else
3274 {
3275 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3276 StartPrivateStateThread();
3277 }
3278 return error;
3279 }
Greg Claytone996fd32011-03-08 22:40:15 +00003280 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003281 else
Greg Claytone996fd32011-03-08 22:40:15 +00003282 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003283 ProcessInstanceInfoList process_infos;
3284 PlatformSP platform_sp (m_target.GetPlatform ());
3285
3286 if (platform_sp)
3287 {
3288 ProcessInstanceInfoMatch match_info;
3289 match_info.GetProcessInfo() = attach_info;
3290 match_info.SetNameMatchType (eNameMatchEquals);
3291 platform_sp->FindProcesses (match_info, process_infos);
3292 const uint32_t num_matches = process_infos.GetSize();
3293 if (num_matches == 1)
3294 {
3295 attach_pid = process_infos.GetProcessIDAtIndex(0);
3296 // Fall through and attach using the above process ID
3297 }
3298 else
3299 {
3300 match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
3301 if (num_matches > 1)
3302 error.SetErrorStringWithFormat ("more than one process named %s", process_name);
3303 else
3304 error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
3305 }
3306 }
3307 else
3308 {
3309 error.SetErrorString ("invalid platform, can't find processes by name");
3310 return error;
3311 }
Greg Claytone996fd32011-03-08 22:40:15 +00003312 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003313 }
3314 else
Greg Clayton144f3a92011-11-15 03:53:30 +00003315 {
3316 error.SetErrorString ("invalid process name");
Greg Claytone996fd32011-03-08 22:40:15 +00003317 }
3318 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003319
3320 if (attach_pid != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00003321 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003322 error = WillAttachToProcessWithID(attach_pid);
Greg Claytone996fd32011-03-08 22:40:15 +00003323 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003324 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003325
Ed Maste64fad602013-07-29 20:58:06 +00003326 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00003327 {
3328 // Now attach using these arguments.
3329 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00003330 const bool restarted = false;
3331 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00003332 error = DoAttachToProcessWithID (attach_pid, attach_info);
3333 }
3334 else
3335 {
3336 // This shouldn't happen
3337 error.SetErrorString("failed to acquire process run lock");
3338 }
3339
Greg Clayton144f3a92011-11-15 03:53:30 +00003340 if (error.Success())
3341 {
3342
3343 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3344 StartPrivateStateThread();
3345 }
3346 else
Greg Claytone996fd32011-03-08 22:40:15 +00003347 {
3348 if (GetID() != LLDB_INVALID_PROCESS_ID)
3349 {
3350 SetID (LLDB_INVALID_PROCESS_ID);
3351 const char *error_string = error.AsCString();
3352 if (error_string == NULL)
3353 error_string = "attach failed";
3354
3355 SetExitStatus(-1, error_string);
3356 }
3357 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003358 }
3359 }
3360 return error;
3361}
3362
Greg Clayton93d3c8332011-02-16 04:46:07 +00003363void
3364Process::CompleteAttach ()
3365{
3366 // Let the process subclass figure out at much as it can about the process
3367 // before we go looking for a dynamic loader plug-in.
3368 DidAttach();
3369
Jim Ingham4299fdb2011-09-15 01:10:17 +00003370 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't
3371 // the same as the one we've already set, switch architectures.
3372 PlatformSP platform_sp (m_target.GetPlatform ());
3373 assert (platform_sp.get());
3374 if (platform_sp)
3375 {
Greg Clayton70512312012-05-08 01:45:38 +00003376 const ArchSpec &target_arch = m_target.GetArchitecture();
Greg Clayton1e0c8842013-01-11 20:49:54 +00003377 if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture (target_arch, false, NULL))
Greg Clayton70512312012-05-08 01:45:38 +00003378 {
3379 ArchSpec platform_arch;
3380 platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch);
3381 if (platform_sp)
3382 {
3383 m_target.SetPlatform (platform_sp);
3384 m_target.SetArchitecture(platform_arch);
3385 }
3386 }
3387 else
3388 {
3389 ProcessInstanceInfo process_info;
3390 platform_sp->GetProcessInfo (GetID(), process_info);
3391 const ArchSpec &process_arch = process_info.GetArchitecture();
Sean Callananbf4b7be2012-12-13 22:07:14 +00003392 if (process_arch.IsValid() && !m_target.GetArchitecture().IsExactMatch(process_arch))
Greg Clayton70512312012-05-08 01:45:38 +00003393 m_target.SetArchitecture (process_arch);
3394 }
Jim Ingham4299fdb2011-09-15 01:10:17 +00003395 }
3396
3397 // We have completed the attach, now it is time to find the dynamic loader
Greg Clayton93d3c8332011-02-16 04:46:07 +00003398 // plug-in
Greg Claytonc859e2d2012-02-13 23:10:39 +00003399 DynamicLoader *dyld = GetDynamicLoader ();
3400 if (dyld)
3401 dyld->DidAttach();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003402
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003403 GetJITLoaders().DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003404
Jason Molendaeef51062013-11-05 03:57:19 +00003405 SystemRuntime *system_runtime = GetSystemRuntime ();
3406 if (system_runtime)
3407 system_runtime->DidAttach();
3408
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003409 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00003410 // Figure out which one is the executable, and set that in our target:
Enrico Granata17598482012-11-08 02:22:02 +00003411 const ModuleList &target_modules = m_target.GetImages();
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003412 Mutex::Locker modules_locker(target_modules.GetMutex());
3413 size_t num_modules = target_modules.GetSize();
3414 ModuleSP new_executable_module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003415
Andy Gibbsa297a972013-06-19 19:04:53 +00003416 for (size_t i = 0; i < num_modules; i++)
Greg Clayton93d3c8332011-02-16 04:46:07 +00003417 {
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003418 ModuleSP module_sp (target_modules.GetModuleAtIndexUnlocked (i));
Greg Clayton8b82f082011-04-12 05:54:46 +00003419 if (module_sp && module_sp->IsExecutable())
Greg Clayton93d3c8332011-02-16 04:46:07 +00003420 {
Greg Claytonaa149cb2011-08-11 02:48:45 +00003421 if (m_target.GetExecutableModulePointer() != module_sp.get())
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003422 new_executable_module_sp = module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003423 break;
3424 }
3425 }
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003426 if (new_executable_module_sp)
3427 m_target.SetExecutableModule (new_executable_module_sp, false);
Greg Clayton93d3c8332011-02-16 04:46:07 +00003428}
3429
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003430Error
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003431Process::ConnectRemote (Stream *strm, const char *remote_url)
Greg Claytonb766a732011-02-04 01:58:07 +00003432{
Greg Claytonb766a732011-02-04 01:58:07 +00003433 m_abi_sp.reset();
3434 m_process_input_reader.reset();
3435
3436 // Find the process and its architecture. Make sure it matches the architecture
3437 // of the current Target, and if not adjust it.
3438
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003439 Error error (DoConnectRemote (strm, remote_url));
Greg Claytonb766a732011-02-04 01:58:07 +00003440 if (error.Success())
3441 {
Greg Clayton71337622011-02-24 22:24:29 +00003442 if (GetID() != LLDB_INVALID_PROCESS_ID)
3443 {
Greg Clayton32e0a752011-03-30 18:16:51 +00003444 EventSP event_sp;
3445 StateType state = WaitForProcessStopPrivate(NULL, event_sp);
3446
3447 if (state == eStateStopped || state == eStateCrashed)
3448 {
3449 // If we attached and actually have a process on the other end, then
3450 // this ended up being the equivalent of an attach.
3451 CompleteAttach ();
3452
3453 // This delays passing the stopped event to listeners till
3454 // CompleteAttach gets a chance to complete...
3455 HandlePrivateEvent (event_sp);
3456
3457 }
Greg Clayton71337622011-02-24 22:24:29 +00003458 }
Greg Clayton32e0a752011-03-30 18:16:51 +00003459
3460 if (PrivateStateThreadIsValid ())
3461 ResumePrivateStateThread ();
3462 else
3463 StartPrivateStateThread ();
Greg Claytonb766a732011-02-04 01:58:07 +00003464 }
3465 return error;
3466}
3467
3468
3469Error
Jim Ingham3b8285d2012-04-19 01:40:33 +00003470Process::PrivateResume ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003471{
Greg Clayton5160ce52013-03-27 23:08:40 +00003472 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_STEP));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003473 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003474 log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s private state: %s",
Jim Ingham4b536182011-08-09 02:12:22 +00003475 m_mod_id.GetStopID(),
Jim Ingham444586b2011-01-24 06:34:17 +00003476 StateAsCString(m_public_state.GetValue()),
3477 StateAsCString(m_private_state.GetValue()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003478
3479 Error error (WillResume());
3480 // Tell the process it is about to resume before the thread list
3481 if (error.Success())
3482 {
Johnny Chenc4221e42010-12-02 20:53:05 +00003483 // Now let the thread list know we are about to resume so it
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003484 // can let all of our threads know that they are about to be
3485 // resumed. Threads will each be called with
3486 // Thread::WillResume(StateType) where StateType contains the state
3487 // that they are supposed to have when the process is resumed
3488 // (suspended/running/stepping). Threads should also check
3489 // their resume signal in lldb::Thread::GetResumeSignal()
Jim Ingham221d51c2013-05-08 00:35:16 +00003490 // to see if they are supposed to start back up with a signal.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003491 if (m_thread_list.WillResume())
3492 {
Jim Ingham372787f2012-04-07 00:00:41 +00003493 // Last thing, do the PreResumeActions.
3494 if (!RunPreResumeActions())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003495 {
Jim Ingham0161b492013-02-09 01:29:05 +00003496 error.SetErrorStringWithFormat ("Process::PrivateResume PreResumeActions failed, not resuming.");
Jim Ingham372787f2012-04-07 00:00:41 +00003497 }
3498 else
3499 {
3500 m_mod_id.BumpResumeID();
3501 error = DoResume();
3502 if (error.Success())
3503 {
3504 DidResume();
3505 m_thread_list.DidResume();
3506 if (log)
3507 log->Printf ("Process thinks the process has resumed.");
3508 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003509 }
3510 }
3511 else
3512 {
Jim Ingham513c6bb2012-09-01 01:02:41 +00003513 // Somebody wanted to run without running. So generate a continue & a stopped event,
3514 // and let the world handle them.
3515 if (log)
3516 log->Printf ("Process::PrivateResume() asked to simulate a start & stop.");
3517
3518 SetPrivateState(eStateRunning);
3519 SetPrivateState(eStateStopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003520 }
3521 }
Jim Ingham444586b2011-01-24 06:34:17 +00003522 else if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003523 log->Printf ("Process::PrivateResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003524 return error;
3525}
3526
3527Error
Greg Claytonf9b57b92013-05-10 23:48:10 +00003528Process::Halt (bool clear_thread_plans)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003529{
Greg Claytonf9b57b92013-05-10 23:48:10 +00003530 // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
3531 // in case it was already set and some thread plan logic calls halt on its
3532 // own.
3533 m_clear_thread_plans_on_stop |= clear_thread_plans;
3534
Jim Inghamaacc3182012-06-06 00:29:30 +00003535 // First make sure we aren't in the middle of handling an event, or we might restart. This is pretty weak, since
3536 // we could just straightaway get another event. It just narrows the window...
3537 m_currently_handling_event.WaitForValueEqualTo(false);
3538
3539
Jim Inghambb3a2832011-01-29 01:49:25 +00003540 // Pause our private state thread so we can ensure no one else eats
3541 // the stop event out from under us.
Jim Ingham0f16e732011-02-08 05:20:59 +00003542 Listener halt_listener ("lldb.process.halt_listener");
3543 HijackPrivateProcessEvents(&halt_listener);
Greg Clayton3af9ea52010-11-18 05:57:03 +00003544
Jim Inghambb3a2832011-01-29 01:49:25 +00003545 EventSP event_sp;
Greg Clayton513c26c2011-01-29 07:10:55 +00003546 Error error (WillHalt());
Jim Inghambb3a2832011-01-29 01:49:25 +00003547
Greg Clayton513c26c2011-01-29 07:10:55 +00003548 if (error.Success())
Jim Inghambb3a2832011-01-29 01:49:25 +00003549 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003550
Greg Clayton513c26c2011-01-29 07:10:55 +00003551 bool caused_stop = false;
3552
3553 // Ask the process subclass to actually halt our process
3554 error = DoHalt(caused_stop);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003555 if (error.Success())
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003556 {
Greg Clayton513c26c2011-01-29 07:10:55 +00003557 if (m_public_state.GetValue() == eStateAttaching)
3558 {
3559 SetExitStatus(SIGKILL, "Cancelled async attach.");
3560 Destroy ();
3561 }
3562 else
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003563 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003564 // If "caused_stop" is true, then DoHalt stopped the process. If
3565 // "caused_stop" is false, the process was already stopped.
3566 // If the DoHalt caused the process to stop, then we want to catch
3567 // this event and set the interrupted bool to true before we pass
3568 // this along so clients know that the process was interrupted by
3569 // a halt command.
3570 if (caused_stop)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003571 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003572 // Wait for 1 second for the process to stop.
Jim Inghambb3a2832011-01-29 01:49:25 +00003573 TimeValue timeout_time;
3574 timeout_time = TimeValue::Now();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003575 timeout_time.OffsetWithSeconds(10);
Jim Ingham0f16e732011-02-08 05:20:59 +00003576 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
3577 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00003578
Jim Ingham0f16e732011-02-08 05:20:59 +00003579 if (!got_event || state == eStateInvalid)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003580 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003581 // We timeout out and didn't get a stop event...
Jim Ingham0f16e732011-02-08 05:20:59 +00003582 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
Greg Clayton3af9ea52010-11-18 05:57:03 +00003583 }
3584 else
3585 {
Greg Clayton2637f822011-11-17 01:23:07 +00003586 if (StateIsStoppedState (state, false))
Jim Inghambb3a2832011-01-29 01:49:25 +00003587 {
3588 // We caused the process to interrupt itself, so mark this
3589 // as such in the stop event so clients can tell an interrupted
3590 // process from a natural stop
3591 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
3592 }
3593 else
3594 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003595 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Inghambb3a2832011-01-29 01:49:25 +00003596 if (log)
3597 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3598 error.SetErrorString ("Did not get stopped event after halt.");
3599 }
Greg Clayton3af9ea52010-11-18 05:57:03 +00003600 }
3601 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003602 DidHalt();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003603 }
3604 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003605 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003606 // Resume our private state thread before we post the event (if any)
Jim Ingham0f16e732011-02-08 05:20:59 +00003607 RestorePrivateProcessEvents();
Jim Inghambb3a2832011-01-29 01:49:25 +00003608
3609 // Post any event we might have consumed. If all goes well, we will have
3610 // stopped the process, intercepted the event and set the interrupted
3611 // bool in the event. Post it to the private event queue and that will end up
3612 // correctly setting the state.
3613 if (event_sp)
3614 m_private_state_broadcaster.BroadcastEvent(event_sp);
3615
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003616 return error;
3617}
3618
3619Error
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003620Process::HaltForDestroyOrDetach(lldb::EventSP &exit_event_sp)
3621{
3622 Error error;
3623 if (m_public_state.GetValue() == eStateRunning)
3624 {
3625 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3626 if (log)
3627 log->Printf("Process::Destroy() About to halt.");
3628 error = Halt();
3629 if (error.Success())
3630 {
3631 // Consume the halt event.
3632 TimeValue timeout (TimeValue::Now());
3633 timeout.OffsetWithSeconds(1);
3634 StateType state = WaitForProcessToStop (&timeout, &exit_event_sp);
3635
3636 // If the process exited while we were waiting for it to stop, put the exited event into
3637 // the shared pointer passed in and return. Our caller doesn't need to do anything else, since
3638 // they don't have a process anymore...
3639
3640 if (state == eStateExited || m_private_state.GetValue() == eStateExited)
3641 {
3642 if (log)
3643 log->Printf("Process::HaltForDestroyOrDetach() Process exited while waiting to Halt.");
3644 return error;
3645 }
3646 else
3647 exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3648
3649 if (state != eStateStopped)
3650 {
3651 if (log)
3652 log->Printf("Process::HaltForDestroyOrDetach() Halt failed to stop, state is: %s", StateAsCString(state));
3653 // If we really couldn't stop the process then we should just error out here, but if the
3654 // lower levels just bobbled sending the event and we really are stopped, then continue on.
3655 StateType private_state = m_private_state.GetValue();
3656 if (private_state != eStateStopped)
3657 {
3658 return error;
3659 }
3660 }
3661 }
3662 else
3663 {
3664 if (log)
3665 log->Printf("Process::HaltForDestroyOrDetach() Halt got error: %s", error.AsCString());
3666 }
3667 }
3668 return error;
3669}
3670
3671Error
Jim Inghamacff8952013-05-02 00:27:30 +00003672Process::Detach (bool keep_stopped)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003673{
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003674 EventSP exit_event_sp;
3675 Error error;
3676 m_destroy_in_process = true;
3677
3678 error = WillDetach();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003679
3680 if (error.Success())
3681 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003682 if (DetachRequiresHalt())
3683 {
3684 error = HaltForDestroyOrDetach (exit_event_sp);
3685 if (!error.Success())
3686 {
3687 m_destroy_in_process = false;
3688 return error;
3689 }
3690 else if (exit_event_sp)
3691 {
3692 // We shouldn't need to do anything else here. There's no process left to detach from...
3693 StopPrivateStateThread();
3694 m_destroy_in_process = false;
3695 return error;
3696 }
3697 }
3698
Andrew MacPhersonc3826b52014-03-25 19:59:36 +00003699 m_thread_list.DiscardThreadPlans();
3700 DisableAllBreakpointSites();
3701
Jim Inghamacff8952013-05-02 00:27:30 +00003702 error = DoDetach(keep_stopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003703 if (error.Success())
3704 {
3705 DidDetach();
3706 StopPrivateStateThread();
3707 }
Jim Inghamacff8952013-05-02 00:27:30 +00003708 else
3709 {
3710 return error;
3711 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003712 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003713 m_destroy_in_process = false;
3714
3715 // If we exited when we were waiting for a process to stop, then
3716 // forward the event here so we don't lose the event
3717 if (exit_event_sp)
3718 {
3719 // Directly broadcast our exited event because we shut down our
3720 // private state thread above
3721 BroadcastEvent(exit_event_sp);
3722 }
3723
3724 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3725 // the last events through the event system, in which case we might strand the write lock. Unlock
3726 // it here so when we do to tear down the process we don't get an error destroying the lock.
3727
Ed Maste64fad602013-07-29 20:58:06 +00003728 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003729 return error;
3730}
3731
3732Error
3733Process::Destroy ()
3734{
Jim Ingham09437922013-03-01 20:04:25 +00003735
3736 // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
3737 // that might hinder the destruction. Remember to set this back to false when we are done. That way if the attempt
3738 // failed and the process stays around for some reason it won't be in a confused state.
3739
3740 m_destroy_in_process = true;
3741
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003742 Error error (WillDestroy());
3743 if (error.Success())
3744 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00003745 EventSP exit_event_sp;
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003746 if (DestroyRequiresHalt())
Jim Ingham04e0a222012-05-23 15:46:31 +00003747 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003748 error = HaltForDestroyOrDetach(exit_event_sp);
Jim Ingham04e0a222012-05-23 15:46:31 +00003749 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003750
Jim Inghamaacc3182012-06-06 00:29:30 +00003751 if (m_public_state.GetValue() != eStateRunning)
3752 {
3753 // Ditch all thread plans, and remove all our breakpoints: in case we have to restart the target to
3754 // kill it, we don't want it hitting a breakpoint...
3755 // Only do this if we've stopped, however, since if we didn't manage to halt it above, then
3756 // we're not going to have much luck doing this now.
3757 m_thread_list.DiscardThreadPlans();
3758 DisableAllBreakpointSites();
3759 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003760
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003761 error = DoDestroy();
3762 if (error.Success())
3763 {
3764 DidDestroy();
3765 StopPrivateStateThread();
3766 }
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003767 m_stdio_communication.StopReadThread();
3768 m_stdio_communication.Disconnect();
Greg Claytonb4874f12014-02-28 18:22:24 +00003769
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003770 if (m_process_input_reader)
Greg Claytonb4874f12014-02-28 18:22:24 +00003771 {
3772 m_process_input_reader->SetIsDone(true);
3773 m_process_input_reader->Cancel();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003774 m_process_input_reader.reset();
Greg Claytonb4874f12014-02-28 18:22:24 +00003775 }
3776
Greg Clayton85fb1b92012-09-11 02:33:37 +00003777 // If we exited when we were waiting for a process to stop, then
3778 // forward the event here so we don't lose the event
3779 if (exit_event_sp)
3780 {
3781 // Directly broadcast our exited event because we shut down our
3782 // private state thread above
3783 BroadcastEvent(exit_event_sp);
3784 }
3785
Jim Inghamb1e2e842012-04-12 18:49:31 +00003786 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3787 // the last events through the event system, in which case we might strand the write lock. Unlock
3788 // 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 +00003789 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003790 }
Jim Ingham09437922013-03-01 20:04:25 +00003791
3792 m_destroy_in_process = false;
3793
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003794 return error;
3795}
3796
3797Error
3798Process::Signal (int signal)
3799{
3800 Error error (WillSignal());
3801 if (error.Success())
3802 {
3803 error = DoSignal(signal);
3804 if (error.Success())
3805 DidSignal();
3806 }
3807 return error;
3808}
3809
Greg Clayton514487e2011-02-15 21:59:32 +00003810lldb::ByteOrder
3811Process::GetByteOrder () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003812{
Greg Clayton514487e2011-02-15 21:59:32 +00003813 return m_target.GetArchitecture().GetByteOrder();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003814}
3815
3816uint32_t
Greg Clayton514487e2011-02-15 21:59:32 +00003817Process::GetAddressByteSize () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003818{
Greg Clayton514487e2011-02-15 21:59:32 +00003819 return m_target.GetArchitecture().GetAddressByteSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003820}
3821
Greg Clayton514487e2011-02-15 21:59:32 +00003822
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003823bool
3824Process::ShouldBroadcastEvent (Event *event_ptr)
3825{
3826 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
3827 bool return_value = true;
Greg Clayton5160ce52013-03-27 23:08:40 +00003828 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | LIBLLDB_LOG_PROCESS));
Jim Ingham0161b492013-02-09 01:29:05 +00003829
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003830 switch (state)
3831 {
Greg Claytonb766a732011-02-04 01:58:07 +00003832 case eStateConnected:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003833 case eStateAttaching:
3834 case eStateLaunching:
3835 case eStateDetached:
3836 case eStateExited:
3837 case eStateUnloaded:
3838 // These events indicate changes in the state of the debugging session, always report them.
3839 return_value = true;
3840 break;
3841 case eStateInvalid:
3842 // We stopped for no apparent reason, don't report it.
3843 return_value = false;
3844 break;
3845 case eStateRunning:
3846 case eStateStepping:
3847 // If we've started the target running, we handle the cases where we
3848 // are already running and where there is a transition from stopped to
3849 // running differently.
3850 // running -> running: Automatically suppress extra running events
3851 // stopped -> running: Report except when there is one or more no votes
3852 // and no yes votes.
3853 SynchronouslyNotifyStateChanged (state);
Jim Ingham1460e4b2014-01-10 23:46:59 +00003854 if (m_force_next_event_delivery)
3855 return_value = true;
3856 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003857 {
Jim Ingham1460e4b2014-01-10 23:46:59 +00003858 switch (m_last_broadcast_state)
3859 {
3860 case eStateRunning:
3861 case eStateStepping:
3862 // We always suppress multiple runnings with no PUBLIC stop in between.
3863 return_value = false;
3864 break;
3865 default:
3866 // TODO: make this work correctly. For now always report
3867 // run if we aren't running so we don't miss any runnning
3868 // events. If I run the lldb/test/thread/a.out file and
3869 // break at main.cpp:58, run and hit the breakpoints on
3870 // multiple threads, then somehow during the stepping over
3871 // of all breakpoints no run gets reported.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003872
Jim Ingham1460e4b2014-01-10 23:46:59 +00003873 // This is a transition from stop to run.
3874 switch (m_thread_list.ShouldReportRun (event_ptr))
3875 {
3876 case eVoteYes:
3877 case eVoteNoOpinion:
3878 return_value = true;
3879 break;
3880 case eVoteNo:
3881 return_value = false;
3882 break;
3883 }
3884 break;
3885 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003886 }
3887 break;
3888 case eStateStopped:
3889 case eStateCrashed:
3890 case eStateSuspended:
3891 {
3892 // We've stopped. First see if we're going to restart the target.
3893 // If we are going to stop, then we always broadcast the event.
3894 // 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 +00003895 // If no thread has an opinion, we don't report it.
Jim Ingham221d51c2013-05-08 00:35:16 +00003896
Jim Inghamcb4ca112012-05-16 01:32:14 +00003897 RefreshStateAfterStop ();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003898 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003899 {
Greg Clayton3af9ea52010-11-18 05:57:03 +00003900 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003901 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003902 static_cast<void*>(event_ptr),
Jim Ingham0161b492013-02-09 01:29:05 +00003903 StateAsCString(state));
Jim Ingham35878c42014-04-08 21:33:21 +00003904 // Even though we know we are going to stop, we should let the threads have a look at the stop,
3905 // so they can properly set their state.
3906 m_thread_list.ShouldStop (event_ptr);
Jim Ingham0161b492013-02-09 01:29:05 +00003907 return_value = true;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003908 }
3909 else
3910 {
Jim Ingham221d51c2013-05-08 00:35:16 +00003911 bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
3912 bool should_resume = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003913
Jim Ingham0161b492013-02-09 01:29:05 +00003914 // It makes no sense to ask "ShouldStop" if we've already been restarted...
3915 // Asking the thread list is also not likely to go well, since we are running again.
3916 // So in that case just report the event.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003917
Jim Ingham0161b492013-02-09 01:29:05 +00003918 if (!was_restarted)
3919 should_resume = m_thread_list.ShouldStop (event_ptr) == false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003920
Jim Ingham221d51c2013-05-08 00:35:16 +00003921 if (was_restarted || should_resume || m_resume_requested)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003922 {
Jim Ingham0161b492013-02-09 01:29:05 +00003923 Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
3924 if (log)
3925 log->Printf ("Process::ShouldBroadcastEvent: should_stop: %i state: %s was_restarted: %i stop_vote: %d.",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003926 should_resume, StateAsCString(state),
3927 was_restarted, stop_vote);
3928
Jim Ingham0161b492013-02-09 01:29:05 +00003929 switch (stop_vote)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003930 {
3931 case eVoteYes:
Jim Ingham0161b492013-02-09 01:29:05 +00003932 return_value = true;
3933 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003934 case eVoteNoOpinion:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003935 case eVoteNo:
3936 return_value = false;
3937 break;
3938 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003939
Jim Inghamcb95f342012-09-05 21:13:56 +00003940 if (!was_restarted)
Jim Ingham0161b492013-02-09 01:29:05 +00003941 {
3942 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003943 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s",
3944 static_cast<void*>(event_ptr),
3945 StateAsCString(state));
Jim Ingham0161b492013-02-09 01:29:05 +00003946 ProcessEventData::SetRestartedInEvent(event_ptr, true);
Jim Inghamcb95f342012-09-05 21:13:56 +00003947 PrivateResume ();
Jim Ingham0161b492013-02-09 01:29:05 +00003948 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003949
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003950 }
3951 else
3952 {
3953 return_value = true;
3954 SynchronouslyNotifyStateChanged (state);
3955 }
3956 }
3957 }
Jim Ingham0161b492013-02-09 01:29:05 +00003958 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003959 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003960
Jim Ingham1460e4b2014-01-10 23:46:59 +00003961 // Forcing the next event delivery is a one shot deal. So reset it here.
3962 m_force_next_event_delivery = false;
3963
Jim Ingham0161b492013-02-09 01:29:05 +00003964 // We do some coalescing of events (for instance two consecutive running events get coalesced.)
3965 // But we only coalesce against events we actually broadcast. So we use m_last_broadcast_state
3966 // to track that. NB - you can't use "m_public_state.GetValue()" for that purpose, as was originally done,
3967 // because the PublicState reflects the last event pulled off the queue, and there may be several
3968 // events stacked up on the queue unserviced. So the PublicState may not reflect the last broadcasted event
3969 // yet. m_last_broadcast_state gets updated here.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003970
Jim Ingham0161b492013-02-09 01:29:05 +00003971 if (return_value)
3972 m_last_broadcast_state = state;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003973
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003974 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003975 log->Printf ("Process::ShouldBroadcastEvent (%p) => new state: %s, last broadcast state: %s - %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003976 static_cast<void*>(event_ptr), StateAsCString(state),
Jim Ingham0161b492013-02-09 01:29:05 +00003977 StateAsCString(m_last_broadcast_state),
3978 return_value ? "YES" : "NO");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003979 return return_value;
3980}
3981
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003982
3983bool
Jim Ingham372787f2012-04-07 00:00:41 +00003984Process::StartPrivateStateThread (bool force)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003985{
Greg Clayton5160ce52013-03-27 23:08:40 +00003986 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003987
Greg Clayton8b82f082011-04-12 05:54:46 +00003988 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003989 if (log)
Greg Clayton8b82f082011-04-12 05:54:46 +00003990 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
3991
Jim Ingham372787f2012-04-07 00:00:41 +00003992 if (!force && already_running)
Greg Clayton8b82f082011-04-12 05:54:46 +00003993 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003994
3995 // Create a thread that watches our internal state and controls which
3996 // events make it to clients (into the DCProcess event queue).
Greg Clayton3e06bd92011-01-09 21:07:35 +00003997 char thread_name[1024];
Jim Ingham372787f2012-04-07 00:00:41 +00003998 if (already_running)
Daniel Malead01b2952012-11-29 21:49:15 +00003999 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
Jim Ingham372787f2012-04-07 00:00:41 +00004000 else
Daniel Malead01b2952012-11-29 21:49:15 +00004001 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
Jim Ingham076b3042012-04-10 01:21:57 +00004002
4003 // Create the private state thread, and start it running.
Greg Clayton3e06bd92011-01-09 21:07:35 +00004004 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL);
Jim Ingham076b3042012-04-10 01:21:57 +00004005 bool success = IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
4006 if (success)
4007 {
4008 ResumePrivateStateThread();
4009 return true;
4010 }
4011 else
4012 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004013}
4014
4015void
4016Process::PausePrivateStateThread ()
4017{
4018 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
4019}
4020
4021void
4022Process::ResumePrivateStateThread ()
4023{
4024 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
4025}
4026
4027void
4028Process::StopPrivateStateThread ()
4029{
Greg Clayton8b82f082011-04-12 05:54:46 +00004030 if (PrivateStateThreadIsValid ())
4031 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Jim Inghamb1e2e842012-04-12 18:49:31 +00004032 else
4033 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004034 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Jim Inghamb1e2e842012-04-12 18:49:31 +00004035 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00004036 log->Printf ("Went to stop the private state thread, but it was already invalid.");
Jim Inghamb1e2e842012-04-12 18:49:31 +00004037 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004038}
4039
4040void
4041Process::ControlPrivateStateThread (uint32_t signal)
4042{
Greg Clayton5160ce52013-03-27 23:08:40 +00004043 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004044
4045 assert (signal == eBroadcastInternalStateControlStop ||
4046 signal == eBroadcastInternalStateControlPause ||
4047 signal == eBroadcastInternalStateControlResume);
4048
4049 if (log)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00004050 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004051
Greg Clayton7ecb3a02011-01-22 17:43:17 +00004052 // Signal the private state thread. First we should copy this is case the
4053 // thread starts exiting since the private state thread will NULL this out
4054 // when it exits
4055 const lldb::thread_t private_state_thread = m_private_state_thread;
Greg Clayton2da6d492011-02-08 01:34:25 +00004056 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004057 {
4058 TimeValue timeout_time;
4059 bool timed_out;
4060
4061 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
4062
4063 timeout_time = TimeValue::Now();
4064 timeout_time.OffsetWithSeconds(2);
Jim Inghamb1e2e842012-04-12 18:49:31 +00004065 if (log)
4066 log->Printf ("Sending control event of type: %d.", signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004067 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
4068 m_private_state_control_wait.SetValue (false, eBroadcastNever);
4069
4070 if (signal == eBroadcastInternalStateControlStop)
4071 {
4072 if (timed_out)
Jim Inghamb1e2e842012-04-12 18:49:31 +00004073 {
4074 Error error;
4075 Host::ThreadCancel (private_state_thread, &error);
4076 if (log)
4077 log->Printf ("Timed out responding to the control event, cancel got error: \"%s\".", error.AsCString());
4078 }
4079 else
4080 {
4081 if (log)
4082 log->Printf ("The control event killed the private state thread without having to cancel.");
4083 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004084
4085 thread_result_t result = NULL;
Greg Clayton7ecb3a02011-01-22 17:43:17 +00004086 Host::ThreadJoin (private_state_thread, &result, NULL);
Greg Clayton49182ed2010-07-22 18:34:21 +00004087 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004088 }
4089 }
Jim Inghamb1e2e842012-04-12 18:49:31 +00004090 else
4091 {
4092 if (log)
4093 log->Printf ("Private state thread already dead, no need to signal it to stop.");
4094 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004095}
4096
4097void
Jim Inghamcfc09352012-07-27 23:57:19 +00004098Process::SendAsyncInterrupt ()
4099{
4100 if (PrivateStateThreadIsValid())
4101 m_private_state_broadcaster.BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
4102 else
4103 BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
4104}
4105
4106void
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004107Process::HandlePrivateEvent (EventSP &event_sp)
4108{
Greg Clayton5160ce52013-03-27 23:08:40 +00004109 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Ingham221d51c2013-05-08 00:35:16 +00004110 m_resume_requested = false;
4111
Jim Inghamaacc3182012-06-06 00:29:30 +00004112 m_currently_handling_event.SetValue(true, eBroadcastNever);
Jim Inghambb3a2832011-01-29 01:49:25 +00004113
Greg Clayton414f5d32011-01-25 02:58:48 +00004114 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00004115
4116 // First check to see if anybody wants a shot at this event:
Jim Ingham754ab982011-01-29 04:05:41 +00004117 if (m_next_event_action_ap.get() != NULL)
Jim Inghambb3a2832011-01-29 01:49:25 +00004118 {
Jim Ingham754ab982011-01-29 04:05:41 +00004119 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Ingham0161b492013-02-09 01:29:05 +00004120 if (log)
4121 log->Printf ("Ran next event action, result was %d.", action_result);
4122
Jim Inghambb3a2832011-01-29 01:49:25 +00004123 switch (action_result)
4124 {
4125 case NextEventAction::eEventActionSuccess:
4126 SetNextEventAction(NULL);
4127 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00004128
Jim Inghambb3a2832011-01-29 01:49:25 +00004129 case NextEventAction::eEventActionRetry:
4130 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00004131
Jim Inghambb3a2832011-01-29 01:49:25 +00004132 case NextEventAction::eEventActionExit:
Jim Ingham2a5fdd42011-01-29 01:57:31 +00004133 // Handle Exiting Here. If we already got an exited event,
4134 // we should just propagate it. Otherwise, swallow this event,
4135 // and set our state to exit so the next event will kill us.
4136 if (new_state != eStateExited)
4137 {
4138 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham754ab982011-01-29 04:05:41 +00004139 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Jim Ingham221d51c2013-05-08 00:35:16 +00004140 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Jim Ingham2a5fdd42011-01-29 01:57:31 +00004141 SetNextEventAction(NULL);
4142 return;
4143 }
4144 SetNextEventAction(NULL);
Jim Inghambb3a2832011-01-29 01:49:25 +00004145 break;
4146 }
4147 }
4148
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004149 // See if we should broadcast this state to external clients?
4150 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004151
4152 if (should_broadcast)
4153 {
Greg Claytonb4874f12014-02-28 18:22:24 +00004154 const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004155 if (log)
4156 {
Daniel Malead01b2952012-11-29 21:49:15 +00004157 log->Printf ("Process::%s (pid = %" PRIu64 ") broadcasting new state %s (old state %s) to %s",
Greg Clayton414f5d32011-01-25 02:58:48 +00004158 __FUNCTION__,
4159 GetID(),
4160 StateAsCString(new_state),
4161 StateAsCString (GetState ()),
Greg Claytonb4874f12014-02-28 18:22:24 +00004162 is_hijacked ? "hijacked" : "public");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004163 }
Jim Ingham9575d842011-03-11 03:53:59 +00004164 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton414f5d32011-01-25 02:58:48 +00004165 if (StateIsRunningState (new_state))
Greg Clayton44d93782014-01-27 23:43:24 +00004166 {
4167 // Only push the input handler if we aren't fowarding events,
4168 // as this means the curses GUI is in use...
4169 if (!GetTarget().GetDebugger().IsForwardingEvents())
4170 PushProcessIOHandler ();
4171 }
Greg Claytonb4874f12014-02-28 18:22:24 +00004172 else if (StateIsStoppedState(new_state, false))
4173 {
4174 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
4175 {
4176 // If the lldb_private::Debugger is handling the events, we don't
4177 // want to pop the process IOHandler here, we want to do it when
4178 // we receive the stopped event so we can carefully control when
4179 // the process IOHandler is popped because when we stop we want to
4180 // display some text stating how and why we stopped, then maybe some
4181 // process/thread/frame info, and then we want the "(lldb) " prompt
4182 // to show up. If we pop the process IOHandler here, then we will
4183 // cause the command interpreter to become the top IOHandler after
4184 // the process pops off and it will update its prompt right away...
4185 // See the Debugger.cpp file where it calls the function as
4186 // "process_sp->PopProcessIOHandler()" to see where I am talking about.
4187 // Otherwise we end up getting overlapping "(lldb) " prompts and
4188 // garbled output.
4189 //
4190 // If we aren't handling the events in the debugger (which is indicated
4191 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
4192 // are hijacked, then we always pop the process IO handler manually.
4193 // Hijacking happens when the internal process state thread is running
4194 // thread plans, or when commands want to run in synchronous mode
4195 // and they call "process->WaitForProcessToStop()". An example of something
4196 // that will hijack the events is a simple expression:
4197 //
4198 // (lldb) expr (int)puts("hello")
4199 //
4200 // This will cause the internal process state thread to resume and halt
4201 // the process (and _it_ will hijack the eBroadcastBitStateChanged
4202 // events) and we do need the IO handler to be pushed and popped
4203 // correctly.
4204
4205 if (is_hijacked || m_target.GetDebugger().IsHandlingEvents() == false)
4206 PopProcessIOHandler ();
4207 }
4208 }
Jim Ingham9575d842011-03-11 03:53:59 +00004209
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004210 BroadcastEvent (event_sp);
4211 }
4212 else
4213 {
4214 if (log)
4215 {
Daniel Malead01b2952012-11-29 21:49:15 +00004216 log->Printf ("Process::%s (pid = %" PRIu64 ") suppressing state %s (old state %s): should_broadcast == false",
Greg Clayton414f5d32011-01-25 02:58:48 +00004217 __FUNCTION__,
4218 GetID(),
4219 StateAsCString(new_state),
Jason Molendafd54b362011-09-20 21:44:10 +00004220 StateAsCString (GetState ()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004221 }
4222 }
Jim Inghamaacc3182012-06-06 00:29:30 +00004223 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004224}
4225
Virgile Bellob2f1fb22013-08-23 12:44:05 +00004226thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004227Process::PrivateStateThread (void *arg)
4228{
4229 Process *proc = static_cast<Process*> (arg);
Virgile Bellob2f1fb22013-08-23 12:44:05 +00004230 thread_result_t result = proc->RunPrivateStateThread();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004231 return result;
4232}
4233
Virgile Bellob2f1fb22013-08-23 12:44:05 +00004234thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004235Process::RunPrivateStateThread ()
4236{
Jim Ingham076b3042012-04-10 01:21:57 +00004237 bool control_only = true;
Jim Inghamb1e2e842012-04-12 18:49:31 +00004238 m_private_state_control_wait.SetValue (false, eBroadcastNever);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004239
Greg Clayton5160ce52013-03-27 23:08:40 +00004240 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004241 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004242 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
4243 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004244
4245 bool exit_now = false;
4246 while (!exit_now)
4247 {
4248 EventSP event_sp;
4249 WaitForEventsPrivate (NULL, event_sp, control_only);
4250 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
4251 {
Jim Inghamb1e2e842012-04-12 18:49:31 +00004252 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004253 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") got a control event: %d",
4254 __FUNCTION__, static_cast<void*>(this), GetID(),
4255 event_sp->GetType());
Jim Inghamb1e2e842012-04-12 18:49:31 +00004256
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004257 switch (event_sp->GetType())
4258 {
4259 case eBroadcastInternalStateControlStop:
4260 exit_now = true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004261 break; // doing any internal state managment below
4262
4263 case eBroadcastInternalStateControlPause:
4264 control_only = true;
4265 break;
4266
4267 case eBroadcastInternalStateControlResume:
4268 control_only = false;
4269 break;
4270 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004271
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004272 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004273 continue;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004274 }
Jim Inghamcfc09352012-07-27 23:57:19 +00004275 else if (event_sp->GetType() == eBroadcastBitInterrupt)
4276 {
4277 if (m_public_state.GetValue() == eStateAttaching)
4278 {
4279 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004280 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.",
4281 __FUNCTION__, static_cast<void*>(this),
4282 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00004283 BroadcastEvent (eBroadcastBitInterrupt, NULL);
4284 }
4285 else
4286 {
4287 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004288 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt - Halting.",
4289 __FUNCTION__, static_cast<void*>(this),
4290 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00004291 Halt();
4292 }
4293 continue;
4294 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004295
4296 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4297
4298 if (internal_state != eStateInvalid)
4299 {
Greg Claytonf9b57b92013-05-10 23:48:10 +00004300 if (m_clear_thread_plans_on_stop &&
4301 StateIsStoppedState(internal_state, true))
4302 {
4303 m_clear_thread_plans_on_stop = false;
4304 m_thread_list.DiscardThreadPlans();
4305 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004306 HandlePrivateEvent (event_sp);
4307 }
4308
Greg Clayton58d1c9a2010-10-18 04:14:23 +00004309 if (internal_state == eStateInvalid ||
4310 internal_state == eStateExited ||
4311 internal_state == eStateDetached )
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004312 {
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004313 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004314 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") about to exit with internal state %s...",
4315 __FUNCTION__, static_cast<void*>(this), GetID(),
4316 StateAsCString(internal_state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004317
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004318 break;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004319 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004320 }
4321
Caroline Tice20ad3c42010-10-29 21:48:37 +00004322 // Verify log is still enabled before attempting to write to it...
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004323 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004324 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4325 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004326
Ed Maste64fad602013-07-29 20:58:06 +00004327 m_public_run_lock.SetStopped();
Greg Clayton6ed95942011-01-22 07:12:45 +00004328 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
4329 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004330 return NULL;
4331}
4332
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004333//------------------------------------------------------------------
4334// Process Event Data
4335//------------------------------------------------------------------
4336
4337Process::ProcessEventData::ProcessEventData () :
4338 EventData (),
4339 m_process_sp (),
4340 m_state (eStateInvalid),
Greg Claytonc982c762010-07-09 20:39:50 +00004341 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004342 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004343 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004344{
4345}
4346
4347Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
4348 EventData (),
4349 m_process_sp (process_sp),
4350 m_state (state),
Greg Claytonc982c762010-07-09 20:39:50 +00004351 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004352 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004353 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004354{
4355}
4356
4357Process::ProcessEventData::~ProcessEventData()
4358{
4359}
4360
4361const ConstString &
4362Process::ProcessEventData::GetFlavorString ()
4363{
4364 static ConstString g_flavor ("Process::ProcessEventData");
4365 return g_flavor;
4366}
4367
4368const ConstString &
4369Process::ProcessEventData::GetFlavor () const
4370{
4371 return ProcessEventData::GetFlavorString ();
4372}
4373
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004374void
4375Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
4376{
4377 // This function gets called twice for each event, once when the event gets pulled
Jim Inghama8604692011-05-22 21:45:01 +00004378 // off of the private process event queue, and then any number of times, first when it gets pulled off of
4379 // the public event queue, then other times when we're pretending that this is where we stopped at the
4380 // end of expression evaluation. m_update_state is used to distinguish these
4381 // three cases; it is 0 when we're just pulling it off for private handling,
Jim Ingham221d51c2013-05-08 00:35:16 +00004382 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Jim Inghama8604692011-05-22 21:45:01 +00004383 if (m_update_state != 1)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004384 return;
Jim Ingham0161b492013-02-09 01:29:05 +00004385
Jim Ingham221d51c2013-05-08 00:35:16 +00004386 m_process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
Jim Ingham35878c42014-04-08 21:33:21 +00004387
4388 // If this is a halt event, even if the halt stopped with some reason other than a plain interrupt (e.g. we had
4389 // already stopped for a breakpoint when the halt request came through) don't do the StopInfo actions, as they may
4390 // end up restarting the process.
4391 if (m_interrupted)
4392 return;
4393
4394 // If we're stopped and haven't restarted, then do the StopInfo actions here:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004395 if (m_state == eStateStopped && ! m_restarted)
Jim Ingham0faa43f2011-11-08 03:00:11 +00004396 {
4397 ThreadList &curr_thread_list = m_process_sp->GetThreadList();
Greg Clayton61e7a582011-12-01 23:28:38 +00004398 uint32_t num_threads = curr_thread_list.GetSize();
4399 uint32_t idx;
Greg Claytonf4b47e12010-08-04 01:40:35 +00004400
Jim Ingham4b536182011-08-09 02:12:22 +00004401 // The actions might change one of the thread's stop_info's opinions about whether we should
4402 // stop the process, so we need to query that as we go.
Jim Ingham0faa43f2011-11-08 03:00:11 +00004403
4404 // One other complication here, is that we try to catch any case where the target has run (except for expressions)
4405 // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
4406 // that would cause our iteration here to crash. We could make a copy of the thread list, but we'd really like
4407 // 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
4408 // against this list & bag out if anything differs.
Greg Clayton61e7a582011-12-01 23:28:38 +00004409 std::vector<uint32_t> thread_index_array(num_threads);
Jim Ingham0faa43f2011-11-08 03:00:11 +00004410 for (idx = 0; idx < num_threads; ++idx)
4411 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
4412
Jim Inghamc7078c22012-12-13 22:24:15 +00004413 // Use this to track whether we should continue from here. We will only continue the target running if
4414 // no thread says we should stop. Of course if some thread's PerformAction actually sets the target running,
4415 // then it doesn't matter what the other threads say...
4416
4417 bool still_should_stop = false;
Jim Ingham4b536182011-08-09 02:12:22 +00004418
Jim Ingham0ad7e052013-04-25 02:04:59 +00004419 // Sometimes - for instance if we have a bug in the stub we are talking to, we stop but no thread has a
4420 // valid stop reason. In that case we should just stop, because we have no way of telling what the right
4421 // thing to do is, and it's better to let the user decide than continue behind their backs.
4422
4423 bool does_anybody_have_an_opinion = false;
4424
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004425 for (idx = 0; idx < num_threads; ++idx)
4426 {
Jim Ingham0faa43f2011-11-08 03:00:11 +00004427 curr_thread_list = m_process_sp->GetThreadList();
4428 if (curr_thread_list.GetSize() != num_threads)
4429 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004430 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004431 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004432 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 +00004433 break;
4434 }
4435
4436 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
4437
4438 if (thread_sp->GetIndexID() != thread_index_array[idx])
4439 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004440 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004441 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004442 log->Printf("The thread at position %u changed from %u to %u while processing event.",
Jim Ingham87c665f2011-12-01 20:26:15 +00004443 idx,
4444 thread_index_array[idx],
4445 thread_sp->GetIndexID());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004446 break;
4447 }
4448
Jim Inghamb15bfc72010-10-20 00:39:53 +00004449 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
Jim Ingham5d88a062012-10-16 00:09:33 +00004450 if (stop_info_sp && stop_info_sp->IsValid())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004451 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004452 does_anybody_have_an_opinion = true;
Jim Ingham0161b492013-02-09 01:29:05 +00004453 bool this_thread_wants_to_stop;
4454 if (stop_info_sp->GetOverrideShouldStop())
Jim Ingham4b536182011-08-09 02:12:22 +00004455 {
Jim Ingham0161b492013-02-09 01:29:05 +00004456 this_thread_wants_to_stop = stop_info_sp->GetOverriddenShouldStopValue();
4457 }
4458 else
4459 {
4460 stop_info_sp->PerformAction(event_ptr);
4461 // The stop action might restart the target. If it does, then we want to mark that in the
4462 // event so that whoever is receiving it will know to wait for the running event and reflect
4463 // that state appropriately.
4464 // We also need to stop processing actions, since they aren't expecting the target to be running.
4465
4466 // FIXME: we might have run.
4467 if (stop_info_sp->HasTargetRunSinceMe())
4468 {
4469 SetRestarted (true);
4470 break;
4471 }
4472
4473 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
Jim Ingham4b536182011-08-09 02:12:22 +00004474 }
Jim Inghamc7078c22012-12-13 22:24:15 +00004475
Jim Inghamc7078c22012-12-13 22:24:15 +00004476 if (still_should_stop == false)
4477 still_should_stop = this_thread_wants_to_stop;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004478 }
4479 }
Jim Ingham3ebcf7f2010-08-10 00:59:59 +00004480
Ashok Thirumurthicf7c55e2013-04-18 14:38:20 +00004481
Jim Inghama8ca6e22013-05-03 23:04:37 +00004482 if (!GetRestarted())
Jim Ingham9575d842011-03-11 03:53:59 +00004483 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004484 if (!still_should_stop && does_anybody_have_an_opinion)
Jim Ingham4b536182011-08-09 02:12:22 +00004485 {
4486 // We've been asked to continue, so do that here.
Jim Ingham9575d842011-03-11 03:53:59 +00004487 SetRestarted(true);
Jim Ingham3b8285d2012-04-19 01:40:33 +00004488 // Use the public resume method here, since this is just
4489 // extending a public resume.
Jim Ingham0161b492013-02-09 01:29:05 +00004490 m_process_sp->PrivateResume();
Jim Ingham4b536182011-08-09 02:12:22 +00004491 }
4492 else
4493 {
4494 // If we didn't restart, run the Stop Hooks here:
4495 // They might also restart the target, so watch for that.
4496 m_process_sp->GetTarget().RunStopHooks();
4497 if (m_process_sp->GetPrivateState() == eStateRunning)
4498 SetRestarted(true);
4499 }
Jim Ingham9575d842011-03-11 03:53:59 +00004500 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004501 }
4502}
4503
4504void
4505Process::ProcessEventData::Dump (Stream *s) const
4506{
4507 if (m_process_sp)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004508 s->Printf(" process = %p (pid = %" PRIu64 "), ",
4509 static_cast<void*>(m_process_sp.get()), m_process_sp->GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004510
Greg Clayton8b82f082011-04-12 05:54:46 +00004511 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004512}
4513
4514const Process::ProcessEventData *
4515Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
4516{
4517 if (event_ptr)
4518 {
4519 const EventData *event_data = event_ptr->GetData();
4520 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4521 return static_cast <const ProcessEventData *> (event_ptr->GetData());
4522 }
4523 return NULL;
4524}
4525
4526ProcessSP
4527Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
4528{
4529 ProcessSP process_sp;
4530 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4531 if (data)
4532 process_sp = data->GetProcessSP();
4533 return process_sp;
4534}
4535
4536StateType
4537Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
4538{
4539 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4540 if (data == NULL)
4541 return eStateInvalid;
4542 else
4543 return data->GetState();
4544}
4545
4546bool
4547Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
4548{
4549 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4550 if (data == NULL)
4551 return false;
4552 else
4553 return data->GetRestarted();
4554}
4555
4556void
4557Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
4558{
4559 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4560 if (data != NULL)
4561 data->SetRestarted(new_value);
4562}
4563
Jim Ingham0161b492013-02-09 01:29:05 +00004564size_t
4565Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr)
4566{
4567 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4568 if (data != NULL)
4569 return data->GetNumRestartedReasons();
4570 else
4571 return 0;
4572}
4573
4574const char *
4575Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx)
4576{
4577 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4578 if (data != NULL)
4579 return data->GetRestartedReasonAtIndex(idx);
4580 else
4581 return NULL;
4582}
4583
4584void
4585Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason)
4586{
4587 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4588 if (data != NULL)
4589 data->AddRestartedReason(reason);
4590}
4591
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004592bool
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004593Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
4594{
4595 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4596 if (data == NULL)
4597 return false;
4598 else
4599 return data->GetInterrupted ();
4600}
4601
4602void
4603Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
4604{
4605 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4606 if (data != NULL)
4607 data->SetInterrupted(new_value);
4608}
4609
4610bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004611Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
4612{
4613 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4614 if (data)
4615 {
4616 data->SetUpdateStateOnRemoval();
4617 return true;
4618 }
4619 return false;
4620}
4621
Greg Claytond9e416c2012-02-18 05:35:26 +00004622lldb::TargetSP
4623Process::CalculateTarget ()
4624{
4625 return m_target.shared_from_this();
4626}
4627
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004628void
Greg Clayton0603aa92010-10-04 01:05:56 +00004629Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004630{
Greg Claytonc14ee322011-09-22 04:58:26 +00004631 exe_ctx.SetTargetPtr (&m_target);
4632 exe_ctx.SetProcessPtr (this);
4633 exe_ctx.SetThreadPtr(NULL);
4634 exe_ctx.SetFramePtr (NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004635}
4636
Greg Claytone996fd32011-03-08 22:40:15 +00004637//uint32_t
4638//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
4639//{
4640// return 0;
4641//}
4642//
4643//ArchSpec
4644//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4645//{
4646// return Host::GetArchSpecForExistingProcess (pid);
4647//}
4648//
4649//ArchSpec
4650//Process::GetArchSpecForExistingProcess (const char *process_name)
4651//{
4652// return Host::GetArchSpecForExistingProcess (process_name);
4653//}
4654//
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004655void
4656Process::AppendSTDOUT (const char * s, size_t len)
4657{
Greg Clayton3af9ea52010-11-18 05:57:03 +00004658 Mutex::Locker locker (m_stdio_communication_mutex);
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004659 m_stdout_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004660 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004661}
4662
4663void
Greg Clayton93e86192011-11-13 04:45:22 +00004664Process::AppendSTDERR (const char * s, size_t len)
4665{
4666 Mutex::Locker locker (m_stdio_communication_mutex);
4667 m_stderr_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004668 BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
Greg Clayton93e86192011-11-13 04:45:22 +00004669}
4670
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004671void
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004672Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004673{
4674 Mutex::Locker locker (m_profile_data_comm_mutex);
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004675 m_profile_data.push_back(one_profile_data);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004676 BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
4677}
4678
4679size_t
4680Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
4681{
4682 Mutex::Locker locker(m_profile_data_comm_mutex);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004683 if (m_profile_data.empty())
4684 return 0;
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004685
4686 std::string &one_profile_data = m_profile_data.front();
4687 size_t bytes_available = one_profile_data.size();
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004688 if (bytes_available > 0)
4689 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004690 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004691 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004692 log->Printf ("Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4693 static_cast<void*>(buf),
4694 static_cast<uint64_t>(buf_size));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004695 if (bytes_available > buf_size)
4696 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004697 memcpy(buf, one_profile_data.c_str(), buf_size);
4698 one_profile_data.erase(0, buf_size);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004699 bytes_available = buf_size;
4700 }
4701 else
4702 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004703 memcpy(buf, one_profile_data.c_str(), bytes_available);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004704 m_profile_data.erase(m_profile_data.begin());
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004705 }
4706 }
4707 return bytes_available;
4708}
4709
4710
Greg Clayton93e86192011-11-13 04:45:22 +00004711//------------------------------------------------------------------
4712// Process STDIO
4713//------------------------------------------------------------------
4714
4715size_t
4716Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
4717{
4718 Mutex::Locker locker(m_stdio_communication_mutex);
4719 size_t bytes_available = m_stdout_data.size();
4720 if (bytes_available > 0)
4721 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004722 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004723 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004724 log->Printf ("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4725 static_cast<void*>(buf),
4726 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004727 if (bytes_available > buf_size)
4728 {
4729 memcpy(buf, m_stdout_data.c_str(), buf_size);
4730 m_stdout_data.erase(0, buf_size);
4731 bytes_available = buf_size;
4732 }
4733 else
4734 {
4735 memcpy(buf, m_stdout_data.c_str(), bytes_available);
4736 m_stdout_data.clear();
4737 }
4738 }
4739 return bytes_available;
4740}
4741
4742
4743size_t
4744Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
4745{
4746 Mutex::Locker locker(m_stdio_communication_mutex);
4747 size_t bytes_available = m_stderr_data.size();
4748 if (bytes_available > 0)
4749 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004750 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004751 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004752 log->Printf ("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4753 static_cast<void*>(buf),
4754 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004755 if (bytes_available > buf_size)
4756 {
4757 memcpy(buf, m_stderr_data.c_str(), buf_size);
4758 m_stderr_data.erase(0, buf_size);
4759 bytes_available = buf_size;
4760 }
4761 else
4762 {
4763 memcpy(buf, m_stderr_data.c_str(), bytes_available);
4764 m_stderr_data.clear();
4765 }
4766 }
4767 return bytes_available;
4768}
4769
4770void
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004771Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
4772{
4773 Process *process = (Process *) baton;
4774 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
4775}
4776
Greg Clayton44d93782014-01-27 23:43:24 +00004777class IOHandlerProcessSTDIO :
4778 public IOHandler
4779{
4780public:
4781 IOHandlerProcessSTDIO (Process *process,
4782 int write_fd) :
4783 IOHandler(process->GetTarget().GetDebugger()),
4784 m_process (process),
4785 m_read_file (),
4786 m_write_file (write_fd, false),
4787 m_pipe_read(),
4788 m_pipe_write()
4789 {
4790 m_read_file.SetDescriptor(GetInputFD(), false);
4791 }
4792
4793 virtual
4794 ~IOHandlerProcessSTDIO ()
4795 {
4796
4797 }
4798
4799 bool
4800 OpenPipes ()
4801 {
4802 if (m_pipe_read.IsValid() && m_pipe_write.IsValid())
4803 return true;
4804
4805 int fds[2];
Hafiz Abid Qadeer6eff1012014-03-12 10:45:23 +00004806#ifdef _WIN32
Deepak Panickal914b8d92014-01-31 18:48:46 +00004807 // pipe is not supported on windows so default to a fail condition
4808 int err = 1;
4809#else
Greg Clayton44d93782014-01-27 23:43:24 +00004810 int err = pipe(fds);
Deepak Panickal914b8d92014-01-31 18:48:46 +00004811#endif
Greg Clayton44d93782014-01-27 23:43:24 +00004812 if (err == 0)
4813 {
4814 m_pipe_read.SetDescriptor(fds[0], true);
4815 m_pipe_write.SetDescriptor(fds[1], true);
4816 return true;
4817 }
4818 return false;
4819 }
4820
4821 void
4822 ClosePipes()
4823 {
4824 m_pipe_read.Close();
4825 m_pipe_write.Close();
4826 }
4827
4828 // Each IOHandler gets to run until it is done. It should read data
4829 // from the "in" and place output into "out" and "err and return
4830 // when done.
4831 virtual void
4832 Run ()
4833 {
4834 if (m_read_file.IsValid() && m_write_file.IsValid())
4835 {
4836 SetIsDone(false);
4837 if (OpenPipes())
4838 {
4839 const int read_fd = m_read_file.GetDescriptor();
4840 const int pipe_read_fd = m_pipe_read.GetDescriptor();
4841 TerminalState terminal_state;
4842 terminal_state.Save (read_fd, false);
4843 Terminal terminal(read_fd);
4844 terminal.SetCanonical(false);
4845 terminal.SetEcho(false);
Deepak Panickal914b8d92014-01-31 18:48:46 +00004846// FD_ZERO, FD_SET are not supported on windows
Hafiz Abid Qadeer6eff1012014-03-12 10:45:23 +00004847#ifndef _WIN32
Greg Clayton44d93782014-01-27 23:43:24 +00004848 while (!GetIsDone())
4849 {
4850 fd_set read_fdset;
4851 FD_ZERO (&read_fdset);
4852 FD_SET (read_fd, &read_fdset);
4853 FD_SET (pipe_read_fd, &read_fdset);
4854 const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
4855 int num_set_fds = select (nfds, &read_fdset, NULL, NULL, NULL);
4856 if (num_set_fds < 0)
4857 {
4858 const int select_errno = errno;
4859
4860 if (select_errno != EINTR)
4861 SetIsDone(true);
4862 }
4863 else if (num_set_fds > 0)
4864 {
4865 char ch = 0;
4866 size_t n;
4867 if (FD_ISSET (read_fd, &read_fdset))
4868 {
4869 n = 1;
4870 if (m_read_file.Read(&ch, n).Success() && n == 1)
4871 {
4872 if (m_write_file.Write(&ch, n).Fail() || n != 1)
4873 SetIsDone(true);
4874 }
4875 else
4876 SetIsDone(true);
4877 }
4878 if (FD_ISSET (pipe_read_fd, &read_fdset))
4879 {
4880 // Consume the interrupt byte
4881 n = 1;
4882 m_pipe_read.Read (&ch, n);
Greg Clayton19e11352014-02-26 22:47:33 +00004883 switch (ch)
4884 {
4885 case 'q':
4886 SetIsDone(true);
4887 break;
4888 case 'i':
4889 if (StateIsRunningState(m_process->GetState()))
4890 m_process->Halt();
4891 break;
4892 }
Greg Clayton44d93782014-01-27 23:43:24 +00004893 }
4894 }
4895 }
Deepak Panickal914b8d92014-01-31 18:48:46 +00004896#endif
Greg Clayton44d93782014-01-27 23:43:24 +00004897 terminal_state.Restore();
4898
4899 }
4900 else
4901 SetIsDone(true);
4902 }
4903 else
4904 SetIsDone(true);
4905 }
4906
4907 // Hide any characters that have been displayed so far so async
4908 // output can be displayed. Refresh() will be called after the
4909 // output has been displayed.
4910 virtual void
4911 Hide ()
4912 {
4913
4914 }
4915 // Called when the async output has been received in order to update
4916 // the input reader (refresh the prompt and redisplay any current
4917 // line(s) that are being edited
4918 virtual void
4919 Refresh ()
4920 {
4921
4922 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004923
Greg Clayton44d93782014-01-27 23:43:24 +00004924 virtual void
Greg Claytone68f5d62014-02-24 22:50:57 +00004925 Cancel ()
Greg Clayton44d93782014-01-27 23:43:24 +00004926 {
4927 size_t n = 1;
Greg Clayton19e11352014-02-26 22:47:33 +00004928 char ch = 'q'; // Send 'q' for quit
Greg Clayton44d93782014-01-27 23:43:24 +00004929 m_pipe_write.Write (&ch, n);
4930 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004931
4932 virtual void
4933 Interrupt ()
4934 {
Greg Clayton19e11352014-02-26 22:47:33 +00004935#ifdef _MSC_VER
4936 // Windows doesn't support pipes, so we will send an async interrupt
4937 // event to stop the process
Greg Claytone68f5d62014-02-24 22:50:57 +00004938 if (StateIsRunningState(m_process->GetState()))
Ed Maste96e51b82014-02-25 14:20:14 +00004939 m_process->SendAsyncInterrupt();
Greg Clayton19e11352014-02-26 22:47:33 +00004940#else
4941 // Do only things that are safe to do in an interrupt context (like in
4942 // a SIGINT handler), like write 1 byte to a file descriptor. This will
4943 // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
4944 // that was written to the pipe and then call m_process->Halt() from a
4945 // much safer location in code.
4946 size_t n = 1;
4947 char ch = 'i'; // Send 'i' for interrupt
4948 m_pipe_write.Write (&ch, n);
4949#endif
Greg Claytone68f5d62014-02-24 22:50:57 +00004950 }
Greg Clayton44d93782014-01-27 23:43:24 +00004951
4952 virtual void
4953 GotEOF()
4954 {
4955
4956 }
4957
4958protected:
4959 Process *m_process;
4960 File m_read_file; // Read from this file (usually actual STDIN for LLDB
4961 File m_write_file; // Write to this file (usually the master pty for getting io to debuggee)
4962 File m_pipe_read;
4963 File m_pipe_write;
4964
4965};
4966
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004967void
Greg Clayton44d93782014-01-27 23:43:24 +00004968Process::SetSTDIOFileDescriptor (int fd)
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004969{
4970 // First set up the Read Thread for reading/handling process I/O
4971
Greg Clayton44d93782014-01-27 23:43:24 +00004972 std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004973
4974 if (conn_ap.get())
4975 {
4976 m_stdio_communication.SetConnection (conn_ap.release());
4977 if (m_stdio_communication.IsConnected())
4978 {
4979 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
4980 m_stdio_communication.StartReadThread();
4981
4982 // Now read thread is set up, set up input reader.
4983
4984 if (!m_process_input_reader.get())
Greg Clayton44d93782014-01-27 23:43:24 +00004985 m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004986 }
4987 }
4988}
4989
Greg Claytonb4874f12014-02-28 18:22:24 +00004990bool
Greg Clayton6fea17e2014-03-03 19:15:20 +00004991Process::ProcessIOHandlerIsActive ()
4992{
4993 IOHandlerSP io_handler_sp (m_process_input_reader);
4994 if (io_handler_sp)
4995 return m_target.GetDebugger().IsTopIOHandler (io_handler_sp);
4996 return false;
4997}
4998bool
Greg Clayton44d93782014-01-27 23:43:24 +00004999Process::PushProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005000{
Greg Clayton44d93782014-01-27 23:43:24 +00005001 IOHandlerSP io_handler_sp (m_process_input_reader);
5002 if (io_handler_sp)
5003 {
5004 io_handler_sp->SetIsDone(false);
5005 m_target.GetDebugger().PushIOHandler (io_handler_sp);
Greg Claytonb4874f12014-02-28 18:22:24 +00005006 return true;
Greg Clayton44d93782014-01-27 23:43:24 +00005007 }
Greg Claytonb4874f12014-02-28 18:22:24 +00005008 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005009}
5010
Greg Claytonb4874f12014-02-28 18:22:24 +00005011bool
Greg Clayton44d93782014-01-27 23:43:24 +00005012Process::PopProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005013{
Greg Clayton44d93782014-01-27 23:43:24 +00005014 IOHandlerSP io_handler_sp (m_process_input_reader);
5015 if (io_handler_sp)
Greg Claytonb4874f12014-02-28 18:22:24 +00005016 return m_target.GetDebugger().PopIOHandler (io_handler_sp);
5017 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005018}
5019
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00005020// The process needs to know about installed plug-ins
Greg Clayton99d0faf2010-11-18 23:32:35 +00005021void
Caroline Tice20bd37f2011-03-10 22:14:10 +00005022Process::SettingsInitialize ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005023{
Greg Clayton6920b522012-08-22 18:39:03 +00005024 Thread::SettingsInitialize ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00005025}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005026
Greg Clayton99d0faf2010-11-18 23:32:35 +00005027void
Caroline Tice20bd37f2011-03-10 22:14:10 +00005028Process::SettingsTerminate ()
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00005029{
Greg Clayton6920b522012-08-22 18:39:03 +00005030 Thread::SettingsTerminate ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00005031}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005032
Greg Clayton8b2fe6d2010-12-14 02:59:59 +00005033ExecutionResults
Jim Inghamf48169b2010-11-30 02:22:11 +00005034Process::RunThreadPlan (ExecutionContext &exe_ctx,
Jim Ingham372787f2012-04-07 00:00:41 +00005035 lldb::ThreadPlanSP &thread_plan_sp,
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005036 const EvaluateExpressionOptions &options,
Jim Inghamf48169b2010-11-30 02:22:11 +00005037 Stream &errors)
5038{
5039 ExecutionResults return_value = eExecutionSetupError;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005040
Jim Ingham77787032011-01-20 02:03:18 +00005041 if (thread_plan_sp.get() == NULL)
5042 {
5043 errors.Printf("RunThreadPlan called with empty thread plan.");
Greg Claytone0d378b2011-03-24 21:19:54 +00005044 return eExecutionSetupError;
Jim Ingham77787032011-01-20 02:03:18 +00005045 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005046
Jim Ingham7d7931d2013-03-28 00:05:34 +00005047 if (!thread_plan_sp->ValidatePlan(NULL))
5048 {
5049 errors.Printf ("RunThreadPlan called with an invalid thread plan.");
5050 return eExecutionSetupError;
5051 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005052
Greg Claytonc14ee322011-09-22 04:58:26 +00005053 if (exe_ctx.GetProcessPtr() != this)
5054 {
5055 errors.Printf("RunThreadPlan called on wrong process.");
5056 return eExecutionSetupError;
5057 }
5058
5059 Thread *thread = exe_ctx.GetThreadPtr();
5060 if (thread == NULL)
5061 {
5062 errors.Printf("RunThreadPlan called with invalid thread.");
5063 return eExecutionSetupError;
5064 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005065
Jim Ingham17e5c4e2011-05-17 22:24:54 +00005066 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
5067 // For that to be true the plan can't be private - since private plans suppress themselves in the
5068 // GetCompletedPlan call.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005069
Jim Ingham17e5c4e2011-05-17 22:24:54 +00005070 bool orig_plan_private = thread_plan_sp->GetPrivate();
5071 thread_plan_sp->SetPrivate(false);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005072
Jim Ingham444586b2011-01-24 06:34:17 +00005073 if (m_private_state.GetValue() != eStateStopped)
5074 {
5075 errors.Printf ("RunThreadPlan called while the private state was not stopped.");
Greg Claytone0d378b2011-03-24 21:19:54 +00005076 return eExecutionSetupError;
Jim Ingham444586b2011-01-24 06:34:17 +00005077 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005078
Jim Ingham66243842011-08-13 00:56:10 +00005079 // Save the thread & frame from the exe_ctx for restoration after we run
Greg Claytonc14ee322011-09-22 04:58:26 +00005080 const uint32_t thread_idx_id = thread->GetIndexID();
Jason Molendab57e4a12013-11-04 09:33:30 +00005081 StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
Jim Ingham11b0e052013-02-19 23:22:45 +00005082 if (!selected_frame_sp)
5083 {
5084 thread->SetSelectedFrame(0);
5085 selected_frame_sp = thread->GetSelectedFrame();
5086 if (!selected_frame_sp)
5087 {
5088 errors.Printf("RunThreadPlan called without a selected frame on thread %d", thread_idx_id);
5089 return eExecutionSetupError;
5090 }
5091 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005092
Jim Ingham11b0e052013-02-19 23:22:45 +00005093 StackID ctx_frame_id = selected_frame_sp->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00005094
5095 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
5096 // so we should arrange to reset them as well.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005097
Greg Claytonc14ee322011-09-22 04:58:26 +00005098 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005099
Jim Ingham66243842011-08-13 00:56:10 +00005100 uint32_t selected_tid;
5101 StackID selected_stack_id;
Greg Clayton762f7132011-09-18 18:59:15 +00005102 if (selected_thread_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00005103 {
5104 selected_tid = selected_thread_sp->GetIndexID();
Jim Ingham66243842011-08-13 00:56:10 +00005105 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00005106 }
5107 else
5108 {
5109 selected_tid = LLDB_INVALID_THREAD_ID;
5110 }
5111
Jim Ingham372787f2012-04-07 00:00:41 +00005112 lldb::thread_t backup_private_state_thread = LLDB_INVALID_HOST_THREAD;
Jim Ingham076b3042012-04-10 01:21:57 +00005113 lldb::StateType old_state;
5114 lldb::ThreadPlanSP stopper_base_plan_sp;
Jim Ingham372787f2012-04-07 00:00:41 +00005115
Greg Clayton5160ce52013-03-27 23:08:40 +00005116 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham372787f2012-04-07 00:00:41 +00005117 if (Host::GetCurrentThread() == m_private_state_thread)
5118 {
Jim Ingham076b3042012-04-10 01:21:57 +00005119 // Yikes, we are running on the private state thread! So we can't wait for public events on this thread, since
5120 // we are the thread that is generating public events.
Jim Ingham372787f2012-04-07 00:00:41 +00005121 // 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 +00005122 // we are fielding public events here.
5123 if (log)
Jason Molendad251c9d2012-11-17 01:41:04 +00005124 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 +00005125
Jim Ingham372787f2012-04-07 00:00:41 +00005126 backup_private_state_thread = m_private_state_thread;
Jim Ingham076b3042012-04-10 01:21:57 +00005127
5128 // One other bit of business: we want to run just this thread plan and anything it pushes, and then stop,
5129 // returning control here.
5130 // But in the normal course of things, the plan above us on the stack would be given a shot at the stop
5131 // event before deciding to stop, and we don't want that. So we insert a "stopper" base plan on the stack
5132 // before the plan we want to run. Since base plans always stop and return control to the user, that will
5133 // do just what we want.
5134 stopper_base_plan_sp.reset(new ThreadPlanBase (*thread));
5135 thread->QueueThreadPlan (stopper_base_plan_sp, false);
5136 // Have to make sure our public state is stopped, since otherwise the reporting logic below doesn't work correctly.
5137 old_state = m_public_state.GetValue();
5138 m_public_state.SetValueNoLock(eStateStopped);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005139
Jim Ingham076b3042012-04-10 01:21:57 +00005140 // Now spin up the private state thread:
Jim Ingham372787f2012-04-07 00:00:41 +00005141 StartPrivateStateThread(true);
5142 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005143
Jim Ingham372787f2012-04-07 00:00:41 +00005144 thread->QueueThreadPlan(thread_plan_sp, false); // This used to pass "true" does that make sense?
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005145
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005146 if (options.GetDebug())
5147 {
5148 // In this case, we aren't actually going to run, we just want to stop right away.
5149 // Flush this thread so we will refetch the stacks and show the correct backtrace.
5150 // FIXME: To make this prettier we should invent some stop reason for this, but that
5151 // is only cosmetic, and this functionality is only of use to lldb developers who can
5152 // live with not pretty...
5153 thread->Flush();
5154 return eExecutionStoppedForDebug;
5155 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005156
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00005157 Listener listener("lldb.process.listener.run-thread-plan");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005158
Sean Callanana46ec452012-07-11 21:31:24 +00005159 lldb::EventSP event_to_broadcast_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005160
Jim Ingham77787032011-01-20 02:03:18 +00005161 {
Sean Callanana46ec452012-07-11 21:31:24 +00005162 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
5163 // restored on exit to the function.
5164 //
5165 // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event
5166 // is put into event_to_broadcast_sp for rebroadcasting.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005167
Sean Callanana46ec452012-07-11 21:31:24 +00005168 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005169
Jim Inghamf48169b2010-11-30 02:22:11 +00005170 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00005171 {
5172 StreamString s;
Sean Callanana46ec452012-07-11 21:31:24 +00005173 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Daniel Malead01b2952012-11-29 21:49:15 +00005174 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 " to run thread plan \"%s\".",
Sean Callanana46ec452012-07-11 21:31:24 +00005175 thread->GetIndexID(),
5176 thread->GetID(),
5177 s.GetData());
5178 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005179
Sean Callanana46ec452012-07-11 21:31:24 +00005180 bool got_event;
5181 lldb::EventSP event_sp;
5182 lldb::StateType stop_state = lldb::eStateInvalid;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005183
Sean Callanana46ec452012-07-11 21:31:24 +00005184 TimeValue* timeout_ptr = NULL;
5185 TimeValue real_timeout;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005186
Jim Ingham0161b492013-02-09 01:29:05 +00005187 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 +00005188 bool do_resume = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005189 bool handle_running_event = true;
Jim Ingham35e1bda2012-10-16 21:41:58 +00005190 const uint64_t default_one_thread_timeout_usec = 250000;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005191
Jim Ingham0161b492013-02-09 01:29:05 +00005192 // This is just for accounting:
5193 uint32_t num_resumes = 0;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005194
Jim Ingham0161b492013-02-09 01:29:05 +00005195 TimeValue one_thread_timeout = TimeValue::Now();
5196 TimeValue final_timeout = one_thread_timeout;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005197
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005198 uint32_t timeout_usec = options.GetTimeoutUsec();
Jim Inghamfe1c3422014-04-16 02:24:48 +00005199
5200 // If we are going to run all threads the whole time, or if we are only going to run one thread,
5201 // then we don't need the first timeout. So we set the final timeout, and pretend we are after the
5202 // first timeout already.
5203
5204 if (!options.GetStopOthers() || !options.GetTryAllThreads())
Jim Ingham286fb1e2014-02-28 02:52:06 +00005205 {
5206 before_first_timeout = false;
5207 final_timeout.OffsetWithMicroSeconds(timeout_usec);
5208 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00005209 else
Jim Ingham0161b492013-02-09 01:29:05 +00005210 {
Jim Ingham914f4e72014-03-28 21:58:28 +00005211 uint64_t option_one_thread_timeout = options.GetOneThreadTimeoutUsec();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005212
Jim Ingham914f4e72014-03-28 21:58:28 +00005213 // If the overall wait is forever, then we only need to set the one thread timeout:
5214 if (timeout_usec == 0)
5215 {
Ed Maste801335c2014-03-31 19:28:14 +00005216 if (option_one_thread_timeout != 0)
Jim Ingham914f4e72014-03-28 21:58:28 +00005217 one_thread_timeout.OffsetWithMicroSeconds(option_one_thread_timeout);
5218 else
5219 one_thread_timeout.OffsetWithMicroSeconds(default_one_thread_timeout_usec);
5220 }
Jim Ingham0161b492013-02-09 01:29:05 +00005221 else
5222 {
Jim Ingham914f4e72014-03-28 21:58:28 +00005223 // Otherwise, if the one thread timeout is set, make sure it isn't longer than the overall timeout,
5224 // and use it, otherwise use half the total timeout, bounded by the default_one_thread_timeout_usec.
5225 uint64_t computed_one_thread_timeout;
5226 if (option_one_thread_timeout != 0)
5227 {
5228 if (timeout_usec < option_one_thread_timeout)
5229 {
5230 errors.Printf("RunThreadPlan called without one thread timeout greater than total timeout");
5231 return eExecutionSetupError;
5232 }
5233 computed_one_thread_timeout = option_one_thread_timeout;
5234 }
5235 else
5236 {
5237 computed_one_thread_timeout = timeout_usec / 2;
5238 if (computed_one_thread_timeout > default_one_thread_timeout_usec)
5239 computed_one_thread_timeout = default_one_thread_timeout_usec;
5240 }
5241 one_thread_timeout.OffsetWithMicroSeconds(computed_one_thread_timeout);
Jim Ingham0161b492013-02-09 01:29:05 +00005242 }
5243 final_timeout.OffsetWithMicroSeconds (timeout_usec);
5244 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00005245
5246 if (log)
5247 log->Printf ("Stop others: %u, try all: %u, one thread: %" PRIu64 " - all threads: %" PRIu64 ".\n",
5248 options.GetStopOthers(),
5249 options.GetTryAllThreads(),
5250 one_thread_timeout.GetAsMicroSecondsSinceJan1_1970(),
5251 final_timeout.GetAsMicroSecondsSinceJan1_1970());
5252
5253
Jim Ingham0161b492013-02-09 01:29:05 +00005254
Jim Ingham1460e4b2014-01-10 23:46:59 +00005255 // This isn't going to work if there are unfetched events on the queue.
5256 // Are there cases where we might want to run the remaining events here, and then try to
5257 // call the function? That's probably being too tricky for our own good.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005258
Jim Ingham1460e4b2014-01-10 23:46:59 +00005259 Event *other_events = listener.PeekAtNextEvent();
5260 if (other_events != NULL)
5261 {
5262 errors.Printf("Calling RunThreadPlan with pending events on the queue.");
5263 return eExecutionSetupError;
5264 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005265
Jim Ingham1460e4b2014-01-10 23:46:59 +00005266 // We also need to make sure that the next event is delivered. We might be calling a function as part of
5267 // a thread plan, in which case the last delivered event could be the running event, and we don't want
5268 // event coalescing to cause us to lose OUR running event...
5269 ForceNextEventDelivery();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005270
Jim Ingham8559a352012-11-26 23:52:18 +00005271 // This while loop must exit out the bottom, there's cleanup that we need to do when we are done.
5272 // So don't call return anywhere within it.
Jim Ingham35878c42014-04-08 21:33:21 +00005273
5274#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5275 // It's pretty much impossible to write test cases for things like:
5276 // One thread timeout expires, I go to halt, but the process already stopped
5277 // on the function call stop breakpoint. Turning on this define will make us not
5278 // fetch the first event till after the halt. So if you run a quick function, it will have
5279 // completed, and the completion event will be waiting, when you interrupt for halt.
5280 // The expression evaluation should still succeed.
5281 bool miss_first_event = true;
5282#endif
5283
Sean Callanana46ec452012-07-11 21:31:24 +00005284 while (1)
5285 {
5286 // We usually want to resume the process if we get to the top of the loop.
5287 // The only exception is if we get two running events with no intervening
5288 // stop, which can happen, we will just wait for then next stop event.
Jim Ingham0161b492013-02-09 01:29:05 +00005289 if (log)
5290 log->Printf ("Top of while loop: do_resume: %i handle_running_event: %i before_first_timeout: %i.",
5291 do_resume,
5292 handle_running_event,
5293 before_first_timeout);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005294
Jim Ingham184e9812013-01-15 02:47:48 +00005295 if (do_resume || handle_running_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005296 {
5297 // Do the initial resume and wait for the running event before going further.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005298
Jim Ingham184e9812013-01-15 02:47:48 +00005299 if (do_resume)
Sean Callanana46ec452012-07-11 21:31:24 +00005300 {
Jim Ingham0161b492013-02-09 01:29:05 +00005301 num_resumes++;
Jim Ingham184e9812013-01-15 02:47:48 +00005302 Error resume_error = PrivateResume ();
5303 if (!resume_error.Success())
5304 {
Jim Ingham0161b492013-02-09 01:29:05 +00005305 errors.Printf("Error resuming inferior the %d time: \"%s\".\n",
5306 num_resumes,
5307 resume_error.AsCString());
Jim Ingham184e9812013-01-15 02:47:48 +00005308 return_value = eExecutionSetupError;
5309 break;
5310 }
Sean Callanana46ec452012-07-11 21:31:24 +00005311 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005312
Jim Ingham0161b492013-02-09 01:29:05 +00005313 TimeValue resume_timeout = TimeValue::Now();
5314 resume_timeout.OffsetWithMicroSeconds(500000);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005315
Jim Ingham0161b492013-02-09 01:29:05 +00005316 got_event = listener.WaitForEvent(&resume_timeout, event_sp);
Sean Callanana46ec452012-07-11 21:31:24 +00005317 if (!got_event)
5318 {
5319 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005320 log->Printf ("Process::RunThreadPlan(): didn't get any event after resume %d, exiting.",
5321 num_resumes);
Sean Callanana46ec452012-07-11 21:31:24 +00005322
Jim Ingham0161b492013-02-09 01:29:05 +00005323 errors.Printf("Didn't get any event after resume %d, exiting.", num_resumes);
Sean Callanana46ec452012-07-11 21:31:24 +00005324 return_value = eExecutionSetupError;
5325 break;
5326 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005327
Sean Callanana46ec452012-07-11 21:31:24 +00005328 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Ingham0161b492013-02-09 01:29:05 +00005329
Sean Callanana46ec452012-07-11 21:31:24 +00005330 if (stop_state != eStateRunning)
5331 {
Jim Ingham0161b492013-02-09 01:29:05 +00005332 bool restarted = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005333
Jim Ingham0161b492013-02-09 01:29:05 +00005334 if (stop_state == eStateStopped)
5335 {
5336 restarted = Process::ProcessEventData::GetRestartedFromEvent(event_sp.get());
5337 if (log)
5338 log->Printf("Process::RunThreadPlan(): didn't get running event after "
5339 "resume %d, got %s instead (restarted: %i, do_resume: %i, handle_running_event: %i).",
5340 num_resumes,
5341 StateAsCString(stop_state),
5342 restarted,
5343 do_resume,
5344 handle_running_event);
5345 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005346
Jim Ingham0161b492013-02-09 01:29:05 +00005347 if (restarted)
5348 {
5349 // This is probably an overabundance of caution, I don't think I should ever get a stopped & restarted
5350 // event here. But if I do, the best thing is to Halt and then get out of here.
5351 Halt();
5352 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005353
Jim Ingham35e1bda2012-10-16 21:41:58 +00005354 errors.Printf("Didn't get running event after initial resume, got %s instead.",
5355 StateAsCString(stop_state));
Sean Callanana46ec452012-07-11 21:31:24 +00005356 return_value = eExecutionSetupError;
5357 break;
5358 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005359
Sean Callanana46ec452012-07-11 21:31:24 +00005360 if (log)
5361 log->PutCString ("Process::RunThreadPlan(): resuming succeeded.");
5362 // We need to call the function synchronously, so spin waiting for it to return.
5363 // If we get interrupted while executing, we're going to lose our context, and
5364 // won't be able to gather the result at this point.
5365 // We set the timeout AFTER the resume, since the resume takes some time and we
5366 // don't want to charge that to the timeout.
Sean Callanana46ec452012-07-11 21:31:24 +00005367 }
Jim Ingham0f16e732011-02-08 05:20:59 +00005368 else
5369 {
Sean Callanana46ec452012-07-11 21:31:24 +00005370 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005371 log->PutCString ("Process::RunThreadPlan(): waiting for next event.");
Jim Ingham0f16e732011-02-08 05:20:59 +00005372 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005373
Jim Ingham0161b492013-02-09 01:29:05 +00005374 if (before_first_timeout)
5375 {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005376 if (options.GetTryAllThreads())
Jim Ingham0161b492013-02-09 01:29:05 +00005377 timeout_ptr = &one_thread_timeout;
5378 else
5379 {
5380 if (timeout_usec == 0)
5381 timeout_ptr = NULL;
5382 else
5383 timeout_ptr = &final_timeout;
5384 }
5385 }
5386 else
5387 {
5388 if (timeout_usec == 0)
5389 timeout_ptr = NULL;
5390 else
5391 timeout_ptr = &final_timeout;
5392 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005393
Jim Ingham0161b492013-02-09 01:29:05 +00005394 do_resume = true;
5395 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005396
Sean Callanana46ec452012-07-11 21:31:24 +00005397 // Now wait for the process to stop again:
Sean Callanana46ec452012-07-11 21:31:24 +00005398 event_sp.reset();
Jim Ingham0f16e732011-02-08 05:20:59 +00005399
Jim Ingham0f16e732011-02-08 05:20:59 +00005400 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00005401 {
Sean Callanana46ec452012-07-11 21:31:24 +00005402 if (timeout_ptr)
5403 {
Matt Kopec676a4872013-02-21 23:55:31 +00005404 log->Printf ("Process::RunThreadPlan(): about to wait - now is %" PRIu64 " - endpoint is %" PRIu64,
Jim Ingham0161b492013-02-09 01:29:05 +00005405 TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
5406 timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
Sean Callanana46ec452012-07-11 21:31:24 +00005407 }
Jim Ingham20829ac2011-08-09 22:24:33 +00005408 else
Sean Callanana46ec452012-07-11 21:31:24 +00005409 {
5410 log->Printf ("Process::RunThreadPlan(): about to wait forever.");
5411 }
5412 }
Jim Ingham35878c42014-04-08 21:33:21 +00005413
5414#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5415 // See comment above...
5416 if (miss_first_event)
5417 {
5418 usleep(1000);
5419 miss_first_event = false;
5420 got_event = false;
5421 }
5422 else
5423#endif
Sean Callanana46ec452012-07-11 21:31:24 +00005424 got_event = listener.WaitForEvent (timeout_ptr, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005425
Sean Callanana46ec452012-07-11 21:31:24 +00005426 if (got_event)
5427 {
5428 if (event_sp.get())
5429 {
5430 bool keep_going = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005431 if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005432 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005433 Halt();
Jim Inghamcfc09352012-07-27 23:57:19 +00005434 return_value = eExecutionInterrupted;
5435 errors.Printf ("Execution halted by user interrupt.");
5436 if (log)
5437 log->Printf ("Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting.");
Jim Ingham0161b492013-02-09 01:29:05 +00005438 break;
Jim Inghamcfc09352012-07-27 23:57:19 +00005439 }
5440 else
5441 {
5442 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5443 if (log)
5444 log->Printf("Process::RunThreadPlan(): in while loop, got event: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005445
Jim Inghamcfc09352012-07-27 23:57:19 +00005446 switch (stop_state)
Sean Callanana46ec452012-07-11 21:31:24 +00005447 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005448 case lldb::eStateStopped:
Sean Callanana46ec452012-07-11 21:31:24 +00005449 {
Jim Ingham0161b492013-02-09 01:29:05 +00005450 // We stopped, figure out what we are going to do now.
Jim Inghamcfc09352012-07-27 23:57:19 +00005451 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
5452 if (!thread_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005453 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005454 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Sean Callanana46ec452012-07-11 21:31:24 +00005455 if (log)
Jim Inghamcfc09352012-07-27 23:57:19 +00005456 log->Printf ("Process::RunThreadPlan(): execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
5457 return_value = eExecutionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005458 }
5459 else
5460 {
Jim Ingham0161b492013-02-09 01:29:05 +00005461 // If we were restarted, we just need to go back up to fetch another event.
5462 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
Jim Inghamcfc09352012-07-27 23:57:19 +00005463 {
5464 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005465 {
5466 log->Printf ("Process::RunThreadPlan(): Got a stop and restart, so we'll continue waiting.");
5467 }
5468 keep_going = true;
5469 do_resume = false;
5470 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005471
Jim Inghamcfc09352012-07-27 23:57:19 +00005472 }
5473 else
5474 {
Jim Ingham0161b492013-02-09 01:29:05 +00005475 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
5476 StopReason stop_reason = eStopReasonInvalid;
5477 if (stop_info_sp)
5478 stop_reason = stop_info_sp->GetStopReason();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005479
Jim Ingham0161b492013-02-09 01:29:05 +00005480 // FIXME: We only check if the stop reason is plan complete, should we make sure that
5481 // it is OUR plan that is complete?
5482 if (stop_reason == eStopReasonPlanComplete)
Jim Ingham184e9812013-01-15 02:47:48 +00005483 {
5484 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005485 log->PutCString ("Process::RunThreadPlan(): execution completed successfully.");
5486 // Now mark this plan as private so it doesn't get reported as the stop reason
5487 // after this point.
5488 if (thread_plan_sp)
5489 thread_plan_sp->SetPrivate (orig_plan_private);
5490 return_value = eExecutionCompleted;
Jim Ingham184e9812013-01-15 02:47:48 +00005491 }
5492 else
5493 {
Jim Ingham0161b492013-02-09 01:29:05 +00005494 // Something restarted the target, so just wait for it to stop for real.
Jim Ingham184e9812013-01-15 02:47:48 +00005495 if (stop_reason == eStopReasonBreakpoint)
Jim Ingham0161b492013-02-09 01:29:05 +00005496 {
5497 if (log)
5498 log->Printf ("Process::RunThreadPlan() stopped for breakpoint: %s.", stop_info_sp->GetDescription());
Jim Ingham184e9812013-01-15 02:47:48 +00005499 return_value = eExecutionHitBreakpoint;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005500 if (!options.DoesIgnoreBreakpoints())
Sean Callanan4b388c92013-07-30 19:54:09 +00005501 {
5502 event_to_broadcast_sp = event_sp;
5503 }
Jim Ingham0161b492013-02-09 01:29:05 +00005504 }
Jim Ingham184e9812013-01-15 02:47:48 +00005505 else
Jim Ingham0161b492013-02-09 01:29:05 +00005506 {
5507 if (log)
5508 log->PutCString ("Process::RunThreadPlan(): thread plan didn't successfully complete.");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005509 if (!options.DoesUnwindOnError())
Sean Callanan4b388c92013-07-30 19:54:09 +00005510 event_to_broadcast_sp = event_sp;
Jim Ingham184e9812013-01-15 02:47:48 +00005511 return_value = eExecutionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005512 }
Jim Ingham184e9812013-01-15 02:47:48 +00005513 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005514 }
Sean Callanana46ec452012-07-11 21:31:24 +00005515 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005516 }
5517 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005518
Jim Inghamcfc09352012-07-27 23:57:19 +00005519 case lldb::eStateRunning:
Jim Ingham0161b492013-02-09 01:29:05 +00005520 // This shouldn't really happen, but sometimes we do get two running events without an
5521 // intervening stop, and in that case we should just go back to waiting for the stop.
Jim Inghamcfc09352012-07-27 23:57:19 +00005522 do_resume = false;
5523 keep_going = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005524 handle_running_event = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005525 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005526
Jim Inghamcfc09352012-07-27 23:57:19 +00005527 default:
5528 if (log)
5529 log->Printf("Process::RunThreadPlan(): execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005530
Jim Inghamcfc09352012-07-27 23:57:19 +00005531 if (stop_state == eStateExited)
5532 event_to_broadcast_sp = event_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005533
Sean Callananbf154da2012-08-08 17:35:10 +00005534 errors.Printf ("Execution stopped with unexpected state.\n");
Jim Inghamcfc09352012-07-27 23:57:19 +00005535 return_value = eExecutionInterrupted;
5536 break;
5537 }
Sean Callanana46ec452012-07-11 21:31:24 +00005538 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005539
Sean Callanana46ec452012-07-11 21:31:24 +00005540 if (keep_going)
5541 continue;
5542 else
5543 break;
5544 }
5545 else
5546 {
5547 if (log)
5548 log->PutCString ("Process::RunThreadPlan(): got_event was true, but the event pointer was null. How odd...");
5549 return_value = eExecutionInterrupted;
5550 break;
5551 }
5552 }
5553 else
5554 {
5555 // If we didn't get an event that means we've timed out...
5556 // We will interrupt the process here. Depending on what we were asked to do we will
5557 // either exit, or try with all threads running for the same timeout.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005558
Sean Callanana46ec452012-07-11 21:31:24 +00005559 if (log) {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005560 if (options.GetTryAllThreads())
Sean Callanana46ec452012-07-11 21:31:24 +00005561 {
Jim Ingham0161b492013-02-09 01:29:05 +00005562 if (before_first_timeout)
Jim Inghamfe1c3422014-04-16 02:24:48 +00005563 {
5564 if (timeout_usec != 0)
5565 {
5566 uint64_t remaining_time = final_timeout - TimeValue::Now();
5567 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
5568 "running for %" PRIu64 " usec with all threads enabled.",
5569 remaining_time);
5570 }
5571 else
5572 {
5573 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
5574 "running for ever with all threads enabled.");
5575 }
5576 }
Sean Callanana46ec452012-07-11 21:31:24 +00005577 else
5578 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
Jason Molenda6a8658a2013-10-27 02:32:23 +00005579 "and timeout: %u timed out, abandoning execution.",
Jim Ingham35e1bda2012-10-16 21:41:58 +00005580 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005581 }
5582 else
Jason Molenda6a8658a2013-10-27 02:32:23 +00005583 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %u timed out, "
Jim Ingham35e1bda2012-10-16 21:41:58 +00005584 "abandoning execution.",
5585 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005586 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005587
Jim Ingham0161b492013-02-09 01:29:05 +00005588 // It is possible that between the time we issued the Halt, and we get around to calling Halt the target
5589 // could have stopped. That's fine, Halt will figure that out and send the appropriate Stopped event.
5590 // BUT it is also possible that we stopped & restarted (e.g. hit a signal with "stop" set to false.) In
5591 // that case, we'll get the stopped & restarted event, and we should go back to waiting for the Halt's
5592 // stopped event. That's what this while loop does.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005593
Jim Ingham0161b492013-02-09 01:29:05 +00005594 bool back_to_top = true;
5595 uint32_t try_halt_again = 0;
5596 bool do_halt = true;
5597 const uint32_t num_retries = 5;
5598 while (try_halt_again < num_retries)
Sean Callanana46ec452012-07-11 21:31:24 +00005599 {
Jim Ingham0161b492013-02-09 01:29:05 +00005600 Error halt_error;
5601 if (do_halt)
5602 {
5603 if (log)
5604 log->Printf ("Process::RunThreadPlan(): Running Halt.");
5605 halt_error = Halt();
5606 }
5607 if (halt_error.Success())
5608 {
5609 if (log)
5610 log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005611
Jim Ingham0161b492013-02-09 01:29:05 +00005612 real_timeout = TimeValue::Now();
5613 real_timeout.OffsetWithMicroSeconds(500000);
5614
5615 got_event = listener.WaitForEvent(&real_timeout, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005616
Jim Ingham0161b492013-02-09 01:29:05 +00005617 if (got_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005618 {
Jim Ingham0161b492013-02-09 01:29:05 +00005619 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5620 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005621 {
Jim Ingham0161b492013-02-09 01:29:05 +00005622 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
5623 if (stop_state == lldb::eStateStopped
5624 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
5625 log->PutCString (" Event was the Halt interruption event.");
Sean Callanana46ec452012-07-11 21:31:24 +00005626 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005627
Jim Ingham0161b492013-02-09 01:29:05 +00005628 if (stop_state == lldb::eStateStopped)
Sean Callanana46ec452012-07-11 21:31:24 +00005629 {
Jim Ingham0161b492013-02-09 01:29:05 +00005630 // Between the time we initiated the Halt and the time we delivered it, the process could have
5631 // already finished its job. Check that here:
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005632
Jim Ingham0161b492013-02-09 01:29:05 +00005633 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
5634 {
5635 if (log)
5636 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
5637 "Exiting wait loop.");
5638 return_value = eExecutionCompleted;
5639 back_to_top = false;
5640 break;
5641 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005642
Jim Ingham0161b492013-02-09 01:29:05 +00005643 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5644 {
5645 if (log)
5646 log->PutCString ("Process::RunThreadPlan(): Went to halt but got a restarted event, there must be an un-restarted stopped event so try again... "
5647 "Exiting wait loop.");
5648 try_halt_again++;
5649 do_halt = false;
5650 continue;
5651 }
Sean Callanana46ec452012-07-11 21:31:24 +00005652
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005653 if (!options.GetTryAllThreads())
Jim Ingham0161b492013-02-09 01:29:05 +00005654 {
5655 if (log)
5656 log->PutCString ("Process::RunThreadPlan(): try_all_threads was false, we stopped so now we're quitting.");
5657 return_value = eExecutionInterrupted;
5658 back_to_top = false;
5659 break;
5660 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005661
Jim Ingham0161b492013-02-09 01:29:05 +00005662 if (before_first_timeout)
5663 {
5664 // Set all the other threads to run, and return to the top of the loop, which will continue;
5665 before_first_timeout = false;
5666 thread_plan_sp->SetStopOthers (false);
5667 if (log)
5668 log->PutCString ("Process::RunThreadPlan(): about to resume.");
Sean Callanana46ec452012-07-11 21:31:24 +00005669
Jim Ingham0161b492013-02-09 01:29:05 +00005670 back_to_top = true;
5671 break;
5672 }
5673 else
5674 {
5675 // Running all threads failed, so return Interrupted.
5676 if (log)
5677 log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
5678 return_value = eExecutionInterrupted;
5679 back_to_top = false;
5680 break;
5681 }
Sean Callanana46ec452012-07-11 21:31:24 +00005682 }
5683 }
5684 else
Jim Ingham0161b492013-02-09 01:29:05 +00005685 { if (log)
5686 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
5687 "I'm getting out of here passing Interrupted.");
Sean Callanana46ec452012-07-11 21:31:24 +00005688 return_value = eExecutionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005689 back_to_top = false;
5690 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005691 }
5692 }
Jim Ingham0161b492013-02-09 01:29:05 +00005693 else
5694 {
5695 try_halt_again++;
5696 continue;
5697 }
Sean Callanana46ec452012-07-11 21:31:24 +00005698 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005699
Jim Ingham0161b492013-02-09 01:29:05 +00005700 if (!back_to_top || try_halt_again > num_retries)
5701 break;
5702 else
5703 continue;
Sean Callanana46ec452012-07-11 21:31:24 +00005704 }
Sean Callanana46ec452012-07-11 21:31:24 +00005705 } // END WAIT LOOP
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005706
Sean Callanana46ec452012-07-11 21:31:24 +00005707 // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
5708 if (IS_VALID_LLDB_HOST_THREAD(backup_private_state_thread))
5709 {
5710 StopPrivateStateThread();
5711 Error error;
5712 m_private_state_thread = backup_private_state_thread;
Sean Callanan9a028512012-08-09 00:50:26 +00005713 if (stopper_base_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005714 {
5715 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5716 }
5717 m_public_state.SetValueNoLock(old_state);
5718
5719 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005720
Jim Ingham184e9812013-01-15 02:47:48 +00005721 // Restore the thread state if we are going to discard the plan execution. There are three cases where this
5722 // could happen:
5723 // 1) The execution successfully completed
5724 // 2) We hit a breakpoint, and ignore_breakpoints was true
5725 // 3) We got some other error, and discard_on_error was true
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005726 bool should_unwind = (return_value == eExecutionInterrupted && options.DoesUnwindOnError())
5727 || (return_value == eExecutionHitBreakpoint && options.DoesIgnoreBreakpoints());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005728
Jim Ingham184e9812013-01-15 02:47:48 +00005729 if (return_value == eExecutionCompleted
5730 || should_unwind)
Jim Ingham8559a352012-11-26 23:52:18 +00005731 {
5732 thread_plan_sp->RestoreThreadState();
5733 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005734
Sean Callanana46ec452012-07-11 21:31:24 +00005735 // Now do some processing on the results of the run:
Jim Ingham184e9812013-01-15 02:47:48 +00005736 if (return_value == eExecutionInterrupted || return_value == eExecutionHitBreakpoint)
Sean Callanana46ec452012-07-11 21:31:24 +00005737 {
5738 if (log)
5739 {
5740 StreamString s;
5741 if (event_sp)
5742 event_sp->Dump (&s);
5743 else
5744 {
5745 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
5746 }
5747
5748 StreamString ts;
5749
5750 const char *event_explanation = NULL;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005751
Sean Callanana46ec452012-07-11 21:31:24 +00005752 do
5753 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005754 if (!event_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005755 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005756 event_explanation = "<no event>";
Sean Callanana46ec452012-07-11 21:31:24 +00005757 break;
5758 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005759 else if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005760 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005761 event_explanation = "<user interrupt>";
Sean Callanana46ec452012-07-11 21:31:24 +00005762 break;
5763 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005764 else
Sean Callanana46ec452012-07-11 21:31:24 +00005765 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005766 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
5767
5768 if (!event_data)
Sean Callanana46ec452012-07-11 21:31:24 +00005769 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005770 event_explanation = "<no event data>";
5771 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005772 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005773
Jim Inghamcfc09352012-07-27 23:57:19 +00005774 Process *process = event_data->GetProcessSP().get();
5775
5776 if (!process)
Sean Callanana46ec452012-07-11 21:31:24 +00005777 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005778 event_explanation = "<no process>";
5779 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005780 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005781
Jim Inghamcfc09352012-07-27 23:57:19 +00005782 ThreadList &thread_list = process->GetThreadList();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005783
Jim Inghamcfc09352012-07-27 23:57:19 +00005784 uint32_t num_threads = thread_list.GetSize();
5785 uint32_t thread_index;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005786
Jim Inghamcfc09352012-07-27 23:57:19 +00005787 ts.Printf("<%u threads> ", num_threads);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005788
Jim Inghamcfc09352012-07-27 23:57:19 +00005789 for (thread_index = 0;
5790 thread_index < num_threads;
5791 ++thread_index)
5792 {
5793 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005794
Jim Inghamcfc09352012-07-27 23:57:19 +00005795 if (!thread)
5796 {
5797 ts.Printf("<?> ");
5798 continue;
5799 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005800
Daniel Malead01b2952012-11-29 21:49:15 +00005801 ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00005802 RegisterContext *register_context = thread->GetRegisterContext().get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005803
Jim Inghamcfc09352012-07-27 23:57:19 +00005804 if (register_context)
Daniel Malead01b2952012-11-29 21:49:15 +00005805 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
Jim Inghamcfc09352012-07-27 23:57:19 +00005806 else
5807 ts.Printf("[ip unknown] ");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005808
Jim Inghamcfc09352012-07-27 23:57:19 +00005809 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
5810 if (stop_info_sp)
5811 {
5812 const char *stop_desc = stop_info_sp->GetDescription();
5813 if (stop_desc)
5814 ts.PutCString (stop_desc);
5815 }
5816 ts.Printf(">");
5817 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005818
Jim Inghamcfc09352012-07-27 23:57:19 +00005819 event_explanation = ts.GetData();
Sean Callanana46ec452012-07-11 21:31:24 +00005820 }
Sean Callanana46ec452012-07-11 21:31:24 +00005821 } while (0);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005822
Jim Inghamcfc09352012-07-27 23:57:19 +00005823 if (event_explanation)
5824 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
Sean Callanana46ec452012-07-11 21:31:24 +00005825 else
Jim Inghamcfc09352012-07-27 23:57:19 +00005826 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
5827 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005828
Jim Inghame4483cf2013-09-27 01:13:01 +00005829 if (should_unwind)
Jim Inghamcfc09352012-07-27 23:57:19 +00005830 {
5831 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005832 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - discarding thread plans up to %p.",
5833 static_cast<void*>(thread_plan_sp.get()));
Jim Inghamcfc09352012-07-27 23:57:19 +00005834 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5835 thread_plan_sp->SetPrivate (orig_plan_private);
5836 }
5837 else
5838 {
5839 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005840 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - for plan: %p not discarding.",
5841 static_cast<void*>(thread_plan_sp.get()));
Sean Callanana46ec452012-07-11 21:31:24 +00005842 }
5843 }
5844 else if (return_value == eExecutionSetupError)
5845 {
5846 if (log)
5847 log->PutCString("Process::RunThreadPlan(): execution set up error.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005848
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005849 if (options.DoesUnwindOnError())
Jim Ingham0f16e732011-02-08 05:20:59 +00005850 {
Greg Claytonc14ee322011-09-22 04:58:26 +00005851 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00005852 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham0f16e732011-02-08 05:20:59 +00005853 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005854 }
5855 else
5856 {
Sean Callanana46ec452012-07-11 21:31:24 +00005857 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00005858 {
Jim Ingham0f16e732011-02-08 05:20:59 +00005859 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005860 log->PutCString("Process::RunThreadPlan(): thread plan is done");
5861 return_value = eExecutionCompleted;
5862 }
5863 else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
5864 {
5865 if (log)
5866 log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
5867 return_value = eExecutionDiscarded;
5868 }
5869 else
5870 {
5871 if (log)
5872 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005873 if (options.DoesUnwindOnError() && thread_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005874 {
5875 if (log)
Jim Ingham184e9812013-01-15 02:47:48 +00005876 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause unwind_on_error is set.");
Sean Callanana46ec452012-07-11 21:31:24 +00005877 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5878 thread_plan_sp->SetPrivate (orig_plan_private);
5879 }
5880 }
5881 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005882
Sean Callanana46ec452012-07-11 21:31:24 +00005883 // Thread we ran the function in may have gone away because we ran the target
5884 // Check that it's still there, and if it is put it back in the context. Also restore the
5885 // frame in the context if it is still present.
5886 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
5887 if (thread)
5888 {
5889 exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
5890 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005891
Sean Callanana46ec452012-07-11 21:31:24 +00005892 // Also restore the current process'es selected frame & thread, since this function calling may
5893 // be done behind the user's back.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005894
Sean Callanana46ec452012-07-11 21:31:24 +00005895 if (selected_tid != LLDB_INVALID_THREAD_ID)
5896 {
5897 if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
5898 {
5899 // We were able to restore the selected thread, now restore the frame:
Daniel Maleaa012d3a2013-07-31 20:21:20 +00005900 Mutex::Locker lock(GetThreadList().GetMutex());
Jason Molendab57e4a12013-11-04 09:33:30 +00005901 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
Sean Callanana46ec452012-07-11 21:31:24 +00005902 if (old_frame_sp)
5903 GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
Jim Inghamf48169b2010-11-30 02:22:11 +00005904 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005905 }
5906 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005907
Sean Callanana46ec452012-07-11 21:31:24 +00005908 // If the process exited during the run of the thread plan, notify everyone.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005909
Sean Callanana46ec452012-07-11 21:31:24 +00005910 if (event_to_broadcast_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00005911 {
Sean Callanana46ec452012-07-11 21:31:24 +00005912 if (log)
5913 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5914 BroadcastEvent(event_to_broadcast_sp);
Jim Inghamf48169b2010-11-30 02:22:11 +00005915 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005916
Jim Inghamf48169b2010-11-30 02:22:11 +00005917 return return_value;
5918}
5919
5920const char *
5921Process::ExecutionResultAsCString (ExecutionResults result)
5922{
5923 const char *result_name;
5924
5925 switch (result)
5926 {
Greg Claytone0d378b2011-03-24 21:19:54 +00005927 case eExecutionCompleted:
Jim Inghamf48169b2010-11-30 02:22:11 +00005928 result_name = "eExecutionCompleted";
5929 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00005930 case eExecutionDiscarded:
Jim Inghamf48169b2010-11-30 02:22:11 +00005931 result_name = "eExecutionDiscarded";
5932 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00005933 case eExecutionInterrupted:
Jim Inghamf48169b2010-11-30 02:22:11 +00005934 result_name = "eExecutionInterrupted";
5935 break;
Jim Ingham184e9812013-01-15 02:47:48 +00005936 case eExecutionHitBreakpoint:
5937 result_name = "eExecutionHitBreakpoint";
5938 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00005939 case eExecutionSetupError:
Jim Inghamf48169b2010-11-30 02:22:11 +00005940 result_name = "eExecutionSetupError";
5941 break;
Greg Claytone0d378b2011-03-24 21:19:54 +00005942 case eExecutionTimedOut:
Jim Inghamf48169b2010-11-30 02:22:11 +00005943 result_name = "eExecutionTimedOut";
5944 break;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005945 case eExecutionStoppedForDebug:
5946 result_name = "eExecutionStoppedForDebug";
5947 break;
Jim Inghamf48169b2010-11-30 02:22:11 +00005948 }
5949 return result_name;
5950}
5951
Greg Clayton7260f622011-04-18 08:33:37 +00005952void
5953Process::GetStatus (Stream &strm)
5954{
5955 const StateType state = GetState();
Greg Clayton2637f822011-11-17 01:23:07 +00005956 if (StateIsStoppedState(state, false))
Greg Clayton7260f622011-04-18 08:33:37 +00005957 {
5958 if (state == eStateExited)
5959 {
5960 int exit_status = GetExitStatus();
5961 const char *exit_description = GetExitDescription();
Daniel Malead01b2952012-11-29 21:49:15 +00005962 strm.Printf ("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
Greg Clayton7260f622011-04-18 08:33:37 +00005963 GetID(),
5964 exit_status,
5965 exit_status,
5966 exit_description ? exit_description : "");
5967 }
5968 else
5969 {
5970 if (state == eStateConnected)
5971 strm.Printf ("Connected to remote target.\n");
5972 else
Daniel Malead01b2952012-11-29 21:49:15 +00005973 strm.Printf ("Process %" PRIu64 " %s\n", GetID(), StateAsCString (state));
Greg Clayton7260f622011-04-18 08:33:37 +00005974 }
5975 }
5976 else
5977 {
Daniel Malead01b2952012-11-29 21:49:15 +00005978 strm.Printf ("Process %" PRIu64 " is running.\n", GetID());
Greg Clayton7260f622011-04-18 08:33:37 +00005979 }
5980}
5981
5982size_t
5983Process::GetThreadStatus (Stream &strm,
5984 bool only_threads_with_stop_reason,
5985 uint32_t start_frame,
5986 uint32_t num_frames,
5987 uint32_t num_frames_with_source)
5988{
5989 size_t num_thread_infos_dumped = 0;
5990
Jim Ingham4a65fb12014-03-07 11:20:03 +00005991 // You can't hold the thread list lock while calling Thread::GetStatus. That very well might run code (e.g. if we need it
5992 // to get return values or arguments.) For that to work the process has to be able to acquire it. So instead copy the thread
5993 // ID's, and look them up one by one:
5994
5995 uint32_t num_threads;
5996 std::vector<uint32_t> thread_index_array;
5997 //Scope for thread list locker;
5998 {
5999 Mutex::Locker locker (GetThreadList().GetMutex());
6000 ThreadList &curr_thread_list = GetThreadList();
6001 num_threads = curr_thread_list.GetSize();
6002 uint32_t idx;
6003 thread_index_array.resize(num_threads);
6004 for (idx = 0; idx < num_threads; ++idx)
6005 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
6006 }
6007
Greg Clayton7260f622011-04-18 08:33:37 +00006008 for (uint32_t i = 0; i < num_threads; i++)
6009 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00006010 ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_index_array[i]));
6011 if (thread_sp)
Greg Clayton7260f622011-04-18 08:33:37 +00006012 {
6013 if (only_threads_with_stop_reason)
6014 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00006015 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
Jim Ingham5d88a062012-10-16 00:09:33 +00006016 if (stop_info_sp.get() == NULL || !stop_info_sp->IsValid())
Greg Clayton7260f622011-04-18 08:33:37 +00006017 continue;
6018 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00006019 thread_sp->GetStatus (strm,
Greg Clayton7260f622011-04-18 08:33:37 +00006020 start_frame,
6021 num_frames,
6022 num_frames_with_source);
6023 ++num_thread_infos_dumped;
6024 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00006025 else
6026 {
6027 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
6028 if (log)
6029 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
6030
6031 }
Greg Clayton7260f622011-04-18 08:33:37 +00006032 }
6033 return num_thread_infos_dumped;
6034}
6035
Greg Claytona9f40ad2012-02-22 04:37:26 +00006036void
6037Process::AddInvalidMemoryRegion (const LoadRange &region)
6038{
6039 m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize());
6040}
6041
6042bool
6043Process::RemoveInvalidMemoryRange (const LoadRange &region)
6044{
6045 return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), region.GetByteSize());
6046}
6047
Jim Ingham372787f2012-04-07 00:00:41 +00006048void
6049Process::AddPreResumeAction (PreResumeActionCallback callback, void *baton)
6050{
6051 m_pre_resume_actions.push_back(PreResumeCallbackAndBaton (callback, baton));
6052}
6053
6054bool
6055Process::RunPreResumeActions ()
6056{
6057 bool result = true;
6058 while (!m_pre_resume_actions.empty())
6059 {
6060 struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back();
6061 m_pre_resume_actions.pop_back();
6062 bool this_result = action.callback (action.baton);
6063 if (result == true) result = this_result;
6064 }
6065 return result;
6066}
6067
6068void
6069Process::ClearPreResumeActions ()
6070{
6071 m_pre_resume_actions.clear();
6072}
Greg Claytona9f40ad2012-02-22 04:37:26 +00006073
Greg Claytonfa559e52012-05-18 02:38:05 +00006074void
6075Process::Flush ()
6076{
6077 m_thread_list.Flush();
Jason Molenda5e8dce42013-12-13 00:29:16 +00006078 m_extended_thread_list.Flush();
6079 m_extended_thread_stop_id = 0;
6080 m_queue_list.Clear();
6081 m_queue_list_stop_id = 0;
Greg Claytonfa559e52012-05-18 02:38:05 +00006082}
Greg Clayton90ba8112012-12-05 00:16:59 +00006083
6084void
6085Process::DidExec ()
6086{
6087 Target &target = GetTarget();
6088 target.CleanupProcess ();
Greg Claytonb35db632013-11-09 00:03:31 +00006089 target.ClearModules(false);
Greg Clayton90ba8112012-12-05 00:16:59 +00006090 m_dynamic_checkers_ap.reset();
6091 m_abi_sp.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00006092 m_system_runtime_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00006093 m_os_ap.reset();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006094 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00006095 m_jit_loaders_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00006096 m_image_tokens.clear();
6097 m_allocated_memory_cache.Clear();
6098 m_language_runtimes.clear();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006099 m_thread_list.DiscardThreadPlans();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006100 m_memory_cache.Clear(true);
Greg Clayton90ba8112012-12-05 00:16:59 +00006101 DoDidExec();
6102 CompleteAttach ();
Greg Clayton095eeaa2013-11-05 23:28:00 +00006103 // Flush the process (threads and all stack frames) after running CompleteAttach()
6104 // in case the dynamic loader loaded things in new locations.
6105 Flush();
Greg Claytonb35db632013-11-09 00:03:31 +00006106
6107 // After we figure out what was loaded/unloaded in CompleteAttach,
6108 // we need to let the target know so it can do any cleanup it needs to.
6109 target.DidExec();
Greg Clayton90ba8112012-12-05 00:16:59 +00006110}
Greg Clayton095eeaa2013-11-05 23:28:00 +00006111
Jim Ingham1460e4b2014-01-10 23:46:59 +00006112addr_t
6113Process::ResolveIndirectFunction(const Address *address, Error &error)
6114{
6115 if (address == nullptr)
6116 {
Jean-Daniel Dupasef37711f2014-02-08 20:22:05 +00006117 error.SetErrorString("Invalid address argument");
Jim Ingham1460e4b2014-01-10 23:46:59 +00006118 return LLDB_INVALID_ADDRESS;
6119 }
6120
6121 addr_t function_addr = LLDB_INVALID_ADDRESS;
6122
6123 addr_t addr = address->GetLoadAddress(&GetTarget());
6124 std::map<addr_t,addr_t>::const_iterator iter = m_resolved_indirect_addresses.find(addr);
6125 if (iter != m_resolved_indirect_addresses.end())
6126 {
6127 function_addr = (*iter).second;
6128 }
6129 else
6130 {
6131 if (!InferiorCall(this, address, function_addr))
6132 {
6133 Symbol *symbol = address->CalculateSymbolContextSymbol();
6134 error.SetErrorStringWithFormat ("Unable to call resolver for indirect function %s",
6135 symbol ? symbol->GetName().AsCString() : "<UNKNOWN>");
6136 function_addr = LLDB_INVALID_ADDRESS;
6137 }
6138 else
6139 {
6140 m_resolved_indirect_addresses.insert(std::pair<addr_t, addr_t>(addr, function_addr));
6141 }
6142 }
6143 return function_addr;
6144}
6145
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00006146void
6147Process::ModulesDidLoad (ModuleList &module_list)
6148{
6149 SystemRuntime *sys_runtime = GetSystemRuntime();
6150 if (sys_runtime)
6151 {
6152 sys_runtime->ModulesDidLoad (module_list);
6153 }
6154
6155 GetJITLoaders().ModulesDidLoad (module_list);
6156}