blob: 730aefd8800081b0d8592fbfdffda73a4246ba79 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- MachProcess.cpp -----------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Created by Greg Clayton on 6/15/07.
11//
12//===----------------------------------------------------------------------===//
13
14#include "DNB.h"
15#include <mach/mach.h>
16#include <spawn.h>
17#include <sys/fcntl.h>
18#include <sys/types.h>
19#include <sys/ptrace.h>
20#include <sys/stat.h>
Greg Clayton71337622011-02-24 22:24:29 +000021#include <sys/sysctl.h>
Chris Lattner30fdc8d2010-06-08 16:52:24 +000022#include <unistd.h>
23#include "MacOSX/CFUtils.h"
24#include "SysSignal.h"
25
26#include <algorithm>
27#include <map>
28
29#include "DNBDataRef.h"
30#include "DNBLog.h"
31#include "DNBThreadResumeActions.h"
32#include "DNBTimer.h"
33#include "MachProcess.h"
34#include "PseudoTerminal.h"
35
36#include "CFBundle.h"
37#include "CFData.h"
38#include "CFString.h"
39
40static CFStringRef CopyBundleIDForPath (const char *app_buncle_path, DNBError &err_str);
41
42#if defined (__arm__)
43
44#include <CoreFoundation/CoreFoundation.h>
45#include <SpringBoardServices/SpringBoardServer.h>
46#include <SpringBoardServices/SBSWatchdogAssertion.h>
47
48
49static bool
50IsSBProcess (nub_process_t pid)
51{
52 bool opt_runningApps = true;
53 bool opt_debuggable = false;
54
55 CFReleaser<CFArrayRef> sbsAppIDs (::SBSCopyApplicationDisplayIdentifiers (opt_runningApps, opt_debuggable));
56 if (sbsAppIDs.get() != NULL)
57 {
58 CFIndex count = ::CFArrayGetCount (sbsAppIDs.get());
59 CFIndex i = 0;
60 for (i = 0; i < count; i++)
61 {
62 CFStringRef displayIdentifier = (CFStringRef)::CFArrayGetValueAtIndex (sbsAppIDs.get(), i);
63
64 // Get the process id for the app (if there is one)
65 pid_t sbs_pid = INVALID_NUB_PROCESS;
66 if (::SBSProcessIDForDisplayIdentifier ((CFStringRef)displayIdentifier, &sbs_pid) == TRUE)
67 {
68 if (sbs_pid == pid)
69 return true;
70 }
71 }
72 }
73 return false;
74}
75
76
77#endif
78
79#if 0
80#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
81#else
82#define DEBUG_LOG(fmt, ...)
83#endif
84
85#ifndef MACH_PROCESS_USE_POSIX_SPAWN
86#define MACH_PROCESS_USE_POSIX_SPAWN 1
87#endif
88
Greg Claytonf681b942010-08-31 18:35:14 +000089#ifndef _POSIX_SPAWN_DISABLE_ASLR
90#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
91#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +000092
93MachProcess::MachProcess() :
94 m_pid (0),
Greg Clayton71337622011-02-24 22:24:29 +000095 m_cpu_type (0),
Chris Lattner30fdc8d2010-06-08 16:52:24 +000096 m_child_stdin (-1),
97 m_child_stdout (-1),
98 m_child_stderr (-1),
99 m_path (),
100 m_args (),
101 m_task (this),
102 m_flags (eMachProcessFlagsNone),
103 m_stdio_thread (0),
104 m_stdio_mutex (PTHREAD_MUTEX_RECURSIVE),
105 m_stdout_data (),
Greg Claytonc4e411f2011-01-18 19:36:39 +0000106 m_thread_actions (),
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000107 m_thread_list (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000108 m_exception_messages (),
109 m_exception_messages_mutex (PTHREAD_MUTEX_RECURSIVE),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000110 m_state (eStateUnloaded),
111 m_state_mutex (PTHREAD_MUTEX_RECURSIVE),
112 m_events (0, kAllEventsMask),
113 m_breakpoints (),
114 m_watchpoints (),
115 m_name_to_addr_callback(NULL),
116 m_name_to_addr_baton(NULL),
117 m_image_infos_callback(NULL),
118 m_image_infos_baton(NULL)
119{
120 DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
121}
122
123MachProcess::~MachProcess()
124{
125 DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
126 Clear();
127}
128
129pid_t
130MachProcess::SetProcessID(pid_t pid)
131{
132 // Free any previous process specific data or resources
133 Clear();
134 // Set the current PID appropriately
135 if (pid == 0)
Johnny Chenc0cd18d2010-09-28 16:34:56 +0000136 m_pid = ::getpid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000137 else
138 m_pid = pid;
139 return m_pid; // Return actualy PID in case a zero pid was passed in
140}
141
142nub_state_t
143MachProcess::GetState()
144{
145 // If any other threads access this we will need a mutex for it
146 PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
147 return m_state;
148}
149
150const char *
151MachProcess::ThreadGetName(nub_thread_t tid)
152{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000153 return m_thread_list.GetName(tid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000154}
155
156nub_state_t
157MachProcess::ThreadGetState(nub_thread_t tid)
158{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000159 return m_thread_list.GetState(tid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000160}
161
162
163nub_size_t
164MachProcess::GetNumThreads () const
165{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000166 return m_thread_list.NumThreads();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000167}
168
169nub_thread_t
170MachProcess::GetThreadAtIndex (nub_size_t thread_idx) const
171{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000172 return m_thread_list.ThreadIDAtIndex(thread_idx);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000173}
174
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000175nub_thread_t
176MachProcess::GetCurrentThread ()
177{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000178 return m_thread_list.CurrentThreadID();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000179}
180
181nub_thread_t
182MachProcess::SetCurrentThread(nub_thread_t tid)
183{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000184 return m_thread_list.SetCurrentThread(tid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000185}
186
187bool
188MachProcess::GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info) const
189{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000190 return m_thread_list.GetThreadStoppedReason(tid, stop_info);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000191}
192
193void
194MachProcess::DumpThreadStoppedReason(nub_thread_t tid) const
195{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000196 return m_thread_list.DumpThreadStoppedReason(tid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000197}
198
199const char *
200MachProcess::GetThreadInfo(nub_thread_t tid) const
201{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000202 return m_thread_list.GetThreadInfo(tid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000203}
204
Greg Clayton71337622011-02-24 22:24:29 +0000205uint32_t
206MachProcess::GetCPUType ()
207{
208 if (m_cpu_type == 0 && m_pid != 0)
209 m_cpu_type = MachProcess::GetCPUTypeForLocalProcess (m_pid);
210 return m_cpu_type;
211}
212
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000213const DNBRegisterSetInfo *
Greg Claytone2d4f0d2011-01-19 07:54:15 +0000214MachProcess::GetRegisterSetInfo (nub_thread_t tid, nub_size_t *num_reg_sets) const
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000215{
Greg Claytone2d4f0d2011-01-19 07:54:15 +0000216 MachThreadSP thread_sp (m_thread_list.GetThreadByID (tid));
217 if (thread_sp)
Greg Clayton3af9ea52010-11-18 05:57:03 +0000218 {
Greg Claytone2d4f0d2011-01-19 07:54:15 +0000219 DNBArchProtocol *arch = thread_sp->GetArchProtocol();
Greg Clayton3af9ea52010-11-18 05:57:03 +0000220 if (arch)
221 return arch->GetRegisterSetInfo (num_reg_sets);
222 }
223 *num_reg_sets = 0;
224 return NULL;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000225}
226
227bool
228MachProcess::GetRegisterValue ( nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *value ) const
229{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000230 return m_thread_list.GetRegisterValue(tid, set, reg, value);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000231}
232
233bool
234MachProcess::SetRegisterValue ( nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value ) const
235{
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000236 return m_thread_list.SetRegisterValue(tid, set, reg, value);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000237}
238
239void
240MachProcess::SetState(nub_state_t new_state)
241{
242 // If any other threads access this we will need a mutex for it
243 uint32_t event_mask = 0;
244
245 // Scope for mutex locker
246 {
247 PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
248 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState ( %s )", DNBStateAsString(new_state));
249
250 const nub_state_t old_state = m_state;
251
252 if (old_state != new_state)
253 {
254 if (NUB_STATE_IS_STOPPED(new_state))
255 event_mask = eEventProcessStoppedStateChanged;
256 else
257 event_mask = eEventProcessRunningStateChanged;
258
259 m_state = new_state;
260 if (new_state == eStateStopped)
261 m_stop_count++;
262 }
263 }
264
265 if (event_mask != 0)
266 {
267 m_events.SetEvents (event_mask);
268
269 // Wait for the event bit to reset if a reset ACK is requested
270 m_events.WaitForResetAck(event_mask);
271 }
272
273}
274
275void
276MachProcess::Clear()
277{
278 // Clear any cached thread list while the pid and task are still valid
279
280 m_task.Clear();
281 // Now clear out all member variables
282 m_pid = INVALID_NUB_PROCESS;
283 CloseChildFileDescriptors();
284 m_path.clear();
285 m_args.clear();
286 SetState(eStateUnloaded);
287 m_flags = eMachProcessFlagsNone;
288 m_stop_count = 0;
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000289 m_thread_list.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000290 {
291 PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
292 m_exception_messages.clear();
293 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000294}
295
296
297bool
298MachProcess::StartSTDIOThread()
299{
300 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
301 // Create the thread that watches for the child STDIO
Greg Clayton3382c2c2010-07-30 23:14:42 +0000302 return ::pthread_create (&m_stdio_thread, NULL, MachProcess::STDIOThread, this) == 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000303}
304
305
306nub_addr_t
307MachProcess::LookupSymbol(const char *name, const char *shlib)
308{
309 if (m_name_to_addr_callback != NULL && name && name[0])
310 return m_name_to_addr_callback(ProcessID(), name, shlib, m_name_to_addr_baton);
311 return INVALID_NUB_ADDRESS;
312}
313
314bool
315MachProcess::Resume (const DNBThreadResumeActions& thread_actions)
316{
317 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Resume ()");
318 nub_state_t state = GetState();
319
320 if (CanResume(state))
321 {
Greg Claytonc4e411f2011-01-18 19:36:39 +0000322 m_thread_actions = thread_actions;
323 PrivateResume();
Greg Clayton3382c2c2010-07-30 23:14:42 +0000324 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000325 }
326 else if (state == eStateRunning)
327 {
328 DNBLogThreadedIf(LOG_PROCESS, "Resume() - task 0x%x is running, ignoring...", m_task.TaskPort());
Greg Clayton3382c2c2010-07-30 23:14:42 +0000329 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000330 }
Greg Clayton3382c2c2010-07-30 23:14:42 +0000331 DNBLogThreadedIf(LOG_PROCESS, "Resume() - task 0x%x can't continue, ignoring...", m_task.TaskPort());
332 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000333}
334
335bool
336MachProcess::Kill (const struct timespec *timeout_abstime)
337{
338 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill ()");
339 nub_state_t state = DoSIGSTOP(true);
340 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() state = %s", DNBStateAsString(state));
341 errno = 0;
342 ::ptrace (PT_KILL, m_pid, 0, 0);
Greg Clayton3382c2c2010-07-30 23:14:42 +0000343 DNBError err;
344 err.SetErrorToErrno();
345 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() ::ptrace (PT_KILL, pid=%u, 0, 0) => 0x%8.8x (%s)", err.Error(), err.AsString());
Greg Claytonc4e411f2011-01-18 19:36:39 +0000346 m_thread_actions = DNBThreadResumeActions (eStateRunning, 0);
347 PrivateResume ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000348 return true;
349}
350
351bool
352MachProcess::Signal (int signal, const struct timespec *timeout_abstime)
353{
354 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p)", signal, timeout_abstime);
355 nub_state_t state = GetState();
356 if (::kill (ProcessID(), signal) == 0)
357 {
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000358 // If we were running and we have a timeout, wait for the signal to stop
359 if (IsRunning(state) && timeout_abstime)
360 {
361 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) waiting for signal to stop process...", signal, timeout_abstime);
362 m_events.WaitForSetEvents(eEventProcessStoppedStateChanged, timeout_abstime);
363 state = GetState();
364 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal, timeout_abstime, DNBStateAsString(state));
365 return !IsRunning (state);
366 }
367 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) not waiting...", signal, timeout_abstime);
Greg Clayton3382c2c2010-07-30 23:14:42 +0000368 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000369 }
Greg Clayton3382c2c2010-07-30 23:14:42 +0000370 DNBError err(errno, DNBError::POSIX);
371 err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal);
372 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000373
374}
375
376nub_state_t
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000377MachProcess::DoSIGSTOP (bool clear_bps_and_wps, uint32_t *thread_idx_ptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000378{
379 nub_state_t state = GetState();
380 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s", DNBStateAsString (state));
381
382 if (!IsRunning(state))
383 {
384 if (clear_bps_and_wps)
385 {
386 DisableAllBreakpoints (true);
387 DisableAllWatchpoints (true);
388 clear_bps_and_wps = false;
389 }
390
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000391 // If we already have a thread stopped due to a SIGSTOP, we don't have
392 // to do anything...
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000393 uint32_t thread_idx = m_thread_list.GetThreadIndexForThreadStoppedWithSignal (SIGSTOP);
394 if (thread_idx_ptr)
395 *thread_idx_ptr = thread_idx;
396 if (thread_idx != UINT32_MAX)
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000397 return GetState();
398
399 // No threads were stopped with a SIGSTOP, we need to run and halt the
400 // process with a signal
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000401 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s -- resuming process", DNBStateAsString (state));
Greg Claytonc4e411f2011-01-18 19:36:39 +0000402 m_thread_actions = DNBThreadResumeActions (eStateRunning, 0);
403 PrivateResume ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000404
405 // Reset the event that says we were indeed running
406 m_events.ResetEvents(eEventProcessRunningStateChanged);
407 state = GetState();
408 }
409
410 // We need to be stopped in order to be able to detach, so we need
411 // to send ourselves a SIGSTOP
412
413 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s -- sending SIGSTOP", DNBStateAsString (state));
414 struct timespec sigstop_timeout;
415 DNBTimer::OffsetTimeOfDay(&sigstop_timeout, 2, 0);
416 Signal (SIGSTOP, &sigstop_timeout);
417 if (clear_bps_and_wps)
418 {
419 DisableAllBreakpoints (true);
420 DisableAllWatchpoints (true);
Johnny Chen2fe7dd42011-08-10 23:01:39 +0000421 // Silence static analyzer.
422 // clear_bps_and_wps = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000423 }
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000424 uint32_t thread_idx = m_thread_list.GetThreadIndexForThreadStoppedWithSignal (SIGSTOP);
425 if (thread_idx_ptr)
426 *thread_idx_ptr = thread_idx;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000427 return GetState();
428}
429
430bool
431MachProcess::Detach()
432{
433 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach()");
434
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000435 uint32_t thread_idx = UINT32_MAX;
436 nub_state_t state = DoSIGSTOP(true, &thread_idx);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000437 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach() DoSIGSTOP() returned %s", DNBStateAsString(state));
438
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000439 {
Greg Claytonc4e411f2011-01-18 19:36:39 +0000440 m_thread_actions.Clear();
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000441 DNBThreadResumeAction thread_action;
442 thread_action.tid = m_thread_list.ThreadIDAtIndex (thread_idx);
443 thread_action.state = eStateRunning;
444 thread_action.signal = -1;
445 thread_action.addr = INVALID_NUB_ADDRESS;
446
Greg Claytonc4e411f2011-01-18 19:36:39 +0000447 m_thread_actions.Append (thread_action);
448 m_thread_actions.SetDefaultThreadActionIfNeeded (eStateRunning, 0);
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000449
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000450 PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000451
Greg Claytonc4e411f2011-01-18 19:36:39 +0000452 ReplyToAllExceptions ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000453
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000454 }
455
456 m_task.ShutDownExcecptionThread();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000457
458 // Detach from our process
459 errno = 0;
460 nub_process_t pid = m_pid;
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000461 int ret = ::ptrace (PT_DETACH, pid, (caddr_t)1, 0);
Greg Clayton3382c2c2010-07-30 23:14:42 +0000462 DNBError err(errno, DNBError::POSIX);
Caroline Tice5d7be2e2010-11-02 16:16:53 +0000463 if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
Greg Clayton3382c2c2010-07-30 23:14:42 +0000464 err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000465
466 // Resume our task
467 m_task.Resume();
468
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000469 // NULL our task out as we have already retored all exception ports
470 m_task.Clear();
471
472 // Clear out any notion of the process we once were
473 Clear();
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000474
475 SetState(eStateDetached);
476
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000477 return true;
478}
479
480
481nub_size_t
482MachProcess::RemoveTrapsFromBuffer (nub_addr_t addr, nub_size_t size, uint8_t *buf) const
483{
484 nub_size_t bytes_removed = 0;
485 const DNBBreakpoint *bp;
486 nub_addr_t intersect_addr;
487 nub_size_t intersect_size;
488 nub_size_t opcode_offset;
489 nub_size_t idx;
490 for (idx = 0; (bp = m_breakpoints.GetByIndex(idx)) != NULL; ++idx)
491 {
492 if (bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset))
493 {
494 assert(addr <= intersect_addr && intersect_addr < addr + size);
495 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
496 assert(opcode_offset + intersect_size <= bp->ByteSize());
497 nub_size_t buf_offset = intersect_addr - addr;
498 ::memcpy(buf + buf_offset, bp->SavedOpcodeBytes() + opcode_offset, intersect_size);
499 }
500 }
501 return bytes_removed;
502}
503
504//----------------------------------------------------------------------
505// ReadMemory from the MachProcess level will always remove any software
506// breakpoints from the memory buffer before returning. If you wish to
507// read memory and see those traps, read from the MachTask
508// (m_task.ReadMemory()) as that version will give you what is actually
509// in inferior memory.
510//----------------------------------------------------------------------
511nub_size_t
512MachProcess::ReadMemory (nub_addr_t addr, nub_size_t size, void *buf)
513{
514 // We need to remove any current software traps (enabled software
515 // breakpoints) that we may have placed in our tasks memory.
516
517 // First just read the memory as is
518 nub_size_t bytes_read = m_task.ReadMemory(addr, size, buf);
519
520 // Then place any opcodes that fall into this range back into the buffer
521 // before we return this to callers.
522 if (bytes_read > 0)
523 RemoveTrapsFromBuffer (addr, size, (uint8_t *)buf);
524 return bytes_read;
525}
526
527//----------------------------------------------------------------------
528// WriteMemory from the MachProcess level will always write memory around
529// any software breakpoints. Any software breakpoints will have their
530// opcodes modified if they are enabled. Any memory that doesn't overlap
531// with software breakpoints will be written to. If you wish to write to
532// inferior memory without this interference, then write to the MachTask
533// (m_task.WriteMemory()) as that version will always modify inferior
534// memory.
535//----------------------------------------------------------------------
536nub_size_t
537MachProcess::WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf)
538{
539 // We need to write any data that would go where any current software traps
540 // (enabled software breakpoints) any software traps (breakpoints) that we
541 // may have placed in our tasks memory.
542
543 std::map<nub_addr_t, DNBBreakpoint *> addr_to_bp_map;
544 DNBBreakpoint *bp;
545 nub_size_t idx;
546 for (idx = 0; (bp = m_breakpoints.GetByIndex(idx)) != NULL; ++idx)
547 {
548 if (bp->IntersectsRange(addr, size, NULL, NULL, NULL))
549 addr_to_bp_map[bp->Address()] = bp;
550 }
551
552 // If we don't have any software breakpoints that are in this buffer, then
553 // we can just write memory and be done with it.
554 if (addr_to_bp_map.empty())
555 return m_task.WriteMemory(addr, size, buf);
556
557 // If we make it here, we have some breakpoints that overlap and we need
558 // to work around them.
559
560 nub_size_t bytes_written = 0;
561 nub_addr_t intersect_addr;
562 nub_size_t intersect_size;
563 nub_size_t opcode_offset;
564 const uint8_t *ubuf = (const uint8_t *)buf;
565 std::map<nub_addr_t, DNBBreakpoint *>::iterator pos, end = addr_to_bp_map.end();
566 for (pos = addr_to_bp_map.begin(); pos != end; ++pos)
567 {
568 bp = pos->second;
569
570 assert(bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset));
571 assert(addr <= intersect_addr && intersect_addr < addr + size);
572 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
573 assert(opcode_offset + intersect_size <= bp->ByteSize());
574
575 // Check for bytes before this breakpoint
576 const nub_addr_t curr_addr = addr + bytes_written;
577 if (intersect_addr > curr_addr)
578 {
579 // There are some bytes before this breakpoint that we need to
580 // just write to memory
581 nub_size_t curr_size = intersect_addr - curr_addr;
582 nub_size_t curr_bytes_written = m_task.WriteMemory(curr_addr, curr_size, ubuf + bytes_written);
583 bytes_written += curr_bytes_written;
584 if (curr_bytes_written != curr_size)
585 {
586 // We weren't able to write all of the requested bytes, we
587 // are done looping and will return the number of bytes that
588 // we have written so far.
589 break;
590 }
591 }
592
593 // Now write any bytes that would cover up any software breakpoints
594 // directly into the breakpoint opcode buffer
595 ::memcpy(bp->SavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
596 bytes_written += intersect_size;
597 }
598
599 // Write any remaining bytes after the last breakpoint if we have any left
600 if (bytes_written < size)
601 bytes_written += m_task.WriteMemory(addr + bytes_written, size - bytes_written, ubuf + bytes_written);
602
603 return bytes_written;
604}
605
606
607void
Greg Claytonc4e411f2011-01-18 19:36:39 +0000608MachProcess::ReplyToAllExceptions ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000609{
610 PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
611 if (m_exception_messages.empty() == false)
612 {
613 MachException::Message::iterator pos;
614 MachException::Message::iterator begin = m_exception_messages.begin();
615 MachException::Message::iterator end = m_exception_messages.end();
616 for (pos = begin; pos != end; ++pos)
617 {
618 DNBLogThreadedIf(LOG_EXCEPTIONS, "Replying to exception %d...", std::distance(begin, pos));
619 int thread_reply_signal = 0;
620
Greg Claytonc4e411f2011-01-18 19:36:39 +0000621 const DNBThreadResumeAction *action = m_thread_actions.GetActionForThread (pos->state.thread_port, false);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000622
623 if (action)
624 {
625 thread_reply_signal = action->signal;
626 if (thread_reply_signal)
Greg Claytonc4e411f2011-01-18 19:36:39 +0000627 m_thread_actions.SetSignalHandledForThread (pos->state.thread_port);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000628 }
629
Greg Clayton3382c2c2010-07-30 23:14:42 +0000630 DNBError err (pos->Reply(this, thread_reply_signal));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000631 if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
Greg Clayton3382c2c2010-07-30 23:14:42 +0000632 err.LogThreadedIfError("Error replying to exception");
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000633 }
634
635 // Erase all exception message as we should have used and replied
636 // to them all already.
637 m_exception_messages.clear();
638 }
639}
640void
Greg Claytonc4e411f2011-01-18 19:36:39 +0000641MachProcess::PrivateResume ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000642{
643 PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex);
644
Greg Claytonc4e411f2011-01-18 19:36:39 +0000645 ReplyToAllExceptions ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000646// bool stepOverBreakInstruction = step;
647
648 // Let the thread prepare to resume and see if any threads want us to
649 // step over a breakpoint instruction (ProcessWillResume will modify
650 // the value of stepOverBreakInstruction).
Greg Claytonc4e411f2011-01-18 19:36:39 +0000651 m_thread_list.ProcessWillResume (this, m_thread_actions);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000652
653 // Set our state accordingly
Greg Claytonc4e411f2011-01-18 19:36:39 +0000654 if (m_thread_actions.NumActionsWithState(eStateStepping))
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000655 SetState (eStateStepping);
656 else
657 SetState (eStateRunning);
658
659 // Now resume our task.
Greg Clayton3382c2c2010-07-30 23:14:42 +0000660 m_task.Resume();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000661}
662
663nub_break_t
664MachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length, bool hardware, thread_t tid)
665{
666 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = 0x%8.8llx, length = %u, hardware = %i, tid = 0x%4.4x )", (uint64_t)addr, length, hardware, tid);
667 if (hardware && tid == INVALID_NUB_THREAD)
668 tid = GetCurrentThread();
669
670 DNBBreakpoint bp(addr, length, tid, hardware);
671 nub_break_t breakID = m_breakpoints.Add(bp);
672 if (EnableBreakpoint(breakID))
673 {
674 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = 0x%8.8llx, length = %u, tid = 0x%4.4x ) => %u", (uint64_t)addr, length, tid, breakID);
675 return breakID;
676 }
677 else
678 {
679 m_breakpoints.Remove(breakID);
680 }
681 // We failed to enable the breakpoint
682 return INVALID_NUB_BREAK_ID;
683}
684
685nub_watch_t
686MachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length, uint32_t watch_flags, bool hardware, thread_t tid)
687{
688 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %u, flags = 0x%8.8x, hardware = %i, tid = 0x%4.4x )", (uint64_t)addr, length, watch_flags, hardware, tid);
689 if (hardware && tid == INVALID_NUB_THREAD)
690 tid = GetCurrentThread();
691
692 DNBBreakpoint watch(addr, length, tid, hardware);
693 watch.SetIsWatchpoint(watch_flags);
694
695 nub_watch_t watchID = m_watchpoints.Add(watch);
696 if (EnableWatchpoint(watchID))
697 {
698 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %u, tid = 0x%x) => %u", (uint64_t)addr, length, tid, watchID);
699 return watchID;
700 }
701 else
702 {
703 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %u, tid = 0x%x) => FAILED (%u)", (uint64_t)addr, length, tid, watchID);
704 m_watchpoints.Remove(watchID);
705 }
706 // We failed to enable the watchpoint
707 return INVALID_NUB_BREAK_ID;
708}
709
710nub_size_t
711MachProcess::DisableAllBreakpoints(bool remove)
712{
713 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::%s (remove = %d )", __FUNCTION__, remove);
714 DNBBreakpoint *bp;
715 nub_size_t disabled_count = 0;
716 nub_size_t idx = 0;
717 while ((bp = m_breakpoints.GetByIndex(idx)) != NULL)
718 {
719 bool success = DisableBreakpoint(bp->GetID(), remove);
720
721 if (success)
722 disabled_count++;
723 // If we failed to disable the breakpoint or we aren't removing the breakpoint
724 // increment the breakpoint index. Otherwise DisableBreakpoint will have removed
725 // the breakpoint at this index and we don't need to change it.
726 if ((success == false) || (remove == false))
727 idx++;
728 }
729 return disabled_count;
730}
731
732nub_size_t
733MachProcess::DisableAllWatchpoints(bool remove)
734{
735 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s (remove = %d )", __FUNCTION__, remove);
736 DNBBreakpoint *wp;
737 nub_size_t disabled_count = 0;
738 nub_size_t idx = 0;
739 while ((wp = m_watchpoints.GetByIndex(idx)) != NULL)
740 {
741 bool success = DisableWatchpoint(wp->GetID(), remove);
742
743 if (success)
744 disabled_count++;
745 // If we failed to disable the watchpoint or we aren't removing the watchpoint
746 // increment the watchpoint index. Otherwise DisableWatchpoint will have removed
747 // the watchpoint at this index and we don't need to change it.
748 if ((success == false) || (remove == false))
749 idx++;
750 }
751 return disabled_count;
752}
753
754bool
755MachProcess::DisableBreakpoint(nub_break_t breakID, bool remove)
756{
757 DNBBreakpoint *bp = m_breakpoints.FindByID (breakID);
758 if (bp)
759 {
760 nub_addr_t addr = bp->Address();
761 DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE, "MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx", breakID, remove, (uint64_t)addr);
762
763 if (bp->IsHardware())
764 {
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000765 bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint (bp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000766
767 if (hw_disable_result == true)
768 {
769 bp->SetEnabled(false);
770 // Let the thread list know that a breakpoint has been modified
771 if (remove)
772 {
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000773 m_thread_list.NotifyBreakpointChanged(bp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000774 m_breakpoints.Remove(breakID);
775 }
776 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx (hardware) => success", breakID, remove, (uint64_t)addr);
777 return true;
778 }
779
780 return false;
781 }
782
783 const nub_size_t break_op_size = bp->ByteSize();
784 assert (break_op_size > 0);
Greg Clayton3af9ea52010-11-18 05:57:03 +0000785 const uint8_t * const break_op = DNBArchProtocol::GetBreakpointOpcode (bp->ByteSize());
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000786 if (break_op_size > 0)
787 {
788 // Clear a software breakoint instruction
789 uint8_t curr_break_op[break_op_size];
790 bool break_op_found = false;
791
792 // Read the breakpoint opcode
793 if (m_task.ReadMemory(addr, break_op_size, curr_break_op) == break_op_size)
794 {
795 bool verify = false;
796 if (bp->IsEnabled())
797 {
798 // Make sure we have the a breakpoint opcode exists at this address
799 if (memcmp(curr_break_op, break_op, break_op_size) == 0)
800 {
801 break_op_found = true;
802 // We found a valid breakpoint opcode at this address, now restore
803 // the saved opcode.
804 if (m_task.WriteMemory(addr, break_op_size, bp->SavedOpcodeBytes()) == break_op_size)
805 {
806 verify = true;
807 }
808 else
809 {
810 DNBLogError("MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx memory write failed when restoring original opcode", breakID, remove, (uint64_t)addr);
811 }
812 }
813 else
814 {
815 DNBLogWarning("MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx expected a breakpoint opcode but didn't find one.", breakID, remove, (uint64_t)addr);
816 // Set verify to true and so we can check if the original opcode has already been restored
817 verify = true;
818 }
819 }
820 else
821 {
822 DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE, "MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x$8.8llx is not enabled", breakID, remove, (uint64_t)addr);
823 // Set verify to true and so we can check if the original opcode is there
824 verify = true;
825 }
826
827 if (verify)
828 {
829 uint8_t verify_opcode[break_op_size];
830 // Verify that our original opcode made it back to the inferior
831 if (m_task.ReadMemory(addr, break_op_size, verify_opcode) == break_op_size)
832 {
833 // compare the memory we just read with the original opcode
834 if (memcmp(bp->SavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
835 {
836 // SUCCESS
837 bp->SetEnabled(false);
838 // Let the thread list know that a breakpoint has been modified
839 if (remove)
840 {
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000841 m_thread_list.NotifyBreakpointChanged(bp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000842 m_breakpoints.Remove(breakID);
843 }
844 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx => success", breakID, remove, (uint64_t)addr);
845 return true;
846 }
847 else
848 {
849 if (break_op_found)
850 DNBLogError("MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx: failed to restore original opcode", breakID, remove, (uint64_t)addr);
851 else
852 DNBLogError("MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) addr = 0x%8.8llx: opcode changed", breakID, remove, (uint64_t)addr);
853 }
854 }
855 else
856 {
857 DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable breakpoint 0x%8.8llx", (uint64_t)addr);
858 }
859 }
860 }
861 else
862 {
863 DNBLogWarning("MachProcess::DisableBreakpoint: unable to read memory at 0x%8.8llx", (uint64_t)addr);
864 }
865 }
866 }
867 else
868 {
869 DNBLogError("MachProcess::DisableBreakpoint ( breakID = %d, remove = %d ) invalid breakpoint ID", breakID, remove);
870 }
871 return false;
872}
873
874bool
875MachProcess::DisableWatchpoint(nub_watch_t watchID, bool remove)
876{
877 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s(watchID = %d, remove = %d)", __FUNCTION__, watchID, remove);
878 DNBBreakpoint *wp = m_watchpoints.FindByID (watchID);
879 if (wp)
880 {
881 nub_addr_t addr = wp->Address();
882 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::DisableWatchpoint ( watchID = %d, remove = %d ) addr = 0x%8.8llx", watchID, remove, (uint64_t)addr);
883
884 if (wp->IsHardware())
885 {
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000886 bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint (wp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000887
888 if (hw_disable_result == true)
889 {
890 wp->SetEnabled(false);
891 if (remove)
892 m_watchpoints.Remove(watchID);
893 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::Disablewatchpoint ( watchID = %d, remove = %d ) addr = 0x%8.8llx (hardware) => success", watchID, remove, (uint64_t)addr);
894 return true;
895 }
896 }
897
898 // TODO: clear software watchpoints if we implement them
899 }
900 else
901 {
902 DNBLogError("MachProcess::DisableWatchpoint ( watchID = %d, remove = %d ) invalid watchpoint ID", watchID, remove);
903 }
904 return false;
905}
906
907
908void
909MachProcess::DumpBreakpoint(nub_break_t breakID) const
910{
911 DNBLogThreaded("MachProcess::DumpBreakpoint(breakID = %d)", breakID);
912
913 if (NUB_BREAK_ID_IS_VALID(breakID))
914 {
915 const DNBBreakpoint *bp = m_breakpoints.FindByID(breakID);
916 if (bp)
917 bp->Dump();
918 else
919 DNBLog("MachProcess::DumpBreakpoint(breakID = %d): invalid breakID", breakID);
920 }
921 else
922 {
923 m_breakpoints.Dump();
924 }
925}
926
927void
928MachProcess::DumpWatchpoint(nub_watch_t watchID) const
929{
930 DNBLogThreaded("MachProcess::DumpWatchpoint(watchID = %d)", watchID);
931
932 if (NUB_BREAK_ID_IS_VALID(watchID))
933 {
934 const DNBBreakpoint *wp = m_watchpoints.FindByID(watchID);
935 if (wp)
936 wp->Dump();
937 else
938 DNBLog("MachProcess::DumpWatchpoint(watchID = %d): invalid watchID", watchID);
939 }
940 else
941 {
942 m_watchpoints.Dump();
943 }
944}
945
946bool
947MachProcess::EnableBreakpoint(nub_break_t breakID)
948{
949 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::EnableBreakpoint ( breakID = %d )", breakID);
950 DNBBreakpoint *bp = m_breakpoints.FindByID (breakID);
951 if (bp)
952 {
953 nub_addr_t addr = bp->Address();
954 if (bp->IsEnabled())
955 {
956 DNBLogWarning("MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: breakpoint already enabled.", breakID, (uint64_t)addr);
957 return true;
958 }
959 else
960 {
961 if (bp->HardwarePreferred())
962 {
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000963 bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000964 if (bp->IsHardware())
965 {
966 bp->SetEnabled(true);
967 return true;
968 }
969 }
970
971 const nub_size_t break_op_size = bp->ByteSize();
972 assert (break_op_size != 0);
Greg Clayton3af9ea52010-11-18 05:57:03 +0000973 const uint8_t * const break_op = DNBArchProtocol::GetBreakpointOpcode (break_op_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000974 if (break_op_size > 0)
975 {
976 // Save the original opcode by reading it
977 if (m_task.ReadMemory(addr, break_op_size, bp->SavedOpcodeBytes()) == break_op_size)
978 {
979 // Write a software breakpoint in place of the original opcode
980 if (m_task.WriteMemory(addr, break_op_size, break_op) == break_op_size)
981 {
982 uint8_t verify_break_op[4];
983 if (m_task.ReadMemory(addr, break_op_size, verify_break_op) == break_op_size)
984 {
985 if (memcmp(break_op, verify_break_op, break_op_size) == 0)
986 {
987 bp->SetEnabled(true);
988 // Let the thread list know that a breakpoint has been modified
Greg Clayton58d1c9a2010-10-18 04:14:23 +0000989 m_thread_list.NotifyBreakpointChanged(bp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000990 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: SUCCESS.", breakID, (uint64_t)addr);
991 return true;
992 }
993 else
994 {
995 DNBLogError("MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: breakpoint opcode verification failed.", breakID, (uint64_t)addr);
996 }
997 }
998 else
999 {
1000 DNBLogError("MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: unable to read memory to verify breakpoint opcode.", breakID, (uint64_t)addr);
1001 }
1002 }
1003 else
1004 {
1005 DNBLogError("MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: unable to write breakpoint opcode to memory.", breakID, (uint64_t)addr);
1006 }
1007 }
1008 else
1009 {
1010 DNBLogError("MachProcess::EnableBreakpoint ( breakID = %d ) addr = 0x%8.8llx: unable to read memory at breakpoint address.", breakID, (uint64_t)addr);
1011 }
1012 }
1013 else
1014 {
1015 DNBLogError("MachProcess::EnableBreakpoint ( breakID = %d ) no software breakpoint opcode for current architecture.", breakID);
1016 }
1017 }
1018 }
1019 return false;
1020}
1021
1022bool
1023MachProcess::EnableWatchpoint(nub_watch_t watchID)
1024{
1025 DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::EnableWatchpoint(watchID = %d)", watchID);
1026 DNBBreakpoint *wp = m_watchpoints.FindByID (watchID);
1027 if (wp)
1028 {
1029 nub_addr_t addr = wp->Address();
1030 if (wp->IsEnabled())
1031 {
1032 DNBLogWarning("MachProcess::EnableWatchpoint(watchID = %d) addr = 0x%8.8llx: watchpoint already enabled.", watchID, (uint64_t)addr);
1033 return true;
1034 }
1035 else
1036 {
1037 // Currently only try and set hardware watchpoints.
Greg Clayton58d1c9a2010-10-18 04:14:23 +00001038 wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001039 if (wp->IsHardware())
1040 {
1041 wp->SetEnabled(true);
1042 return true;
1043 }
1044 // TODO: Add software watchpoints by doing page protection tricks.
1045 }
1046 }
1047 return false;
1048}
1049
1050// Called by the exception thread when an exception has been received from
1051// our process. The exception message is completely filled and the exception
1052// data has already been copied.
1053void
1054MachProcess::ExceptionMessageReceived (const MachException::Message& exceptionMessage)
1055{
1056 PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex);
1057
1058 if (m_exception_messages.empty())
1059 m_task.Suspend();
1060
1061 DNBLogThreadedIf(LOG_EXCEPTIONS, "MachProcess::ExceptionMessageReceived ( )");
1062
1063 // Use a locker to automatically unlock our mutex in case of exceptions
1064 // Add the exception to our internal exception stack
1065 m_exception_messages.push_back(exceptionMessage);
1066}
1067
1068void
1069MachProcess::ExceptionMessageBundleComplete()
1070{
1071 // We have a complete bundle of exceptions for our child process.
1072 PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex);
1073 DNBLogThreadedIf(LOG_EXCEPTIONS, "%s: %d exception messages.", __PRETTY_FUNCTION__, m_exception_messages.size());
1074 if (!m_exception_messages.empty())
1075 {
1076 // Let all threads recover from stopping and do any clean up based
1077 // on the previous thread state (if any).
Greg Clayton58d1c9a2010-10-18 04:14:23 +00001078 m_thread_list.ProcessDidStop(this);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001079
1080 // Let each thread know of any exceptions
1081 task_t task = m_task.TaskPort();
1082 size_t i;
1083 for (i=0; i<m_exception_messages.size(); ++i)
1084 {
1085 // Let the thread list figure use the MachProcess to forward all exceptions
1086 // on down to each thread.
1087 if (m_exception_messages[i].state.task_port == task)
Greg Clayton58d1c9a2010-10-18 04:14:23 +00001088 m_thread_list.NotifyException(m_exception_messages[i].state);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001089 if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
1090 m_exception_messages[i].Dump();
1091 }
1092
1093 if (DNBLogCheckLogBit(LOG_THREAD))
Greg Clayton58d1c9a2010-10-18 04:14:23 +00001094 m_thread_list.Dump();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001095
1096 bool step_more = false;
Greg Clayton58d1c9a2010-10-18 04:14:23 +00001097 if (m_thread_list.ShouldStop(step_more))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001098 {
1099 // Wait for the eEventProcessRunningStateChanged event to be reset
1100 // before changing state to stopped to avoid race condition with
1101 // very fast start/stops
1102 struct timespec timeout;
1103 //DNBTimer::OffsetTimeOfDay(&timeout, 0, 250 * 1000); // Wait for 250 ms
1104 DNBTimer::OffsetTimeOfDay(&timeout, 1, 0); // Wait for 250 ms
1105 m_events.WaitForEventsToReset(eEventProcessRunningStateChanged, &timeout);
1106 SetState(eStateStopped);
1107 }
1108 else
1109 {
1110 // Resume without checking our current state.
Greg Claytonc4e411f2011-01-18 19:36:39 +00001111 PrivateResume ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001112 }
1113 }
1114 else
1115 {
1116 DNBLogThreadedIf(LOG_EXCEPTIONS, "%s empty exception messages bundle.", __PRETTY_FUNCTION__, m_exception_messages.size());
1117 }
1118}
1119
1120nub_size_t
1121MachProcess::CopyImageInfos ( struct DNBExecutableImageInfo **image_infos, bool only_changed)
1122{
1123 if (m_image_infos_callback != NULL)
1124 return m_image_infos_callback(ProcessID(), image_infos, only_changed, m_image_infos_baton);
1125 return 0;
1126}
1127
1128void
1129MachProcess::SharedLibrariesUpdated ( )
1130{
1131 uint32_t event_bits = eEventSharedLibsStateChange;
1132 // Set the shared library event bit to let clients know of shared library
1133 // changes
1134 m_events.SetEvents(event_bits);
1135 // Wait for the event bit to reset if a reset ACK is requested
1136 m_events.WaitForResetAck(event_bits);
1137}
1138
1139void
1140MachProcess::AppendSTDOUT (char* s, size_t len)
1141{
1142 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (<%d> %s) ...", __FUNCTION__, len, s);
1143 PTHREAD_MUTEX_LOCKER (locker, m_stdio_mutex);
1144 m_stdout_data.append(s, len);
1145 m_events.SetEvents(eEventStdioAvailable);
1146
1147 // Wait for the event bit to reset if a reset ACK is requested
1148 m_events.WaitForResetAck(eEventStdioAvailable);
1149}
1150
1151size_t
1152MachProcess::GetAvailableSTDOUT (char *buf, size_t buf_size)
1153{
1154 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%u]) ...", __FUNCTION__, buf, buf_size);
1155 PTHREAD_MUTEX_LOCKER (locker, m_stdio_mutex);
1156 size_t bytes_available = m_stdout_data.size();
1157 if (bytes_available > 0)
1158 {
1159 if (bytes_available > buf_size)
1160 {
1161 memcpy(buf, m_stdout_data.data(), buf_size);
1162 m_stdout_data.erase(0, buf_size);
1163 bytes_available = buf_size;
1164 }
1165 else
1166 {
1167 memcpy(buf, m_stdout_data.data(), bytes_available);
1168 m_stdout_data.clear();
1169 }
1170 }
1171 return bytes_available;
1172}
1173
1174nub_addr_t
1175MachProcess::GetDYLDAllImageInfosAddress ()
1176{
Greg Clayton3382c2c2010-07-30 23:14:42 +00001177 DNBError err;
1178 return m_task.GetDYLDAllImageInfosAddress(err);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001179}
1180
1181size_t
1182MachProcess::GetAvailableSTDERR (char *buf, size_t buf_size)
1183{
1184 return 0;
1185}
1186
1187void *
1188MachProcess::STDIOThread(void *arg)
1189{
1190 MachProcess *proc = (MachProcess*) arg;
1191 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( arg = %p ) thread starting...", __FUNCTION__, arg);
1192
1193 // We start use a base and more options so we can control if we
1194 // are currently using a timeout on the mach_msg. We do this to get a
1195 // bunch of related exceptions on our exception port so we can process
1196 // then together. When we have multiple threads, we can get an exception
1197 // per thread and they will come in consecutively. The main thread loop
1198 // will start by calling mach_msg to without having the MACH_RCV_TIMEOUT
1199 // flag set in the options, so we will wait forever for an exception on
1200 // our exception port. After we get one exception, we then will use the
1201 // MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
1202 // exceptions for our process. After we have received the last pending
1203 // exception, we will get a timeout which enables us to then notify
1204 // our main thread that we have an exception bundle avaiable. We then wait
1205 // for the main thread to tell this exception thread to start trying to get
1206 // exceptions messages again and we start again with a mach_msg read with
1207 // infinite timeout.
1208 DNBError err;
1209 int stdout_fd = proc->GetStdoutFileDescriptor();
1210 int stderr_fd = proc->GetStderrFileDescriptor();
1211 if (stdout_fd == stderr_fd)
1212 stderr_fd = -1;
1213
1214 while (stdout_fd >= 0 || stderr_fd >= 0)
1215 {
1216 ::pthread_testcancel ();
1217
1218 fd_set read_fds;
1219 FD_ZERO (&read_fds);
1220 if (stdout_fd >= 0)
1221 FD_SET (stdout_fd, &read_fds);
1222 if (stderr_fd >= 0)
1223 FD_SET (stderr_fd, &read_fds);
1224 int nfds = std::max<int>(stdout_fd, stderr_fd) + 1;
1225
1226 int num_set_fds = select (nfds, &read_fds, NULL, NULL, NULL);
1227 DNBLogThreadedIf(LOG_PROCESS, "select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds);
1228
1229 if (num_set_fds < 0)
1230 {
1231 int select_errno = errno;
1232 if (DNBLogCheckLogBit(LOG_PROCESS))
1233 {
1234 err.SetError (select_errno, DNBError::POSIX);
1235 err.LogThreadedIfError("select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds);
1236 }
1237
1238 switch (select_errno)
1239 {
1240 case EAGAIN: // The kernel was (perhaps temporarily) unable to allocate the requested number of file descriptors, or we have non-blocking IO
1241 break;
1242 case EBADF: // One of the descriptor sets specified an invalid descriptor.
1243 return NULL;
1244 break;
1245 case EINTR: // A signal was delivered before the time limit expired and before any of the selected events occurred.
1246 case EINVAL: // The specified time limit is invalid. One of its components is negative or too large.
1247 default: // Other unknown error
1248 break;
1249 }
1250 }
1251 else if (num_set_fds == 0)
1252 {
1253 }
1254 else
1255 {
1256 char s[1024];
1257 s[sizeof(s)-1] = '\0'; // Ensure we have NULL termination
1258 int bytes_read = 0;
1259 if (stdout_fd >= 0 && FD_ISSET (stdout_fd, &read_fds))
1260 {
1261 do
1262 {
1263 bytes_read = ::read (stdout_fd, s, sizeof(s)-1);
1264 if (bytes_read < 0)
1265 {
1266 int read_errno = errno;
1267 DNBLogThreadedIf(LOG_PROCESS, "read (stdout_fd, ) => %d errno: %d (%s)", bytes_read, read_errno, strerror(read_errno));
1268 }
1269 else if (bytes_read == 0)
1270 {
1271 // EOF...
1272 DNBLogThreadedIf(LOG_PROCESS, "read (stdout_fd, ) => %d (reached EOF for child STDOUT)", bytes_read);
1273 stdout_fd = -1;
1274 }
1275 else if (bytes_read > 0)
1276 {
1277 proc->AppendSTDOUT(s, bytes_read);
1278 }
1279
1280 } while (bytes_read > 0);
1281 }
1282
1283 if (stderr_fd >= 0 && FD_ISSET (stderr_fd, &read_fds))
1284 {
1285 do
1286 {
1287 bytes_read = ::read (stderr_fd, s, sizeof(s)-1);
1288 if (bytes_read < 0)
1289 {
1290 int read_errno = errno;
1291 DNBLogThreadedIf(LOG_PROCESS, "read (stderr_fd, ) => %d errno: %d (%s)", bytes_read, read_errno, strerror(read_errno));
1292 }
1293 else if (bytes_read == 0)
1294 {
1295 // EOF...
1296 DNBLogThreadedIf(LOG_PROCESS, "read (stderr_fd, ) => %d (reached EOF for child STDERR)", bytes_read);
1297 stderr_fd = -1;
1298 }
1299 else if (bytes_read > 0)
1300 {
1301 proc->AppendSTDOUT(s, bytes_read);
1302 }
1303
1304 } while (bytes_read > 0);
1305 }
1306 }
1307 }
1308 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%p): thread exiting...", __FUNCTION__, arg);
1309 return NULL;
1310}
1311
1312pid_t
1313MachProcess::AttachForDebug (pid_t pid, char *err_str, size_t err_len)
1314{
1315 // Clear out and clean up from any current state
1316 Clear();
1317 if (pid != 0)
1318 {
Greg Clayton3382c2c2010-07-30 23:14:42 +00001319 DNBError err;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001320 // Make sure the process exists...
1321 if (::getpgid (pid) < 0)
1322 {
Greg Clayton3382c2c2010-07-30 23:14:42 +00001323 err.SetErrorToErrno();
1324 const char *err_cstr = err.AsString();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001325 ::snprintf (err_str, err_len, "%s", err_cstr ? err_cstr : "No such process");
1326 return INVALID_NUB_PROCESS;
1327 }
1328
1329 SetState(eStateAttaching);
1330 m_pid = pid;
1331 // Let ourselves know we are going to be using SBS if the correct flag bit is set...
1332#if defined (__arm__)
1333 if (IsSBProcess(pid))
1334 m_flags |= eMachProcessFlagsUsingSBS;
1335#endif
Greg Clayton3382c2c2010-07-30 23:14:42 +00001336 if (!m_task.StartExceptionThread(err))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001337 {
Greg Clayton3382c2c2010-07-30 23:14:42 +00001338 const char *err_cstr = err.AsString();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001339 ::snprintf (err_str, err_len, "%s", err_cstr ? err_cstr : "unable to start the exception thread");
1340 DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
1341 m_pid = INVALID_NUB_PROCESS;
1342 return INVALID_NUB_PROCESS;
1343 }
1344
1345 errno = 0;
Greg Clayton3382c2c2010-07-30 23:14:42 +00001346 if (::ptrace (PT_ATTACHEXC, pid, 0, 0))
1347 err.SetError(errno);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001348 else
Greg Clayton3382c2c2010-07-30 23:14:42 +00001349 err.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001350
Greg Clayton3382c2c2010-07-30 23:14:42 +00001351 if (err.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001352 {
1353 m_flags |= eMachProcessFlagsAttached;
1354 // Sleep a bit to let the exception get received and set our process status
1355 // to stopped.
1356 ::usleep(250000);
1357 DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid);
1358 return m_pid;
1359 }
1360 else
1361 {
Greg Clayton3382c2c2010-07-30 23:14:42 +00001362 ::snprintf (err_str, err_len, "%s", err.AsString());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001363 DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
1364 }
1365 }
1366 return INVALID_NUB_PROCESS;
1367}
1368
1369// Do the process specific setup for attach. If this returns NULL, then there's no
1370// platform specific stuff to be done to wait for the attach. If you get non-null,
1371// pass that token to the CheckForProcess method, and then to CleanupAfterAttach.
1372
1373// Call PrepareForAttach before attaching to a process that has not yet launched
1374// This returns a token that can be passed to CheckForProcess, and to CleanupAfterAttach.
1375// You should call CleanupAfterAttach to free the token, and do whatever other
1376// cleanup seems good.
1377
1378const void *
1379MachProcess::PrepareForAttach (const char *path, nub_launch_flavor_t launch_flavor, bool waitfor, DNBError &err_str)
1380{
1381#if defined (__arm__)
1382 // Tell SpringBoard to halt the next launch of this application on startup.
1383
1384 if (!waitfor)
1385 return NULL;
1386
1387 const char *app_ext = strstr(path, ".app");
1388 if (app_ext == NULL)
1389 {
1390 DNBLogThreadedIf(LOG_PROCESS, "%s: path '%s' doesn't contain .app, we can't tell springboard to wait for launch...", path);
1391 return NULL;
1392 }
1393
1394 if (launch_flavor != eLaunchFlavorSpringBoard
1395 && launch_flavor != eLaunchFlavorDefault)
1396 return NULL;
1397
1398 std::string app_bundle_path(path, app_ext + strlen(".app"));
1399
1400 CFStringRef bundleIDCFStr = CopyBundleIDForPath (app_bundle_path.c_str (), err_str);
1401 std::string bundleIDStr;
1402 CFString::UTF8(bundleIDCFStr, bundleIDStr);
1403 DNBLogThreadedIf(LOG_PROCESS, "CopyBundleIDForPath (%s, err_str) returned @\"%s\"", app_bundle_path.c_str (), bundleIDStr.c_str());
1404
1405 if (bundleIDCFStr == NULL)
1406 {
1407 return NULL;
1408 }
1409
1410 SBSApplicationLaunchError sbs_error = 0;
1411
1412 const char *stdout_err = "/dev/null";
1413 CFString stdio_path;
1414 stdio_path.SetFileSystemRepresentation (stdout_err);
1415
1416 DNBLogThreadedIf(LOG_PROCESS, "SBSLaunchApplicationForDebugging ( @\"%s\" , NULL, NULL, NULL, @\"%s\", @\"%s\", SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger )", bundleIDStr.c_str(), stdout_err, stdout_err);
1417 sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr,
1418 (CFURLRef)NULL, // openURL
1419 NULL, // launch_argv.get(),
1420 NULL, // launch_envp.get(), // CFDictionaryRef environment
1421 stdio_path.get(),
1422 stdio_path.get(),
1423 SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger);
1424
1425 if (sbs_error != SBSApplicationLaunchErrorSuccess)
1426 {
1427 err_str.SetError(sbs_error, DNBError::SpringBoard);
1428 return NULL;
1429 }
1430
1431 DNBLogThreadedIf(LOG_PROCESS, "Successfully set DebugOnNextLaunch.");
1432 return bundleIDCFStr;
1433# else
1434 return NULL;
1435#endif
1436}
1437
1438// Pass in the token you got from PrepareForAttach. If there is a process
1439// for that token, then the pid will be returned, otherwise INVALID_NUB_PROCESS
1440// will be returned.
1441
1442nub_process_t
1443MachProcess::CheckForProcess (const void *attach_token)
1444{
1445 if (attach_token == NULL)
1446 return INVALID_NUB_PROCESS;
1447
1448#if defined (__arm__)
1449 CFStringRef bundleIDCFStr = (CFStringRef) attach_token;
1450 Boolean got_it;
1451 nub_process_t attach_pid;
1452 got_it = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &attach_pid);
1453 if (got_it)
1454 return attach_pid;
1455 else
1456 return INVALID_NUB_PROCESS;
1457#endif
1458 return INVALID_NUB_PROCESS;
1459}
1460
1461// Call this to clean up after you have either attached or given up on the attach.
1462// Pass true for success if you have attached, false if you have not.
1463// The token will also be freed at this point, so you can't use it after calling
1464// this method.
1465
1466void
1467MachProcess::CleanupAfterAttach (const void *attach_token, bool success, DNBError &err_str)
1468{
1469#if defined (__arm__)
1470 if (attach_token == NULL)
1471 return;
1472
1473 // Tell SpringBoard to cancel the debug on next launch of this application
1474 // if we failed to attach
1475 if (!success)
1476 {
1477 SBSApplicationLaunchError sbs_error = 0;
1478 CFStringRef bundleIDCFStr = (CFStringRef) attach_token;
1479
1480 sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr,
1481 (CFURLRef)NULL,
1482 NULL,
1483 NULL,
1484 NULL,
1485 NULL,
1486 SBSApplicationCancelDebugOnNextLaunch);
1487
1488 if (sbs_error != SBSApplicationLaunchErrorSuccess)
1489 {
1490 err_str.SetError(sbs_error, DNBError::SpringBoard);
1491 return;
1492 }
1493 }
1494
1495 CFRelease((CFStringRef) attach_token);
1496#endif
1497}
1498
1499pid_t
1500MachProcess::LaunchForDebug
1501(
1502 const char *path,
1503 char const *argv[],
1504 char const *envp[],
Greg Clayton6779606a2011-01-22 23:43:18 +00001505 const char *working_directory, // NULL => dont' change, non-NULL => set working directory for inferior to this
1506 const char *stdin_path,
1507 const char *stdout_path,
1508 const char *stderr_path,
Caroline Ticef8da8632010-12-03 18:46:09 +00001509 bool no_stdio,
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001510 nub_launch_flavor_t launch_flavor,
Greg Claytonf681b942010-08-31 18:35:14 +00001511 int disable_aslr,
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001512 DNBError &launch_err
1513)
1514{
1515 // Clear out and clean up from any current state
1516 Clear();
1517
Greg Claytonf681b942010-08-31 18:35:14 +00001518 DNBLogThreadedIf(LOG_PROCESS, "%s( path = '%s', argv = %p, envp = %p, launch_flavor = %u, disable_aslr = %d )", __FUNCTION__, path, argv, envp, launch_flavor, disable_aslr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001519
1520 // Fork a child process for debugging
1521 SetState(eStateLaunching);
1522
1523 switch (launch_flavor)
1524 {
1525 case eLaunchFlavorForkExec:
1526 m_pid = MachProcess::ForkChildForPTraceDebugging (path, argv, envp, this, launch_err);
1527 break;
1528
1529 case eLaunchFlavorPosixSpawn:
Greg Clayton3af9ea52010-11-18 05:57:03 +00001530 m_pid = MachProcess::PosixSpawnChildForPTraceDebugging (path,
Greg Clayton3c144382010-12-01 22:45:40 +00001531 DNBArchProtocol::GetArchitecture (),
Greg Clayton3af9ea52010-11-18 05:57:03 +00001532 argv,
1533 envp,
Greg Clayton6779606a2011-01-22 23:43:18 +00001534 working_directory,
1535 stdin_path,
1536 stdout_path,
1537 stderr_path,
Caroline Ticef8da8632010-12-03 18:46:09 +00001538 no_stdio,
Greg Clayton3af9ea52010-11-18 05:57:03 +00001539 this,
1540 disable_aslr,
1541 launch_err);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001542 break;
1543
1544#if defined (__arm__)
1545
1546 case eLaunchFlavorSpringBoard:
1547 {
1548 const char *app_ext = strstr(path, ".app");
1549 if (app_ext != NULL)
1550 {
1551 std::string app_bundle_path(path, app_ext + strlen(".app"));
Caroline Ticef8da8632010-12-03 18:46:09 +00001552 return SBLaunchForDebug (app_bundle_path.c_str(), argv, envp, no_stdio, launch_err);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001553 }
1554 }
1555 break;
1556
1557#endif
1558
1559 default:
1560 // Invalid launch
1561 launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
1562 return INVALID_NUB_PROCESS;
1563 }
1564
1565 if (m_pid == INVALID_NUB_PROCESS)
1566 {
1567 // If we don't have a valid process ID and no one has set the error,
1568 // then return a generic error
1569 if (launch_err.Success())
1570 launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
1571 }
1572 else
1573 {
1574 m_path = path;
1575 size_t i;
1576 char const *arg;
1577 for (i=0; (arg = argv[i]) != NULL; i++)
1578 m_args.push_back(arg);
1579
Greg Clayton3382c2c2010-07-30 23:14:42 +00001580 m_task.StartExceptionThread(launch_err);
1581 if (launch_err.Fail())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001582 {
Greg Clayton3382c2c2010-07-30 23:14:42 +00001583 if (launch_err.AsString() == NULL)
1584 launch_err.SetErrorString("unable to start the exception thread");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001585 ::ptrace (PT_KILL, m_pid, 0, 0);
1586 m_pid = INVALID_NUB_PROCESS;
1587 return INVALID_NUB_PROCESS;
1588 }
1589
1590 StartSTDIOThread();
1591
1592 if (launch_flavor == eLaunchFlavorPosixSpawn)
1593 {
1594
1595 SetState (eStateAttaching);
1596 errno = 0;
Caroline Tice5d7be2e2010-11-02 16:16:53 +00001597 int err = ::ptrace (PT_ATTACHEXC, m_pid, 0, 0);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001598 if (err == 0)
1599 {
1600 m_flags |= eMachProcessFlagsAttached;
1601 DNBLogThreadedIf(LOG_PROCESS, "successfully spawned pid %d", m_pid);
1602 launch_err.Clear();
1603 }
1604 else
1605 {
1606 SetState (eStateExited);
1607 DNBError ptrace_err(errno, DNBError::POSIX);
1608 DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to spawned pid %d (err = %i, errno = %i (%s))", m_pid, err, ptrace_err.Error(), ptrace_err.AsString());
1609 launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
1610 }
1611 }
1612 else
1613 {
1614 launch_err.Clear();
1615 }
1616 }
1617 return m_pid;
1618}
1619
1620pid_t
1621MachProcess::PosixSpawnChildForPTraceDebugging
1622(
1623 const char *path,
Greg Clayton3af9ea52010-11-18 05:57:03 +00001624 cpu_type_t cpu_type,
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001625 char const *argv[],
1626 char const *envp[],
Greg Clayton6779606a2011-01-22 23:43:18 +00001627 const char *working_directory,
1628 const char *stdin_path,
1629 const char *stdout_path,
1630 const char *stderr_path,
Caroline Ticef8da8632010-12-03 18:46:09 +00001631 bool no_stdio,
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001632 MachProcess* process,
Greg Claytonf681b942010-08-31 18:35:14 +00001633 int disable_aslr,
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001634 DNBError& err
1635)
1636{
1637 posix_spawnattr_t attr;
Greg Claytonf681b942010-08-31 18:35:14 +00001638 short flags;
Greg Claytonbd82a5d2011-01-23 05:56:20 +00001639 DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv=%p, envp=%p, working_dir=%s, stdin=%s, stdout=%s stderr=%s, no-stdio=%i)",
1640 __FUNCTION__,
1641 path,
1642 argv,
1643 envp,
1644 working_directory,
1645 stdin_path,
1646 stdout_path,
1647 stderr_path,
1648 no_stdio);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001649
1650 err.SetError( ::posix_spawnattr_init (&attr), DNBError::POSIX);
1651 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
1652 err.LogThreaded("::posix_spawnattr_init ( &attr )");
1653 if (err.Fail())
1654 return INVALID_NUB_PROCESS;
1655
Greg Claytonf681b942010-08-31 18:35:14 +00001656 flags = POSIX_SPAWN_START_SUSPENDED;
1657 if (disable_aslr)
1658 flags |= _POSIX_SPAWN_DISABLE_ASLR;
1659
1660 err.SetError( ::posix_spawnattr_setflags (&attr, flags), DNBError::POSIX);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001661 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
Greg Claytonf681b942010-08-31 18:35:14 +00001662 err.LogThreaded("::posix_spawnattr_setflags ( &attr, POSIX_SPAWN_START_SUSPENDED%s )", flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR" : "");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001663 if (err.Fail())
1664 return INVALID_NUB_PROCESS;
1665
1666 // Don't do this on SnowLeopard, _sometimes_ the TASK_BASIC_INFO will fail
1667 // and we will fail to continue with our process...
1668
1669 // On SnowLeopard we should set "DYLD_NO_PIE" in the inferior environment....
1670
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001671#if !defined(__arm__)
1672
1673 // We don't need to do this for ARM, and we really shouldn't now that we
1674 // have multiple CPU subtypes and no posix_spawnattr call that allows us
1675 // to set which CPU subtype to launch...
Greg Clayton71337622011-02-24 22:24:29 +00001676 if (cpu_type != 0)
1677 {
1678 size_t ocount = 0;
1679 err.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu_type, &ocount), DNBError::POSIX);
1680 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
1681 err.LogThreaded("::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %zu )", cpu_type, ocount);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001682
Greg Clayton71337622011-02-24 22:24:29 +00001683 if (err.Fail() != 0 || ocount != 1)
1684 return INVALID_NUB_PROCESS;
1685 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001686#endif
1687
1688 PseudoTerminal pty;
1689
1690 posix_spawn_file_actions_t file_actions;
1691 err.SetError( ::posix_spawn_file_actions_init (&file_actions), DNBError::POSIX);
1692 int file_actions_valid = err.Success();
1693 if (!file_actions_valid || DNBLogCheckLogBit(LOG_PROCESS))
1694 err.LogThreaded("::posix_spawn_file_actions_init ( &file_actions )");
1695 int pty_error = -1;
1696 pid_t pid = INVALID_NUB_PROCESS;
1697 if (file_actions_valid)
1698 {
Greg Clayton6779606a2011-01-22 23:43:18 +00001699 if (stdin_path == NULL && stdout_path == NULL && stderr_path == NULL && !no_stdio)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001700 {
1701 pty_error = pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY);
1702 if (pty_error == PseudoTerminal::success)
Greg Clayton6779606a2011-01-22 23:43:18 +00001703 {
1704 stdin_path = stdout_path = stderr_path = pty.SlaveName();
1705 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001706 }
1707
Caroline Ticef8da8632010-12-03 18:46:09 +00001708 // if no_stdio, then do open file actions, opening /dev/null.
1709 if (no_stdio)
1710 {
1711 err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, STDIN_FILENO, "/dev/null",
1712 O_RDONLY | O_NOCTTY, 0), DNBError::POSIX);
1713 if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS))
1714 err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDIN_FILENO, path=/dev/null)");
1715
1716 err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, STDOUT_FILENO, "/dev/null",
1717 O_WRONLY | O_NOCTTY, 0), DNBError::POSIX);
1718 if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS))
1719 err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDOUT_FILENO, path=/dev/null)");
1720
1721 err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, STDERR_FILENO, "/dev/null",
1722 O_RDWR | O_NOCTTY, 0), DNBError::POSIX);
1723 if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS))
1724 err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDERR_FILENO, path=/dev/null)");
1725 }
Greg Clayton6779606a2011-01-22 23:43:18 +00001726 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001727 {
Greg Clayton71337622011-02-24 22:24:29 +00001728 if ( stdin_path == NULL) stdin_path = "/dev/null";
1729 if (stdout_path == NULL) stdout_path = "/dev/null";
1730 if (stderr_path == NULL) stderr_path = "/dev/null";
1731
1732 int slave_fd_err = open (stderr_path, O_NOCTTY | O_CREAT | O_RDWR , 0640);
1733 int slave_fd_in = open (stdin_path , O_NOCTTY | O_RDONLY);
1734 int slave_fd_out = open (stdout_path, O_NOCTTY | O_CREAT | O_WRONLY , 0640);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001735
Caroline Tice5e254d32010-11-05 22:37:44 +00001736 err.SetError( ::posix_spawn_file_actions_adddup2(&file_actions, slave_fd_err, STDERR_FILENO), DNBError::POSIX);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001737 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
Greg Clayton71337622011-02-24 22:24:29 +00001738 err.LogThreaded("::posix_spawn_file_actions_adddup2 ( &file_actions, filedes = %d (\"%s\"), newfiledes = STDERR_FILENO )", slave_fd_err, stderr_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001739
Caroline Tice5e254d32010-11-05 22:37:44 +00001740 err.SetError( ::posix_spawn_file_actions_adddup2(&file_actions, slave_fd_in, STDIN_FILENO), DNBError::POSIX);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001741 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
Greg Clayton71337622011-02-24 22:24:29 +00001742 err.LogThreaded("::posix_spawn_file_actions_adddup2 ( &file_actions, filedes = %d (\"%s\"), newfiledes = STDIN_FILENO )", slave_fd_in, stdin_path);
Caroline Tice5e254d32010-11-05 22:37:44 +00001743
1744 err.SetError( ::posix_spawn_file_actions_adddup2(&file_actions, slave_fd_out, STDOUT_FILENO), DNBError::POSIX);
1745 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
Greg Clayton71337622011-02-24 22:24:29 +00001746 err.LogThreaded("::posix_spawn_file_actions_adddup2 ( &file_actions, filedes = %d (\"%s\"), newfiledes = STDOUT_FILENO )", slave_fd_out, stdout_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001747 }
Greg Claytonbd82a5d2011-01-23 05:56:20 +00001748
1749 // TODO: Verify if we can set the working directory back immediately
1750 // after the posix_spawnp call without creating a race condition???
1751 if (working_directory)
1752 ::chdir (working_directory);
1753
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001754 err.SetError( ::posix_spawnp (&pid, path, &file_actions, &attr, (char * const*)argv, (char * const*)envp), DNBError::POSIX);
1755 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
1756 err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", pid, path, &file_actions, &attr, argv, envp);
1757 }
1758 else
1759 {
Greg Claytonbd82a5d2011-01-23 05:56:20 +00001760 // TODO: Verify if we can set the working directory back immediately
1761 // after the posix_spawnp call without creating a race condition???
1762 if (working_directory)
1763 ::chdir (working_directory);
1764
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001765 err.SetError( ::posix_spawnp (&pid, path, NULL, &attr, (char * const*)argv, (char * const*)envp), DNBError::POSIX);
1766 if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
1767 err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", pid, path, NULL, &attr, argv, envp);
1768 }
1769
1770 // We have seen some cases where posix_spawnp was returning a valid
1771 // looking pid even when an error was returned, so clear it out
1772 if (err.Fail())
1773 pid = INVALID_NUB_PROCESS;
1774
1775 if (pty_error == 0)
1776 {
1777 if (process != NULL)
1778 {
1779 int master_fd = pty.ReleaseMasterFD();
1780 process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
1781 }
1782 }
Greg Clayton0b42ac32010-07-02 01:29:13 +00001783 ::posix_spawnattr_destroy (&attr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001784
Greg Clayton71337622011-02-24 22:24:29 +00001785 if (pid != INVALID_NUB_PROCESS)
1786 {
1787 cpu_type_t pid_cpu_type = MachProcess::GetCPUTypeForLocalProcess (pid);
1788 DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( ) pid=%i, cpu_type=0x%8.8x", __FUNCTION__, pid, pid_cpu_type);
1789 if (pid_cpu_type)
1790 DNBArchProtocol::SetArchitecture (pid_cpu_type);
1791 }
1792
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001793 if (file_actions_valid)
1794 {
1795 DNBError err2;
1796 err2.SetError( ::posix_spawn_file_actions_destroy (&file_actions), DNBError::POSIX);
1797 if (err2.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
1798 err2.LogThreaded("::posix_spawn_file_actions_destroy ( &file_actions )");
1799 }
1800
1801 return pid;
1802}
1803
Greg Clayton71337622011-02-24 22:24:29 +00001804uint32_t
1805MachProcess::GetCPUTypeForLocalProcess (pid_t pid)
1806{
1807 int mib[CTL_MAXNAME]={0,};
1808 size_t len = CTL_MAXNAME;
1809 if (::sysctlnametomib("sysctl.proc_cputype", mib, &len))
1810 return 0;
1811
1812 mib[len] = pid;
1813 len++;
1814
1815 cpu_type_t cpu;
1816 size_t cpu_len = sizeof(cpu);
1817 if (::sysctl (mib, len, &cpu, &cpu_len, 0, 0))
1818 cpu = 0;
1819 return cpu;
1820}
1821
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001822pid_t
1823MachProcess::ForkChildForPTraceDebugging
1824(
1825 const char *path,
1826 char const *argv[],
1827 char const *envp[],
1828 MachProcess* process,
1829 DNBError& launch_err
1830)
1831{
1832 PseudoTerminal::Error pty_error = PseudoTerminal::success;
1833
1834 // Use a fork that ties the child process's stdin/out/err to a pseudo
1835 // terminal so we can read it in our MachProcess::STDIOThread
1836 // as unbuffered io.
1837 PseudoTerminal pty;
1838 pid_t pid = pty.Fork(pty_error);
1839
1840 if (pid < 0)
1841 {
1842 //--------------------------------------------------------------
1843 // Error during fork.
1844 //--------------------------------------------------------------
1845 return pid;
1846 }
1847 else if (pid == 0)
1848 {
1849 //--------------------------------------------------------------
1850 // Child process
1851 //--------------------------------------------------------------
1852 ::ptrace (PT_TRACE_ME, 0, 0, 0); // Debug this process
1853 ::ptrace (PT_SIGEXC, 0, 0, 0); // Get BSD signals as mach exceptions
1854
1855 // If our parent is setgid, lets make sure we don't inherit those
1856 // extra powers due to nepotism.
1857 ::setgid (getgid ());
1858
1859 // Let the child have its own process group. We need to execute
1860 // this call in both the child and parent to avoid a race condition
1861 // between the two processes.
1862 ::setpgid (0, 0); // Set the child process group to match its pid
1863
1864 // Sleep a bit to before the exec call
1865 ::sleep (1);
1866
1867 // Turn this process into
1868 ::execv (path, (char * const *)argv);
1869 // Exit with error code. Child process should have taken
1870 // over in above exec call and if the exec fails it will
1871 // exit the child process below.
1872 ::exit (127);
1873 }
1874 else
1875 {
1876 //--------------------------------------------------------------
1877 // Parent process
1878 //--------------------------------------------------------------
1879 // Let the child have its own process group. We need to execute
1880 // this call in both the child and parent to avoid a race condition
1881 // between the two processes.
1882 ::setpgid (pid, pid); // Set the child process group to match its pid
1883
1884 if (process != NULL)
1885 {
1886 // Release our master pty file descriptor so the pty class doesn't
1887 // close it and so we can continue to use it in our STDIO thread
1888 int master_fd = pty.ReleaseMasterFD();
1889 process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
1890 }
1891 }
1892 return pid;
1893}
1894
1895#if defined (__arm__)
1896
1897pid_t
Caroline Ticef8da8632010-12-03 18:46:09 +00001898MachProcess::SBLaunchForDebug (const char *path, char const *argv[], char const *envp[], bool no_stdio, DNBError &launch_err)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001899{
1900 // Clear out and clean up from any current state
1901 Clear();
1902
1903 DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
1904
1905 // Fork a child process for debugging
1906 SetState(eStateLaunching);
Caroline Ticef8da8632010-12-03 18:46:09 +00001907 m_pid = MachProcess::SBForkChildForPTraceDebugging(path, argv, envp, no_stdio, this, launch_err);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001908 if (m_pid != 0)
1909 {
1910 m_flags |= eMachProcessFlagsUsingSBS;
1911 m_path = path;
1912 size_t i;
1913 char const *arg;
1914 for (i=0; (arg = argv[i]) != NULL; i++)
1915 m_args.push_back(arg);
Greg Clayton6f35f5c2010-09-09 06:32:46 +00001916 m_task.StartExceptionThread(launch_err);
1917
1918 if (launch_err.Fail())
1919 {
1920 if (launch_err.AsString() == NULL)
1921 launch_err.SetErrorString("unable to start the exception thread");
1922 ::ptrace (PT_KILL, m_pid, 0, 0);
1923 m_pid = INVALID_NUB_PROCESS;
1924 return INVALID_NUB_PROCESS;
1925 }
1926
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001927 StartSTDIOThread();
1928 SetState (eStateAttaching);
Caroline Tice5d7be2e2010-11-02 16:16:53 +00001929 int err = ::ptrace (PT_ATTACHEXC, m_pid, 0, 0);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001930 if (err == 0)
1931 {
1932 m_flags |= eMachProcessFlagsAttached;
1933 DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
1934 }
1935 else
1936 {
1937 SetState (eStateExited);
1938 DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
1939 }
1940 }
1941 return m_pid;
1942}
1943
1944#include <servers/bootstrap.h>
1945
1946// This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
1947// or NULL if there was some problem getting the bundle id.
1948static CFStringRef
1949CopyBundleIDForPath (const char *app_bundle_path, DNBError &err_str)
1950{
1951 CFBundle bundle(app_bundle_path);
1952 CFStringRef bundleIDCFStr = bundle.GetIdentifier();
1953 std::string bundleID;
1954 if (CFString::UTF8(bundleIDCFStr, bundleID) == NULL)
1955 {
1956 struct stat app_bundle_stat;
1957 char err_msg[PATH_MAX];
1958
1959 if (::stat (app_bundle_path, &app_bundle_stat) < 0)
1960 {
1961 err_str.SetError(errno, DNBError::POSIX);
1962 snprintf(err_msg, sizeof(err_msg), "%s: \"%s\"", err_str.AsString(), app_bundle_path);
1963 err_str.SetErrorString(err_msg);
1964 DNBLogThreadedIf(LOG_PROCESS, "%s() error: %s", __FUNCTION__, err_msg);
1965 }
1966 else
1967 {
1968 err_str.SetError(-1, DNBError::Generic);
1969 snprintf(err_msg, sizeof(err_msg), "failed to extract CFBundleIdentifier from %s", app_bundle_path);
1970 err_str.SetErrorString(err_msg);
1971 DNBLogThreadedIf(LOG_PROCESS, "%s() error: failed to extract CFBundleIdentifier from '%s'", __FUNCTION__, app_bundle_path);
1972 }
1973 return NULL;
1974 }
1975
1976 DNBLogThreadedIf(LOG_PROCESS, "%s() extracted CFBundleIdentifier: %s", __FUNCTION__, bundleID.c_str());
1977 CFRetain (bundleIDCFStr);
1978
1979 return bundleIDCFStr;
1980}
1981
1982pid_t
Caroline Ticef8da8632010-12-03 18:46:09 +00001983MachProcess::SBForkChildForPTraceDebugging (const char *app_bundle_path, char const *argv[], char const *envp[], bool no_stdio, MachProcess* process, DNBError &launch_err)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001984{
1985 DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__, app_bundle_path, process);
1986 CFAllocatorRef alloc = kCFAllocatorDefault;
1987
1988 if (argv[0] == NULL)
1989 return INVALID_NUB_PROCESS;
1990
1991 size_t argc = 0;
1992 // Count the number of arguments
1993 while (argv[argc] != NULL)
1994 argc++;
1995
1996 // Enumerate the arguments
1997 size_t first_launch_arg_idx = 1;
1998 CFReleaser<CFMutableArrayRef> launch_argv;
1999
2000 if (argv[first_launch_arg_idx])
2001 {
2002 size_t launch_argc = argc > 0 ? argc - 1 : 0;
2003 launch_argv.reset (::CFArrayCreateMutable (alloc, launch_argc, &kCFTypeArrayCallBacks));
2004 size_t i;
2005 char const *arg;
2006 CFString launch_arg;
2007 for (i=first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL); i++)
2008 {
2009 launch_arg.reset(::CFStringCreateWithCString (alloc, arg, kCFStringEncodingUTF8));
2010 if (launch_arg.get() != NULL)
2011 CFArrayAppendValue(launch_argv.get(), launch_arg.get());
2012 else
2013 break;
2014 }
2015 }
2016
2017 // Next fill in the arguments dictionary. Note, the envp array is of the form
2018 // Variable=value but SpringBoard wants a CF dictionary. So we have to convert
2019 // this here.
2020
2021 CFReleaser<CFMutableDictionaryRef> launch_envp;
2022
2023 if (envp[0])
2024 {
2025 launch_envp.reset(::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
2026 const char *value;
2027 int name_len;
2028 CFString name_string, value_string;
2029
2030 for (int i = 0; envp[i] != NULL; i++)
2031 {
2032 value = strstr (envp[i], "=");
2033
2034 // If the name field is empty or there's no =, skip it. Somebody's messing with us.
2035 if (value == NULL || value == envp[i])
2036 continue;
2037
2038 name_len = value - envp[i];
2039
2040 // Now move value over the "="
2041 value++;
2042
2043 name_string.reset(::CFStringCreateWithBytes(alloc, (const UInt8 *) envp[i], name_len, kCFStringEncodingUTF8, false));
2044 value_string.reset(::CFStringCreateWithCString(alloc, value, kCFStringEncodingUTF8));
2045 CFDictionarySetValue (launch_envp.get(), name_string.get(), value_string.get());
2046 }
2047 }
2048
2049 CFString stdio_path;
2050
2051 PseudoTerminal pty;
Caroline Ticef8da8632010-12-03 18:46:09 +00002052 if (!no_stdio)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002053 {
Caroline Ticef8da8632010-12-03 18:46:09 +00002054 PseudoTerminal::Error pty_err = pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY);
2055 if (pty_err == PseudoTerminal::success)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002056 {
Caroline Ticef8da8632010-12-03 18:46:09 +00002057 const char* slave_name = pty.SlaveName();
2058 DNBLogThreadedIf(LOG_PROCESS, "%s() successfully opened master pty, slave is %s", __FUNCTION__, slave_name);
2059 if (slave_name && slave_name[0])
2060 {
2061 ::chmod (slave_name, S_IRWXU | S_IRWXG | S_IRWXO);
2062 stdio_path.SetFileSystemRepresentation (slave_name);
2063 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002064 }
2065 }
Caroline Ticef8da8632010-12-03 18:46:09 +00002066
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002067 if (stdio_path.get() == NULL)
2068 {
2069 stdio_path.SetFileSystemRepresentation ("/dev/null");
2070 }
2071
2072 CFStringRef bundleIDCFStr = CopyBundleIDForPath (app_bundle_path, launch_err);
2073 if (bundleIDCFStr == NULL)
2074 return INVALID_NUB_PROCESS;
2075
2076 std::string bundleID;
2077 CFString::UTF8(bundleIDCFStr, bundleID);
2078
2079 CFData argv_data(NULL);
2080
2081 if (launch_argv.get())
2082 {
2083 if (argv_data.Serialize(launch_argv.get(), kCFPropertyListBinaryFormat_v1_0) == NULL)
2084 {
2085 DNBLogThreadedIf(LOG_PROCESS, "%s() error: failed to serialize launch arg array...", __FUNCTION__);
2086 return INVALID_NUB_PROCESS;
2087 }
2088 }
2089
2090 DNBLogThreadedIf(LOG_PROCESS, "%s() serialized launch arg array", __FUNCTION__);
2091
2092 // Find SpringBoard
2093 SBSApplicationLaunchError sbs_error = 0;
2094 sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr,
2095 (CFURLRef)NULL, // openURL
2096 launch_argv.get(),
2097 launch_envp.get(), // CFDictionaryRef environment
2098 stdio_path.get(),
2099 stdio_path.get(),
2100 SBSApplicationLaunchWaitForDebugger | SBSApplicationLaunchUnlockDevice);
2101
2102
2103 launch_err.SetError(sbs_error, DNBError::SpringBoard);
2104
2105 if (sbs_error == SBSApplicationLaunchErrorSuccess)
2106 {
2107 static const useconds_t pid_poll_interval = 200000;
2108 static const useconds_t pid_poll_timeout = 30000000;
2109
2110 useconds_t pid_poll_total = 0;
2111
2112 nub_process_t pid = INVALID_NUB_PROCESS;
2113 Boolean pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
2114 // Poll until the process is running, as long as we are getting valid responses and the timeout hasn't expired
2115 // A return PID of 0 means the process is not running, which may be because it hasn't been (asynchronously) started
2116 // yet, or that it died very quickly (if you weren't using waitForDebugger).
2117 while (!pid_found && pid_poll_total < pid_poll_timeout)
2118 {
2119 usleep (pid_poll_interval);
2120 pid_poll_total += pid_poll_interval;
2121 DNBLogThreadedIf(LOG_PROCESS, "%s() polling Springboard for pid for %s...", __FUNCTION__, bundleID.c_str());
2122 pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
2123 }
2124
2125 CFRelease (bundleIDCFStr);
2126 if (pid_found)
2127 {
2128 if (process != NULL)
2129 {
2130 // Release our master pty file descriptor so the pty class doesn't
2131 // close it and so we can continue to use it in our STDIO thread
2132 int master_fd = pty.ReleaseMasterFD();
2133 process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
2134 }
2135 DNBLogThreadedIf(LOG_PROCESS, "%s() => pid = %4.4x", __FUNCTION__, pid);
2136 }
2137 else
2138 {
2139 DNBLogError("failed to lookup the process ID for CFBundleIdentifier %s.", bundleID.c_str());
2140 }
2141 return pid;
2142 }
2143
2144 DNBLogError("unable to launch the application with CFBundleIdentifier '%s' sbs_error = %u", bundleID.c_str(), sbs_error);
2145 return INVALID_NUB_PROCESS;
2146}
2147
2148#endif // #if defined (__arm__)
2149
2150