DNB.cpp revision 1308a9555ad586ff03c8f97bcfe7f3212d06bc86
1//===-- DNB.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 3/23/07. 11// 12//===----------------------------------------------------------------------===// 13 14#include "DNB.h" 15#include <signal.h> 16#include <stdio.h> 17#include <stdlib.h> 18#include <sys/resource.h> 19#include <sys/stat.h> 20#include <sys/types.h> 21#include <sys/wait.h> 22#include <unistd.h> 23#include <sys/sysctl.h> 24#include <map> 25#include <vector> 26 27#include "MacOSX/MachProcess.h" 28#include "MacOSX/MachTask.h" 29#include "CFString.h" 30#include "DNBLog.h" 31#include "DNBDataRef.h" 32#include "DNBThreadResumeActions.h" 33#include "DNBTimer.h" 34 35typedef std::tr1::shared_ptr<MachProcess> MachProcessSP; 36typedef std::map<nub_process_t, MachProcessSP> ProcessMap; 37typedef ProcessMap::iterator ProcessMapIter; 38typedef ProcessMap::const_iterator ProcessMapConstIter; 39 40static size_t GetAllInfos (std::vector<struct kinfo_proc>& proc_infos); 41static size_t GetAllInfosMatchingName (const char *process_name, std::vector<struct kinfo_proc>& matching_proc_infos); 42 43//---------------------------------------------------------------------- 44// A Thread safe singleton to get a process map pointer. 45// 46// Returns a pointer to the existing process map, or a pointer to a 47// newly created process map if CAN_CREATE is non-zero. 48//---------------------------------------------------------------------- 49static ProcessMap* 50GetProcessMap(bool can_create) 51{ 52 static ProcessMap* g_process_map_ptr = NULL; 53 54 if (can_create && g_process_map_ptr == NULL) 55 { 56 static pthread_mutex_t g_process_map_mutex = PTHREAD_MUTEX_INITIALIZER; 57 PTHREAD_MUTEX_LOCKER (locker, &g_process_map_mutex); 58 if (g_process_map_ptr == NULL) 59 g_process_map_ptr = new ProcessMap; 60 } 61 return g_process_map_ptr; 62} 63 64//---------------------------------------------------------------------- 65// Add PID to the shared process pointer map. 66// 67// Return non-zero value if we succeed in adding the process to the map. 68// The only time this should fail is if we run out of memory and can't 69// allocate a ProcessMap. 70//---------------------------------------------------------------------- 71static nub_bool_t 72AddProcessToMap (nub_process_t pid, MachProcessSP& procSP) 73{ 74 ProcessMap* process_map = GetProcessMap(true); 75 if (process_map) 76 { 77 process_map->insert(std::make_pair(pid, procSP)); 78 return true; 79 } 80 return false; 81} 82 83//---------------------------------------------------------------------- 84// Remove the shared pointer for PID from the process map. 85// 86// Returns the number of items removed from the process map. 87//---------------------------------------------------------------------- 88static size_t 89RemoveProcessFromMap (nub_process_t pid) 90{ 91 ProcessMap* process_map = GetProcessMap(false); 92 if (process_map) 93 { 94 return process_map->erase(pid); 95 } 96 return 0; 97} 98 99//---------------------------------------------------------------------- 100// Get the shared pointer for PID from the existing process map. 101// 102// Returns true if we successfully find a shared pointer to a 103// MachProcess object. 104//---------------------------------------------------------------------- 105static nub_bool_t 106GetProcessSP (nub_process_t pid, MachProcessSP& procSP) 107{ 108 ProcessMap* process_map = GetProcessMap(false); 109 if (process_map != NULL) 110 { 111 ProcessMapIter pos = process_map->find(pid); 112 if (pos != process_map->end()) 113 { 114 procSP = pos->second; 115 return true; 116 } 117 } 118 procSP.reset(); 119 return false; 120} 121 122 123static void * 124waitpid_thread (void *arg) 125{ 126 const pid_t pid = (pid_t)(intptr_t)arg; 127 int status; 128 while (1) 129 { 130 pid_t child_pid = waitpid(pid, &status, 0); 131 DNBLogThreadedIf(LOG_PROCESS, "waitpid_process_thread (): waitpid (pid = %i, &status, 0) => %i, status = %i, errno = %i", pid, child_pid, status, errno); 132 133 if (child_pid < 0) 134 { 135 if (errno == EINTR) 136 continue; 137 break; 138 } 139 else 140 { 141 if (WIFSTOPPED(status)) 142 { 143 continue; 144 } 145 else// if (WIFEXITED(status) || WIFSIGNALED(status)) 146 { 147 DNBLogThreadedIf(LOG_PROCESS, "waitpid_process_thread (): setting exit status for pid = %i to %i", child_pid, status); 148 DNBProcessSetExitStatus (child_pid, status); 149 return NULL; 150 } 151 } 152 } 153 154 // We should never exit as long as our child process is alive, so if we 155 // do something else went wrong and we should exit... 156 DNBLogThreadedIf(LOG_PROCESS, "waitpid_process_thread (): main loop exited, setting exit status to an invalid value (-1) for pid %i", pid); 157 DNBProcessSetExitStatus (pid, -1); 158 return NULL; 159} 160 161static bool 162spawn_waitpid_thread (pid_t pid) 163{ 164 pthread_t thread = THREAD_NULL; 165 ::pthread_create (&thread, NULL, waitpid_thread, (void *)(intptr_t)pid); 166 if (thread != THREAD_NULL) 167 { 168 ::pthread_detach (thread); 169 return true; 170 } 171 return false; 172} 173 174nub_process_t 175DNBProcessLaunch (const char *path, 176 char const *argv[], 177 const char *envp[], 178 const char *working_directory, // NULL => dont' change, non-NULL => set working directory for inferior to this 179 const char *stdin_path, 180 const char *stdout_path, 181 const char *stderr_path, 182 bool no_stdio, 183 nub_launch_flavor_t launch_flavor, 184 int disable_aslr, 185 char *err_str, 186 size_t err_len) 187{ 188 DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv = %p, envp = %p, working_dir=%s, stdin=%s, stdout=%s, stderr=%s, no-stdio=%i, launch_flavor = %u, disable_aslr = %d, err = %p, err_len = %zu) called...", 189 __FUNCTION__, 190 path, 191 argv, 192 envp, 193 working_directory, 194 stdin_path, 195 stdout_path, 196 stderr_path, 197 no_stdio, 198 launch_flavor, 199 disable_aslr, 200 err_str, 201 err_len); 202 203 if (err_str && err_len > 0) 204 err_str[0] = '\0'; 205 struct stat path_stat; 206 if (::stat(path, &path_stat) == -1) 207 { 208 char stat_error[256]; 209 ::strerror_r (errno, stat_error, sizeof(stat_error)); 210 snprintf(err_str, err_len, "%s (%s)", stat_error, path); 211 return INVALID_NUB_PROCESS; 212 } 213 214 MachProcessSP processSP (new MachProcess); 215 if (processSP.get()) 216 { 217 DNBError launch_err; 218 pid_t pid = processSP->LaunchForDebug (path, 219 argv, 220 envp, 221 working_directory, 222 stdin_path, 223 stdout_path, 224 stderr_path, 225 no_stdio, 226 launch_flavor, 227 disable_aslr, 228 launch_err); 229 if (err_str) 230 { 231 *err_str = '\0'; 232 if (launch_err.Fail()) 233 { 234 const char *launch_err_str = launch_err.AsString(); 235 if (launch_err_str) 236 { 237 strncpy(err_str, launch_err_str, err_len-1); 238 err_str[err_len-1] = '\0'; // Make sure the error string is terminated 239 } 240 } 241 } 242 243 DNBLogThreadedIf(LOG_PROCESS, "(DebugNub) new pid is %d...", pid); 244 245 if (pid != INVALID_NUB_PROCESS) 246 { 247 // Spawn a thread to reap our child inferior process... 248 spawn_waitpid_thread (pid); 249 250 if (processSP->Task().TaskPortForProcessID (launch_err) == TASK_NULL) 251 { 252 // We failed to get the task for our process ID which is bad. 253 if (err_str && err_len > 0) 254 { 255 if (launch_err.AsString()) 256 { 257 ::snprintf (err_str, err_len, "failed to get the task for process %i (%s)", pid, launch_err.AsString()); 258 } 259 else 260 { 261 ::snprintf (err_str, err_len, "failed to get the task for process %i", pid); 262 } 263 } 264 } 265 else 266 { 267 assert(AddProcessToMap(pid, processSP)); 268 return pid; 269 } 270 } 271 } 272 return INVALID_NUB_PROCESS; 273} 274 275nub_process_t 276DNBProcessAttachByName (const char *name, struct timespec *timeout, char *err_str, size_t err_len) 277{ 278 if (err_str && err_len > 0) 279 err_str[0] = '\0'; 280 std::vector<struct kinfo_proc> matching_proc_infos; 281 size_t num_matching_proc_infos = GetAllInfosMatchingName(name, matching_proc_infos); 282 if (num_matching_proc_infos == 0) 283 { 284 DNBLogError ("error: no processes match '%s'\n", name); 285 return INVALID_NUB_PROCESS; 286 } 287 else if (num_matching_proc_infos > 1) 288 { 289 DNBLogError ("error: %zu processes match '%s':\n", num_matching_proc_infos, name); 290 size_t i; 291 for (i=0; i<num_matching_proc_infos; ++i) 292 DNBLogError ("%6u - %s\n", matching_proc_infos[i].kp_proc.p_pid, matching_proc_infos[i].kp_proc.p_comm); 293 return INVALID_NUB_PROCESS; 294 } 295 296 return DNBProcessAttach (matching_proc_infos[0].kp_proc.p_pid, timeout, err_str, err_len); 297} 298 299nub_process_t 300DNBProcessAttach (nub_process_t attach_pid, struct timespec *timeout, char *err_str, size_t err_len) 301{ 302 if (err_str && err_len > 0) 303 err_str[0] = '\0'; 304 305 pid_t pid = INVALID_NUB_PROCESS; 306 MachProcessSP processSP(new MachProcess); 307 if (processSP.get()) 308 { 309 DNBLogThreadedIf(LOG_PROCESS, "(DebugNub) attaching to pid %d...", attach_pid); 310 pid = processSP->AttachForDebug (attach_pid, err_str, err_len); 311 312 if (pid != INVALID_NUB_PROCESS) 313 { 314 assert(AddProcessToMap(pid, processSP)); 315 spawn_waitpid_thread(pid); 316 } 317 } 318 319 while (pid != INVALID_NUB_PROCESS) 320 { 321 // Wait for process to start up and hit entry point 322 DNBLogThreadedIf (LOG_PROCESS, 323 "%s DNBProcessWaitForEvent (%4.4x, eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged, true, INFINITE)...", 324 __FUNCTION__, 325 pid); 326 nub_event_t set_events = DNBProcessWaitForEvents (pid, 327 eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged, 328 true, 329 timeout); 330 331 DNBLogThreadedIf (LOG_PROCESS, 332 "%s DNBProcessWaitForEvent (%4.4x, eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged, true, INFINITE) => 0x%8.8x", 333 __FUNCTION__, 334 pid, 335 set_events); 336 337 if (set_events == 0) 338 { 339 if (err_str && err_len > 0) 340 snprintf(err_str, err_len, "operation timed out"); 341 pid = INVALID_NUB_PROCESS; 342 } 343 else 344 { 345 if (set_events & (eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged)) 346 { 347 nub_state_t pid_state = DNBProcessGetState (pid); 348 DNBLogThreadedIf (LOG_PROCESS, "%s process %4.4x state changed (eEventProcessStateChanged): %s", 349 __FUNCTION__, pid, DNBStateAsString(pid_state)); 350 351 switch (pid_state) 352 { 353 default: 354 case eStateInvalid: 355 case eStateUnloaded: 356 case eStateAttaching: 357 case eStateLaunching: 358 case eStateSuspended: 359 break; // Ignore 360 361 case eStateRunning: 362 case eStateStepping: 363 // Still waiting to stop at entry point... 364 break; 365 366 case eStateStopped: 367 case eStateCrashed: 368 return pid; 369 370 case eStateDetached: 371 case eStateExited: 372 if (err_str && err_len > 0) 373 snprintf(err_str, err_len, "process exited"); 374 return INVALID_NUB_PROCESS; 375 } 376 } 377 378 DNBProcessResetEvents(pid, set_events); 379 } 380 } 381 382 return INVALID_NUB_PROCESS; 383} 384 385static size_t 386GetAllInfos (std::vector<struct kinfo_proc>& proc_infos) 387{ 388 size_t size; 389 int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL }; 390 u_int namelen = sizeof(name)/sizeof(int); 391 int err; 392 393 // Try to find out how many processes are around so we can 394 // size the buffer appropriately. sysctl's man page specifically suggests 395 // this approach, and says it returns a bit larger size than needed to 396 // handle any new processes created between then and now. 397 398 err = ::sysctl (name, namelen, NULL, &size, NULL, 0); 399 400 if ((err < 0) && (err != ENOMEM)) 401 { 402 proc_infos.clear(); 403 perror("sysctl (mib, miblen, NULL, &num_processes, NULL, 0)"); 404 return 0; 405 } 406 407 408 // Increase the size of the buffer by a few processes in case more have 409 // been spawned 410 proc_infos.resize (size / sizeof(struct kinfo_proc)); 411 size = proc_infos.size() * sizeof(struct kinfo_proc); // Make sure we don't exceed our resize... 412 err = ::sysctl (name, namelen, &proc_infos[0], &size, NULL, 0); 413 if (err < 0) 414 { 415 proc_infos.clear(); 416 return 0; 417 } 418 419 // Trim down our array to fit what we actually got back 420 proc_infos.resize(size / sizeof(struct kinfo_proc)); 421 return proc_infos.size(); 422} 423 424 425static size_t 426GetAllInfosMatchingName(const char *full_process_name, std::vector<struct kinfo_proc>& matching_proc_infos) 427{ 428 429 matching_proc_infos.clear(); 430 if (full_process_name && full_process_name[0]) 431 { 432 // We only get the process name, not the full path, from the proc_info. So just take the 433 // base name of the process name... 434 const char *process_name; 435 process_name = strrchr (full_process_name, '/'); 436 if (process_name == NULL) 437 process_name = full_process_name; 438 else 439 process_name++; 440 441 std::vector<struct kinfo_proc> proc_infos; 442 const size_t num_proc_infos = GetAllInfos(proc_infos); 443 if (num_proc_infos > 0) 444 { 445 uint32_t i; 446 for (i=0; i<num_proc_infos; i++) 447 { 448 // Skip zombie processes and processes with unset status 449 if (proc_infos[i].kp_proc.p_stat == 0 || proc_infos[i].kp_proc.p_stat == SZOMB) 450 continue; 451 452 // Check for process by name. We only check the first MAXCOMLEN 453 // chars as that is all that kp_proc.p_comm holds. 454 if (::strncasecmp(proc_infos[i].kp_proc.p_comm, process_name, MAXCOMLEN) == 0) 455 { 456 // We found a matching process, add it to our list 457 matching_proc_infos.push_back(proc_infos[i]); 458 } 459 } 460 } 461 } 462 // return the newly added matches. 463 return matching_proc_infos.size(); 464} 465 466nub_process_t 467DNBProcessAttachWait (const char *waitfor_process_name, 468 nub_launch_flavor_t launch_flavor, 469 struct timespec *timeout_abstime, 470 useconds_t waitfor_interval, 471 char *err_str, 472 size_t err_len, 473 DNBShouldCancelCallback should_cancel_callback, 474 void *callback_data) 475{ 476 DNBError prepare_error; 477 std::vector<struct kinfo_proc> exclude_proc_infos; 478 size_t num_exclude_proc_infos; 479 480 // If the PrepareForAttach returns a valid token, use MachProcess to check 481 // for the process, otherwise scan the process table. 482 483 const void *attach_token = MachProcess::PrepareForAttach (waitfor_process_name, launch_flavor, true, prepare_error); 484 485 if (prepare_error.Fail()) 486 { 487 DNBLogError ("Error in PrepareForAttach: %s", prepare_error.AsString()); 488 return INVALID_NUB_PROCESS; 489 } 490 491 if (attach_token == NULL) 492 num_exclude_proc_infos = GetAllInfosMatchingName (waitfor_process_name, exclude_proc_infos); 493 494 DNBLogThreadedIf (LOG_PROCESS, "Waiting for '%s' to appear...\n", waitfor_process_name); 495 496 // Loop and try to find the process by name 497 nub_process_t waitfor_pid = INVALID_NUB_PROCESS; 498 499 while (waitfor_pid == INVALID_NUB_PROCESS) 500 { 501 if (attach_token != NULL) 502 { 503 nub_process_t pid; 504 pid = MachProcess::CheckForProcess(attach_token); 505 if (pid != INVALID_NUB_PROCESS) 506 { 507 waitfor_pid = pid; 508 break; 509 } 510 } 511 else 512 { 513 514 // Get the current process list, and check for matches that 515 // aren't in our original list. If anyone wants to attach 516 // to an existing process by name, they should do it with 517 // --attach=PROCNAME. Else we will wait for the first matching 518 // process that wasn't in our exclusion list. 519 std::vector<struct kinfo_proc> proc_infos; 520 const size_t num_proc_infos = GetAllInfosMatchingName (waitfor_process_name, proc_infos); 521 for (size_t i=0; i<num_proc_infos; i++) 522 { 523 nub_process_t curr_pid = proc_infos[i].kp_proc.p_pid; 524 for (size_t j=0; j<num_exclude_proc_infos; j++) 525 { 526 if (curr_pid == exclude_proc_infos[j].kp_proc.p_pid) 527 { 528 // This process was in our exclusion list, don't use it. 529 curr_pid = INVALID_NUB_PROCESS; 530 break; 531 } 532 } 533 534 // If we didn't find CURR_PID in our exclusion list, then use it. 535 if (curr_pid != INVALID_NUB_PROCESS) 536 { 537 // We found our process! 538 waitfor_pid = curr_pid; 539 break; 540 } 541 } 542 } 543 544 // If we haven't found our process yet, check for a timeout 545 // and then sleep for a bit until we poll again. 546 if (waitfor_pid == INVALID_NUB_PROCESS) 547 { 548 if (timeout_abstime != NULL) 549 { 550 // Check to see if we have a waitfor-duration option that 551 // has timed out? 552 if (DNBTimer::TimeOfDayLaterThan(*timeout_abstime)) 553 { 554 if (err_str && err_len > 0) 555 snprintf(err_str, err_len, "operation timed out"); 556 DNBLogError ("error: waiting for process '%s' timed out.\n", waitfor_process_name); 557 return INVALID_NUB_PROCESS; 558 } 559 } 560 561 // Call the should cancel callback as well... 562 563 if (should_cancel_callback != NULL 564 && should_cancel_callback (callback_data)) 565 { 566 DNBLogThreadedIf (LOG_PROCESS, "DNBProcessAttachWait cancelled by should_cancel callback."); 567 waitfor_pid = INVALID_NUB_PROCESS; 568 break; 569 } 570 571 ::usleep (waitfor_interval); // Sleep for WAITFOR_INTERVAL, then poll again 572 } 573 } 574 575 if (waitfor_pid != INVALID_NUB_PROCESS) 576 { 577 DNBLogThreadedIf (LOG_PROCESS, "Attaching to %s with pid %i...\n", waitfor_process_name, waitfor_pid); 578 waitfor_pid = DNBProcessAttach (waitfor_pid, timeout_abstime, err_str, err_len); 579 } 580 581 bool success = waitfor_pid != INVALID_NUB_PROCESS; 582 MachProcess::CleanupAfterAttach (attach_token, success, prepare_error); 583 584 return waitfor_pid; 585} 586 587nub_bool_t 588DNBProcessDetach (nub_process_t pid) 589{ 590 MachProcessSP procSP; 591 if (GetProcessSP (pid, procSP)) 592 { 593 return procSP->Detach(); 594 } 595 return false; 596} 597 598nub_bool_t 599DNBProcessKill (nub_process_t pid) 600{ 601 MachProcessSP procSP; 602 if (GetProcessSP (pid, procSP)) 603 { 604 return procSP->Kill (); 605 } 606 return false; 607} 608 609nub_bool_t 610DNBProcessSignal (nub_process_t pid, int signal) 611{ 612 MachProcessSP procSP; 613 if (GetProcessSP (pid, procSP)) 614 { 615 return procSP->Signal (signal); 616 } 617 return false; 618} 619 620 621nub_bool_t 622DNBProcessIsAlive (nub_process_t pid) 623{ 624 MachProcessSP procSP; 625 if (GetProcessSP (pid, procSP)) 626 { 627 return MachTask::IsValid (procSP->Task().TaskPort()); 628 } 629 return eStateInvalid; 630} 631 632//---------------------------------------------------------------------- 633// Process and Thread state information 634//---------------------------------------------------------------------- 635nub_state_t 636DNBProcessGetState (nub_process_t pid) 637{ 638 MachProcessSP procSP; 639 if (GetProcessSP (pid, procSP)) 640 { 641 return procSP->GetState(); 642 } 643 return eStateInvalid; 644} 645 646//---------------------------------------------------------------------- 647// Process and Thread state information 648//---------------------------------------------------------------------- 649nub_bool_t 650DNBProcessGetExitStatus (nub_process_t pid, int* status) 651{ 652 MachProcessSP procSP; 653 if (GetProcessSP (pid, procSP)) 654 { 655 return procSP->GetExitStatus(status); 656 } 657 return false; 658} 659 660nub_bool_t 661DNBProcessSetExitStatus (nub_process_t pid, int status) 662{ 663 MachProcessSP procSP; 664 if (GetProcessSP (pid, procSP)) 665 { 666 procSP->SetExitStatus(status); 667 return true; 668 } 669 return false; 670} 671 672 673const char * 674DNBThreadGetName (nub_process_t pid, nub_thread_t tid) 675{ 676 MachProcessSP procSP; 677 if (GetProcessSP (pid, procSP)) 678 return procSP->ThreadGetName(tid); 679 return NULL; 680} 681 682 683nub_bool_t 684DNBThreadGetIdentifierInfo (nub_process_t pid, nub_thread_t tid, thread_identifier_info_data_t *ident_info) 685{ 686 MachProcessSP procSP; 687 if (GetProcessSP (pid, procSP)) 688 return procSP->GetThreadList().GetIdentifierInfo(tid, ident_info); 689 return false; 690} 691 692nub_state_t 693DNBThreadGetState (nub_process_t pid, nub_thread_t tid) 694{ 695 MachProcessSP procSP; 696 if (GetProcessSP (pid, procSP)) 697 { 698 return procSP->ThreadGetState(tid); 699 } 700 return eStateInvalid; 701} 702 703const char * 704DNBStateAsString(nub_state_t state) 705{ 706 switch (state) 707 { 708 case eStateInvalid: return "Invalid"; 709 case eStateUnloaded: return "Unloaded"; 710 case eStateAttaching: return "Attaching"; 711 case eStateLaunching: return "Launching"; 712 case eStateStopped: return "Stopped"; 713 case eStateRunning: return "Running"; 714 case eStateStepping: return "Stepping"; 715 case eStateCrashed: return "Crashed"; 716 case eStateDetached: return "Detached"; 717 case eStateExited: return "Exited"; 718 case eStateSuspended: return "Suspended"; 719 } 720 return "nub_state_t ???"; 721} 722 723const char * 724DNBProcessGetExecutablePath (nub_process_t pid) 725{ 726 MachProcessSP procSP; 727 if (GetProcessSP (pid, procSP)) 728 { 729 return procSP->Path(); 730 } 731 return NULL; 732} 733 734nub_size_t 735DNBProcessGetArgumentCount (nub_process_t pid) 736{ 737 MachProcessSP procSP; 738 if (GetProcessSP (pid, procSP)) 739 { 740 return procSP->ArgumentCount(); 741 } 742 return 0; 743} 744 745const char * 746DNBProcessGetArgumentAtIndex (nub_process_t pid, nub_size_t idx) 747{ 748 MachProcessSP procSP; 749 if (GetProcessSP (pid, procSP)) 750 { 751 return procSP->ArgumentAtIndex (idx); 752 } 753 return NULL; 754} 755 756 757//---------------------------------------------------------------------- 758// Execution control 759//---------------------------------------------------------------------- 760nub_bool_t 761DNBProcessResume (nub_process_t pid, const DNBThreadResumeAction *actions, size_t num_actions) 762{ 763 DNBLogThreadedIf(LOG_PROCESS, "%s(pid = %4.4x)", __FUNCTION__, pid); 764 MachProcessSP procSP; 765 if (GetProcessSP (pid, procSP)) 766 { 767 DNBThreadResumeActions thread_actions (actions, num_actions); 768 769 // Below we add a default thread plan just in case one wasn't 770 // provided so all threads always know what they were supposed to do 771 if (thread_actions.IsEmpty()) 772 { 773 // No thread plans were given, so the default it to run all threads 774 thread_actions.SetDefaultThreadActionIfNeeded (eStateRunning, 0); 775 } 776 else 777 { 778 // Some thread plans were given which means anything that wasn't 779 // specified should remain stopped. 780 thread_actions.SetDefaultThreadActionIfNeeded (eStateStopped, 0); 781 } 782 return procSP->Resume (thread_actions); 783 } 784 return false; 785} 786 787nub_bool_t 788DNBProcessHalt (nub_process_t pid) 789{ 790 DNBLogThreadedIf(LOG_PROCESS, "%s(pid = %4.4x)", __FUNCTION__, pid); 791 MachProcessSP procSP; 792 if (GetProcessSP (pid, procSP)) 793 return procSP->Signal (SIGSTOP); 794 return false; 795} 796// 797//nub_bool_t 798//DNBThreadResume (nub_process_t pid, nub_thread_t tid, nub_bool_t step) 799//{ 800// DNBLogThreadedIf(LOG_THREAD, "%s(pid = %4.4x, tid = %4.4x, step = %u)", __FUNCTION__, pid, tid, (uint32_t)step); 801// MachProcessSP procSP; 802// if (GetProcessSP (pid, procSP)) 803// { 804// return procSP->Resume(tid, step, 0); 805// } 806// return false; 807//} 808// 809//nub_bool_t 810//DNBThreadResumeWithSignal (nub_process_t pid, nub_thread_t tid, nub_bool_t step, int signal) 811//{ 812// DNBLogThreadedIf(LOG_THREAD, "%s(pid = %4.4x, tid = %4.4x, step = %u, signal = %i)", __FUNCTION__, pid, tid, (uint32_t)step, signal); 813// MachProcessSP procSP; 814// if (GetProcessSP (pid, procSP)) 815// { 816// return procSP->Resume(tid, step, signal); 817// } 818// return false; 819//} 820 821nub_event_t 822DNBProcessWaitForEvents (nub_process_t pid, nub_event_t event_mask, bool wait_for_set, struct timespec* timeout) 823{ 824 nub_event_t result = 0; 825 MachProcessSP procSP; 826 if (GetProcessSP (pid, procSP)) 827 { 828 if (wait_for_set) 829 result = procSP->Events().WaitForSetEvents(event_mask, timeout); 830 else 831 result = procSP->Events().WaitForEventsToReset(event_mask, timeout); 832 } 833 return result; 834} 835 836void 837DNBProcessResetEvents (nub_process_t pid, nub_event_t event_mask) 838{ 839 MachProcessSP procSP; 840 if (GetProcessSP (pid, procSP)) 841 procSP->Events().ResetEvents(event_mask); 842} 843 844void 845DNBProcessInterruptEvents (nub_process_t pid) 846{ 847 MachProcessSP procSP; 848 if (GetProcessSP (pid, procSP)) 849 procSP->Events().SetEvents(eEventProcessAsyncInterrupt); 850} 851 852 853// Breakpoints 854nub_break_t 855DNBBreakpointSet (nub_process_t pid, nub_addr_t addr, nub_size_t size, nub_bool_t hardware) 856{ 857 MachProcessSP procSP; 858 if (GetProcessSP (pid, procSP)) 859 { 860 return procSP->CreateBreakpoint(addr, size, hardware, THREAD_NULL); 861 } 862 return INVALID_NUB_BREAK_ID; 863} 864 865nub_bool_t 866DNBBreakpointClear (nub_process_t pid, nub_break_t breakID) 867{ 868 if (NUB_BREAK_ID_IS_VALID(breakID)) 869 { 870 MachProcessSP procSP; 871 if (GetProcessSP (pid, procSP)) 872 { 873 return procSP->DisableBreakpoint(breakID, true); 874 } 875 } 876 return false; // Failed 877} 878 879nub_ssize_t 880DNBBreakpointGetHitCount (nub_process_t pid, nub_break_t breakID) 881{ 882 if (NUB_BREAK_ID_IS_VALID(breakID)) 883 { 884 MachProcessSP procSP; 885 if (GetProcessSP (pid, procSP)) 886 { 887 DNBBreakpoint *bp = procSP->Breakpoints().FindByID(breakID); 888 if (bp) 889 return bp->GetHitCount(); 890 } 891 } 892 return 0; 893} 894 895nub_ssize_t 896DNBBreakpointGetIgnoreCount (nub_process_t pid, nub_break_t breakID) 897{ 898 if (NUB_BREAK_ID_IS_VALID(breakID)) 899 { 900 MachProcessSP procSP; 901 if (GetProcessSP (pid, procSP)) 902 { 903 DNBBreakpoint *bp = procSP->Breakpoints().FindByID(breakID); 904 if (bp) 905 return bp->GetIgnoreCount(); 906 } 907 } 908 return 0; 909} 910 911nub_bool_t 912DNBBreakpointSetIgnoreCount (nub_process_t pid, nub_break_t breakID, nub_size_t ignore_count) 913{ 914 if (NUB_BREAK_ID_IS_VALID(breakID)) 915 { 916 MachProcessSP procSP; 917 if (GetProcessSP (pid, procSP)) 918 { 919 DNBBreakpoint *bp = procSP->Breakpoints().FindByID(breakID); 920 if (bp) 921 { 922 bp->SetIgnoreCount(ignore_count); 923 return true; 924 } 925 } 926 } 927 return false; 928} 929 930// Set the callback function for a given breakpoint. The callback function will 931// get called as soon as the breakpoint is hit. The function will be called 932// with the process ID, thread ID, breakpoint ID and the baton, and can return 933// 934nub_bool_t 935DNBBreakpointSetCallback (nub_process_t pid, nub_break_t breakID, DNBCallbackBreakpointHit callback, void *baton) 936{ 937 if (NUB_BREAK_ID_IS_VALID(breakID)) 938 { 939 MachProcessSP procSP; 940 if (GetProcessSP (pid, procSP)) 941 { 942 DNBBreakpoint *bp = procSP->Breakpoints().FindByID(breakID); 943 if (bp) 944 { 945 bp->SetCallback(callback, baton); 946 return true; 947 } 948 } 949 } 950 return false; 951} 952 953//---------------------------------------------------------------------- 954// Dump the breakpoints stats for process PID for a breakpoint by ID. 955//---------------------------------------------------------------------- 956void 957DNBBreakpointPrint (nub_process_t pid, nub_break_t breakID) 958{ 959 MachProcessSP procSP; 960 if (GetProcessSP (pid, procSP)) 961 procSP->DumpBreakpoint(breakID); 962} 963 964//---------------------------------------------------------------------- 965// Watchpoints 966//---------------------------------------------------------------------- 967nub_watch_t 968DNBWatchpointSet (nub_process_t pid, nub_addr_t addr, nub_size_t size, uint32_t watch_flags, nub_bool_t hardware) 969{ 970 MachProcessSP procSP; 971 if (GetProcessSP (pid, procSP)) 972 { 973 return procSP->CreateWatchpoint(addr, size, watch_flags, hardware, THREAD_NULL); 974 } 975 return INVALID_NUB_WATCH_ID; 976} 977 978nub_bool_t 979DNBWatchpointClear (nub_process_t pid, nub_watch_t watchID) 980{ 981 if (NUB_WATCH_ID_IS_VALID(watchID)) 982 { 983 MachProcessSP procSP; 984 if (GetProcessSP (pid, procSP)) 985 { 986 return procSP->DisableWatchpoint(watchID, true); 987 } 988 } 989 return false; // Failed 990} 991 992nub_ssize_t 993DNBWatchpointGetHitCount (nub_process_t pid, nub_watch_t watchID) 994{ 995 if (NUB_WATCH_ID_IS_VALID(watchID)) 996 { 997 MachProcessSP procSP; 998 if (GetProcessSP (pid, procSP)) 999 { 1000 DNBBreakpoint *bp = procSP->Watchpoints().FindByID(watchID); 1001 if (bp) 1002 return bp->GetHitCount(); 1003 } 1004 } 1005 return 0; 1006} 1007 1008nub_ssize_t 1009DNBWatchpointGetIgnoreCount (nub_process_t pid, nub_watch_t watchID) 1010{ 1011 if (NUB_WATCH_ID_IS_VALID(watchID)) 1012 { 1013 MachProcessSP procSP; 1014 if (GetProcessSP (pid, procSP)) 1015 { 1016 DNBBreakpoint *bp = procSP->Watchpoints().FindByID(watchID); 1017 if (bp) 1018 return bp->GetIgnoreCount(); 1019 } 1020 } 1021 return 0; 1022} 1023 1024nub_bool_t 1025DNBWatchpointSetIgnoreCount (nub_process_t pid, nub_watch_t watchID, nub_size_t ignore_count) 1026{ 1027 if (NUB_WATCH_ID_IS_VALID(watchID)) 1028 { 1029 MachProcessSP procSP; 1030 if (GetProcessSP (pid, procSP)) 1031 { 1032 DNBBreakpoint *bp = procSP->Watchpoints().FindByID(watchID); 1033 if (bp) 1034 { 1035 bp->SetIgnoreCount(ignore_count); 1036 return true; 1037 } 1038 } 1039 } 1040 return false; 1041} 1042 1043// Set the callback function for a given watchpoint. The callback function will 1044// get called as soon as the watchpoint is hit. The function will be called 1045// with the process ID, thread ID, watchpoint ID and the baton, and can return 1046// 1047nub_bool_t 1048DNBWatchpointSetCallback (nub_process_t pid, nub_watch_t watchID, DNBCallbackBreakpointHit callback, void *baton) 1049{ 1050 if (NUB_WATCH_ID_IS_VALID(watchID)) 1051 { 1052 MachProcessSP procSP; 1053 if (GetProcessSP (pid, procSP)) 1054 { 1055 DNBBreakpoint *bp = procSP->Watchpoints().FindByID(watchID); 1056 if (bp) 1057 { 1058 bp->SetCallback(callback, baton); 1059 return true; 1060 } 1061 } 1062 } 1063 return false; 1064} 1065 1066//---------------------------------------------------------------------- 1067// Dump the watchpoints stats for process PID for a watchpoint by ID. 1068//---------------------------------------------------------------------- 1069void 1070DNBWatchpointPrint (nub_process_t pid, nub_watch_t watchID) 1071{ 1072 MachProcessSP procSP; 1073 if (GetProcessSP (pid, procSP)) 1074 procSP->DumpWatchpoint(watchID); 1075} 1076 1077//---------------------------------------------------------------------- 1078// Read memory in the address space of process PID. This call will take 1079// care of setting and restoring permissions and breaking up the memory 1080// read into multiple chunks as required. 1081// 1082// RETURNS: number of bytes actually read 1083//---------------------------------------------------------------------- 1084nub_size_t 1085DNBProcessMemoryRead (nub_process_t pid, nub_addr_t addr, nub_size_t size, void *buf) 1086{ 1087 MachProcessSP procSP; 1088 if (GetProcessSP (pid, procSP)) 1089 return procSP->ReadMemory(addr, size, buf); 1090 return 0; 1091} 1092 1093//---------------------------------------------------------------------- 1094// Write memory to the address space of process PID. This call will take 1095// care of setting and restoring permissions and breaking up the memory 1096// write into multiple chunks as required. 1097// 1098// RETURNS: number of bytes actually written 1099//---------------------------------------------------------------------- 1100nub_size_t 1101DNBProcessMemoryWrite (nub_process_t pid, nub_addr_t addr, nub_size_t size, const void *buf) 1102{ 1103 MachProcessSP procSP; 1104 if (GetProcessSP (pid, procSP)) 1105 return procSP->WriteMemory(addr, size, buf); 1106 return 0; 1107} 1108 1109nub_addr_t 1110DNBProcessMemoryAllocate (nub_process_t pid, nub_size_t size, uint32_t permissions) 1111{ 1112 MachProcessSP procSP; 1113 if (GetProcessSP (pid, procSP)) 1114 return procSP->Task().AllocateMemory (size, permissions); 1115 return 0; 1116} 1117 1118nub_bool_t 1119DNBProcessMemoryDeallocate (nub_process_t pid, nub_addr_t addr) 1120{ 1121 MachProcessSP procSP; 1122 if (GetProcessSP (pid, procSP)) 1123 return procSP->Task().DeallocateMemory (addr); 1124 return 0; 1125} 1126 1127//---------------------------------------------------------------------- 1128// Find attributes of the memory region that contains ADDR for process PID, 1129// if possible, and return a string describing those attributes. 1130// 1131// Returns 1 if we could find attributes for this region and OUTBUF can 1132// be sent to the remote debugger. 1133// 1134// Returns 0 if we couldn't find the attributes for a region of memory at 1135// that address and OUTBUF should not be sent. 1136// 1137// Returns -1 if this platform cannot look up information about memory regions 1138// or if we do not yet have a valid launched process. 1139// 1140//---------------------------------------------------------------------- 1141int 1142DNBProcessMemoryRegionInfo (nub_process_t pid, nub_addr_t addr, DNBRegionInfo *region_info) 1143{ 1144 MachProcessSP procSP; 1145 if (GetProcessSP (pid, procSP)) 1146 return procSP->Task().GetMemoryRegionInfo (addr, region_info); 1147 1148 return -1; 1149} 1150 1151 1152//---------------------------------------------------------------------- 1153// Formatted output that uses memory and registers from process and 1154// thread in place of arguments. 1155//---------------------------------------------------------------------- 1156nub_size_t 1157DNBPrintf (nub_process_t pid, nub_thread_t tid, nub_addr_t base_addr, FILE *file, const char *format) 1158{ 1159 if (file == NULL) 1160 return 0; 1161 enum printf_flags 1162 { 1163 alternate_form = (1 << 0), 1164 zero_padding = (1 << 1), 1165 negative_field_width = (1 << 2), 1166 blank_space = (1 << 3), 1167 show_sign = (1 << 4), 1168 show_thousands_separator= (1 << 5), 1169 }; 1170 1171 enum printf_length_modifiers 1172 { 1173 length_mod_h = (1 << 0), 1174 length_mod_hh = (1 << 1), 1175 length_mod_l = (1 << 2), 1176 length_mod_ll = (1 << 3), 1177 length_mod_L = (1 << 4), 1178 length_mod_j = (1 << 5), 1179 length_mod_t = (1 << 6), 1180 length_mod_z = (1 << 7), 1181 length_mod_q = (1 << 8), 1182 }; 1183 1184 nub_addr_t addr = base_addr; 1185 char *end_format = (char*)format + strlen(format); 1186 char *end = NULL; // For strtoXXXX calls; 1187 std::basic_string<uint8_t> buf; 1188 nub_size_t total_bytes_read = 0; 1189 DNBDataRef data; 1190 const char *f; 1191 for (f = format; *f != '\0' && f < end_format; f++) 1192 { 1193 char ch = *f; 1194 switch (ch) 1195 { 1196 case '%': 1197 { 1198 f++; // Skip the '%' character 1199 int min_field_width = 0; 1200 int precision = 0; 1201 uint32_t flags = 0; 1202 uint32_t length_modifiers = 0; 1203 uint32_t byte_size = 0; 1204 uint32_t actual_byte_size = 0; 1205 bool is_string = false; 1206 bool is_register = false; 1207 DNBRegisterValue register_value; 1208 int64_t register_offset = 0; 1209 nub_addr_t register_addr = INVALID_NUB_ADDRESS; 1210 1211 // Create the format string to use for this conversion specification 1212 // so we can remove and mprintf specific flags and formatters. 1213 std::string fprintf_format("%"); 1214 1215 // Decode any flags 1216 switch (*f) 1217 { 1218 case '#': fprintf_format += *f++; flags |= alternate_form; break; 1219 case '0': fprintf_format += *f++; flags |= zero_padding; break; 1220 case '-': fprintf_format += *f++; flags |= negative_field_width; break; 1221 case ' ': fprintf_format += *f++; flags |= blank_space; break; 1222 case '+': fprintf_format += *f++; flags |= show_sign; break; 1223 case ',': fprintf_format += *f++; flags |= show_thousands_separator;break; 1224 case '{': 1225 case '[': 1226 { 1227 // We have a register name specification that can take two forms: 1228 // ${regname} or ${regname+offset} 1229 // The action is to read the register value and add the signed offset 1230 // (if any) and use that as the value to format. 1231 // $[regname] or $[regname+offset] 1232 // The action is to read the register value and add the signed offset 1233 // (if any) and use the result as an address to dereference. The size 1234 // of what is dereferenced is specified by the actual byte size that 1235 // follows the minimum field width and precision (see comments below). 1236 switch (*f) 1237 { 1238 case '{': 1239 case '[': 1240 { 1241 char open_scope_ch = *f; 1242 f++; 1243 const char *reg_name = f; 1244 size_t reg_name_length = strcspn(f, "+-}]"); 1245 if (reg_name_length > 0) 1246 { 1247 std::string register_name(reg_name, reg_name_length); 1248 f += reg_name_length; 1249 register_offset = strtoll(f, &end, 0); 1250 if (f < end) 1251 f = end; 1252 if ((open_scope_ch == '{' && *f != '}') || (open_scope_ch == '[' && *f != ']')) 1253 { 1254 fprintf(file, "error: Invalid register format string. Valid formats are %%{regname} or %%{regname+offset}, %%[regname] or %%[regname+offset]\n"); 1255 return total_bytes_read; 1256 } 1257 else 1258 { 1259 f++; 1260 if (DNBThreadGetRegisterValueByName(pid, tid, REGISTER_SET_ALL, register_name.c_str(), ®ister_value)) 1261 { 1262 // Set the address to dereference using the register value plus the offset 1263 switch (register_value.info.size) 1264 { 1265 default: 1266 case 0: 1267 fprintf (file, "error: unsupported register size of %u.\n", register_value.info.size); 1268 return total_bytes_read; 1269 1270 case 1: register_addr = register_value.value.uint8 + register_offset; break; 1271 case 2: register_addr = register_value.value.uint16 + register_offset; break; 1272 case 4: register_addr = register_value.value.uint32 + register_offset; break; 1273 case 8: register_addr = register_value.value.uint64 + register_offset; break; 1274 case 16: 1275 if (open_scope_ch == '[') 1276 { 1277 fprintf (file, "error: register size (%u) too large for address.\n", register_value.info.size); 1278 return total_bytes_read; 1279 } 1280 break; 1281 } 1282 1283 if (open_scope_ch == '{') 1284 { 1285 byte_size = register_value.info.size; 1286 is_register = true; // value is in a register 1287 1288 } 1289 else 1290 { 1291 addr = register_addr; // Use register value and offset as the address 1292 } 1293 } 1294 else 1295 { 1296 fprintf(file, "error: unable to read register '%s' for process %#.4x and thread %#.4x\n", register_name.c_str(), pid, tid); 1297 return total_bytes_read; 1298 } 1299 } 1300 } 1301 } 1302 break; 1303 1304 default: 1305 fprintf(file, "error: %%$ must be followed by (regname + n) or [regname + n]\n"); 1306 return total_bytes_read; 1307 } 1308 } 1309 break; 1310 } 1311 1312 // Check for a minimum field width 1313 if (isdigit(*f)) 1314 { 1315 min_field_width = strtoul(f, &end, 10); 1316 if (end > f) 1317 { 1318 fprintf_format.append(f, end - f); 1319 f = end; 1320 } 1321 } 1322 1323 1324 // Check for a precision 1325 if (*f == '.') 1326 { 1327 f++; 1328 if (isdigit(*f)) 1329 { 1330 fprintf_format += '.'; 1331 precision = strtoul(f, &end, 10); 1332 if (end > f) 1333 { 1334 fprintf_format.append(f, end - f); 1335 f = end; 1336 } 1337 } 1338 } 1339 1340 1341 // mprintf specific: read the optional actual byte size (abs) 1342 // after the standard minimum field width (mfw) and precision (prec). 1343 // Standard printf calls you can have "mfw.prec" or ".prec", but 1344 // mprintf can have "mfw.prec.abs", ".prec.abs" or "..abs". This is nice 1345 // for strings that may be in a fixed size buffer, but may not use all bytes 1346 // in that buffer for printable characters. 1347 if (*f == '.') 1348 { 1349 f++; 1350 actual_byte_size = strtoul(f, &end, 10); 1351 if (end > f) 1352 { 1353 byte_size = actual_byte_size; 1354 f = end; 1355 } 1356 } 1357 1358 // Decode the length modifiers 1359 switch (*f) 1360 { 1361 case 'h': // h and hh length modifiers 1362 fprintf_format += *f++; 1363 length_modifiers |= length_mod_h; 1364 if (*f == 'h') 1365 { 1366 fprintf_format += *f++; 1367 length_modifiers |= length_mod_hh; 1368 } 1369 break; 1370 1371 case 'l': // l and ll length modifiers 1372 fprintf_format += *f++; 1373 length_modifiers |= length_mod_l; 1374 if (*f == 'h') 1375 { 1376 fprintf_format += *f++; 1377 length_modifiers |= length_mod_ll; 1378 } 1379 break; 1380 1381 case 'L': fprintf_format += *f++; length_modifiers |= length_mod_L; break; 1382 case 'j': fprintf_format += *f++; length_modifiers |= length_mod_j; break; 1383 case 't': fprintf_format += *f++; length_modifiers |= length_mod_t; break; 1384 case 'z': fprintf_format += *f++; length_modifiers |= length_mod_z; break; 1385 case 'q': fprintf_format += *f++; length_modifiers |= length_mod_q; break; 1386 } 1387 1388 // Decode the conversion specifier 1389 switch (*f) 1390 { 1391 case '_': 1392 // mprintf specific format items 1393 { 1394 ++f; // Skip the '_' character 1395 switch (*f) 1396 { 1397 case 'a': // Print the current address 1398 ++f; 1399 fprintf_format += "ll"; 1400 fprintf_format += *f; // actual format to show address with folows the 'a' ("%_ax") 1401 fprintf (file, fprintf_format.c_str(), addr); 1402 break; 1403 case 'o': // offset from base address 1404 ++f; 1405 fprintf_format += "ll"; 1406 fprintf_format += *f; // actual format to show address with folows the 'a' ("%_ox") 1407 fprintf(file, fprintf_format.c_str(), addr - base_addr); 1408 break; 1409 default: 1410 fprintf (file, "error: unsupported mprintf specific format character '%c'.\n", *f); 1411 break; 1412 } 1413 continue; 1414 } 1415 break; 1416 1417 case 'D': 1418 case 'O': 1419 case 'U': 1420 fprintf_format += *f; 1421 if (byte_size == 0) 1422 byte_size = sizeof(long int); 1423 break; 1424 1425 case 'd': 1426 case 'i': 1427 case 'o': 1428 case 'u': 1429 case 'x': 1430 case 'X': 1431 fprintf_format += *f; 1432 if (byte_size == 0) 1433 { 1434 if (length_modifiers & length_mod_hh) 1435 byte_size = sizeof(char); 1436 else if (length_modifiers & length_mod_h) 1437 byte_size = sizeof(short); 1438 if (length_modifiers & length_mod_ll) 1439 byte_size = sizeof(long long); 1440 else if (length_modifiers & length_mod_l) 1441 byte_size = sizeof(long); 1442 else 1443 byte_size = sizeof(int); 1444 } 1445 break; 1446 1447 case 'a': 1448 case 'A': 1449 case 'f': 1450 case 'F': 1451 case 'e': 1452 case 'E': 1453 case 'g': 1454 case 'G': 1455 fprintf_format += *f; 1456 if (byte_size == 0) 1457 { 1458 if (length_modifiers & length_mod_L) 1459 byte_size = sizeof(long double); 1460 else 1461 byte_size = sizeof(double); 1462 } 1463 break; 1464 1465 case 'c': 1466 if ((length_modifiers & length_mod_l) == 0) 1467 { 1468 fprintf_format += *f; 1469 if (byte_size == 0) 1470 byte_size = sizeof(char); 1471 break; 1472 } 1473 // Fall through to 'C' modifier below... 1474 1475 case 'C': 1476 fprintf_format += *f; 1477 if (byte_size == 0) 1478 byte_size = sizeof(wchar_t); 1479 break; 1480 1481 case 's': 1482 fprintf_format += *f; 1483 if (is_register || byte_size == 0) 1484 is_string = 1; 1485 break; 1486 1487 case 'p': 1488 fprintf_format += *f; 1489 if (byte_size == 0) 1490 byte_size = sizeof(void*); 1491 break; 1492 } 1493 1494 if (is_string) 1495 { 1496 std::string mem_string; 1497 const size_t string_buf_len = 4; 1498 char string_buf[string_buf_len+1]; 1499 char *string_buf_end = string_buf + string_buf_len; 1500 string_buf[string_buf_len] = '\0'; 1501 nub_size_t bytes_read; 1502 nub_addr_t str_addr = is_register ? register_addr : addr; 1503 while ((bytes_read = DNBProcessMemoryRead(pid, str_addr, string_buf_len, &string_buf[0])) > 0) 1504 { 1505 // Did we get a NULL termination character yet? 1506 if (strchr(string_buf, '\0') == string_buf_end) 1507 { 1508 // no NULL terminator yet, append as a std::string 1509 mem_string.append(string_buf, string_buf_len); 1510 str_addr += string_buf_len; 1511 } 1512 else 1513 { 1514 // yep 1515 break; 1516 } 1517 } 1518 // Append as a C-string so we don't get the extra NULL 1519 // characters in the temp buffer (since it was resized) 1520 mem_string += string_buf; 1521 size_t mem_string_len = mem_string.size() + 1; 1522 fprintf(file, fprintf_format.c_str(), mem_string.c_str()); 1523 if (mem_string_len > 0) 1524 { 1525 if (!is_register) 1526 { 1527 addr += mem_string_len; 1528 total_bytes_read += mem_string_len; 1529 } 1530 } 1531 else 1532 return total_bytes_read; 1533 } 1534 else 1535 if (byte_size > 0) 1536 { 1537 buf.resize(byte_size); 1538 nub_size_t bytes_read = 0; 1539 if (is_register) 1540 bytes_read = register_value.info.size; 1541 else 1542 bytes_read = DNBProcessMemoryRead(pid, addr, buf.size(), &buf[0]); 1543 if (bytes_read > 0) 1544 { 1545 if (!is_register) 1546 total_bytes_read += bytes_read; 1547 1548 if (bytes_read == byte_size) 1549 { 1550 switch (*f) 1551 { 1552 case 'd': 1553 case 'i': 1554 case 'o': 1555 case 'u': 1556 case 'X': 1557 case 'x': 1558 case 'a': 1559 case 'A': 1560 case 'f': 1561 case 'F': 1562 case 'e': 1563 case 'E': 1564 case 'g': 1565 case 'G': 1566 case 'p': 1567 case 'c': 1568 case 'C': 1569 { 1570 if (is_register) 1571 data.SetData(®ister_value.value.v_uint8[0], register_value.info.size); 1572 else 1573 data.SetData(&buf[0], bytes_read); 1574 DNBDataRef::offset_t data_offset = 0; 1575 if (byte_size <= 4) 1576 { 1577 uint32_t u32 = data.GetMax32(&data_offset, byte_size); 1578 // Show the actual byte width when displaying hex 1579 fprintf(file, fprintf_format.c_str(), u32); 1580 } 1581 else if (byte_size <= 8) 1582 { 1583 uint64_t u64 = data.GetMax64(&data_offset, byte_size); 1584 // Show the actual byte width when displaying hex 1585 fprintf(file, fprintf_format.c_str(), u64); 1586 } 1587 else 1588 { 1589 fprintf(file, "error: integer size not supported, must be 8 bytes or less (%u bytes).\n", byte_size); 1590 } 1591 if (!is_register) 1592 addr += byte_size; 1593 } 1594 break; 1595 1596 case 's': 1597 fprintf(file, fprintf_format.c_str(), buf.c_str()); 1598 addr += byte_size; 1599 break; 1600 1601 default: 1602 fprintf(file, "error: unsupported conversion specifier '%c'.\n", *f); 1603 break; 1604 } 1605 } 1606 } 1607 } 1608 else 1609 return total_bytes_read; 1610 } 1611 break; 1612 1613 case '\\': 1614 { 1615 f++; 1616 switch (*f) 1617 { 1618 case 'e': ch = '\e'; break; 1619 case 'a': ch = '\a'; break; 1620 case 'b': ch = '\b'; break; 1621 case 'f': ch = '\f'; break; 1622 case 'n': ch = '\n'; break; 1623 case 'r': ch = '\r'; break; 1624 case 't': ch = '\t'; break; 1625 case 'v': ch = '\v'; break; 1626 case '\'': ch = '\''; break; 1627 case '\\': ch = '\\'; break; 1628 case '0': 1629 case '1': 1630 case '2': 1631 case '3': 1632 case '4': 1633 case '5': 1634 case '6': 1635 case '7': 1636 ch = strtoul(f, &end, 8); 1637 f = end; 1638 break; 1639 default: 1640 ch = *f; 1641 break; 1642 } 1643 fputc(ch, file); 1644 } 1645 break; 1646 1647 default: 1648 fputc(ch, file); 1649 break; 1650 } 1651 } 1652 return total_bytes_read; 1653} 1654 1655 1656//---------------------------------------------------------------------- 1657// Get the number of threads for the specified process. 1658//---------------------------------------------------------------------- 1659nub_size_t 1660DNBProcessGetNumThreads (nub_process_t pid) 1661{ 1662 MachProcessSP procSP; 1663 if (GetProcessSP (pid, procSP)) 1664 return procSP->GetNumThreads(); 1665 return 0; 1666} 1667 1668//---------------------------------------------------------------------- 1669// Get the thread ID of the current thread. 1670//---------------------------------------------------------------------- 1671nub_thread_t 1672DNBProcessGetCurrentThread (nub_process_t pid) 1673{ 1674 MachProcessSP procSP; 1675 if (GetProcessSP (pid, procSP)) 1676 return procSP->GetCurrentThread(); 1677 return 0; 1678} 1679 1680//---------------------------------------------------------------------- 1681// Change the current thread. 1682//---------------------------------------------------------------------- 1683nub_thread_t 1684DNBProcessSetCurrentThread (nub_process_t pid, nub_thread_t tid) 1685{ 1686 MachProcessSP procSP; 1687 if (GetProcessSP (pid, procSP)) 1688 return procSP->SetCurrentThread (tid); 1689 return INVALID_NUB_THREAD; 1690} 1691 1692 1693//---------------------------------------------------------------------- 1694// Dump a string describing a thread's stop reason to the specified file 1695// handle 1696//---------------------------------------------------------------------- 1697nub_bool_t 1698DNBThreadGetStopReason (nub_process_t pid, nub_thread_t tid, struct DNBThreadStopInfo *stop_info) 1699{ 1700 MachProcessSP procSP; 1701 if (GetProcessSP (pid, procSP)) 1702 return procSP->GetThreadStoppedReason (tid, stop_info); 1703 return false; 1704} 1705 1706//---------------------------------------------------------------------- 1707// Return string description for the specified thread. 1708// 1709// RETURNS: NULL if the thread isn't valid, else a NULL terminated C 1710// string from a static buffer that must be copied prior to subsequent 1711// calls. 1712//---------------------------------------------------------------------- 1713const char * 1714DNBThreadGetInfo (nub_process_t pid, nub_thread_t tid) 1715{ 1716 MachProcessSP procSP; 1717 if (GetProcessSP (pid, procSP)) 1718 return procSP->GetThreadInfo (tid); 1719 return NULL; 1720} 1721 1722//---------------------------------------------------------------------- 1723// Get the thread ID given a thread index. 1724//---------------------------------------------------------------------- 1725nub_thread_t 1726DNBProcessGetThreadAtIndex (nub_process_t pid, size_t thread_idx) 1727{ 1728 MachProcessSP procSP; 1729 if (GetProcessSP (pid, procSP)) 1730 return procSP->GetThreadAtIndex (thread_idx); 1731 return INVALID_NUB_THREAD; 1732} 1733 1734nub_addr_t 1735DNBProcessGetSharedLibraryInfoAddress (nub_process_t pid) 1736{ 1737 MachProcessSP procSP; 1738 DNBError err; 1739 if (GetProcessSP (pid, procSP)) 1740 return procSP->Task().GetDYLDAllImageInfosAddress (err); 1741 return INVALID_NUB_ADDRESS; 1742} 1743 1744 1745nub_bool_t 1746DNBProcessSharedLibrariesUpdated(nub_process_t pid) 1747{ 1748 MachProcessSP procSP; 1749 if (GetProcessSP (pid, procSP)) 1750 { 1751 procSP->SharedLibrariesUpdated (); 1752 return true; 1753 } 1754 return false; 1755} 1756 1757//---------------------------------------------------------------------- 1758// Get the current shared library information for a process. Only return 1759// the shared libraries that have changed since the last shared library 1760// state changed event if only_changed is non-zero. 1761//---------------------------------------------------------------------- 1762nub_size_t 1763DNBProcessGetSharedLibraryInfo (nub_process_t pid, nub_bool_t only_changed, struct DNBExecutableImageInfo **image_infos) 1764{ 1765 MachProcessSP procSP; 1766 if (GetProcessSP (pid, procSP)) 1767 return procSP->CopyImageInfos (image_infos, only_changed); 1768 1769 // If we have no process, then return NULL for the shared library info 1770 // and zero for shared library count 1771 *image_infos = NULL; 1772 return 0; 1773} 1774 1775//---------------------------------------------------------------------- 1776// Get the register set information for a specific thread. 1777//---------------------------------------------------------------------- 1778const DNBRegisterSetInfo * 1779DNBGetRegisterSetInfo (nub_size_t *num_reg_sets) 1780{ 1781 return DNBArchProtocol::GetRegisterSetInfo (num_reg_sets); 1782} 1783 1784 1785//---------------------------------------------------------------------- 1786// Read a register value by register set and register index. 1787//---------------------------------------------------------------------- 1788nub_bool_t 1789DNBThreadGetRegisterValueByID (nub_process_t pid, nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *value) 1790{ 1791 MachProcessSP procSP; 1792 ::bzero (value, sizeof(DNBRegisterValue)); 1793 if (GetProcessSP (pid, procSP)) 1794 { 1795 if (tid != INVALID_NUB_THREAD) 1796 return procSP->GetRegisterValue (tid, set, reg, value); 1797 } 1798 return false; 1799} 1800 1801nub_bool_t 1802DNBThreadSetRegisterValueByID (nub_process_t pid, nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value) 1803{ 1804 if (tid != INVALID_NUB_THREAD) 1805 { 1806 MachProcessSP procSP; 1807 if (GetProcessSP (pid, procSP)) 1808 return procSP->SetRegisterValue (tid, set, reg, value); 1809 } 1810 return false; 1811} 1812 1813nub_size_t 1814DNBThreadGetRegisterContext (nub_process_t pid, nub_thread_t tid, void *buf, size_t buf_len) 1815{ 1816 MachProcessSP procSP; 1817 if (GetProcessSP (pid, procSP)) 1818 { 1819 if (tid != INVALID_NUB_THREAD) 1820 return procSP->GetThreadList().GetRegisterContext (tid, buf, buf_len); 1821 } 1822 ::bzero (buf, buf_len); 1823 return 0; 1824 1825} 1826 1827nub_size_t 1828DNBThreadSetRegisterContext (nub_process_t pid, nub_thread_t tid, const void *buf, size_t buf_len) 1829{ 1830 MachProcessSP procSP; 1831 if (GetProcessSP (pid, procSP)) 1832 { 1833 if (tid != INVALID_NUB_THREAD) 1834 return procSP->GetThreadList().SetRegisterContext (tid, buf, buf_len); 1835 } 1836 return 0; 1837} 1838 1839//---------------------------------------------------------------------- 1840// Read a register value by name. 1841//---------------------------------------------------------------------- 1842nub_bool_t 1843DNBThreadGetRegisterValueByName (nub_process_t pid, nub_thread_t tid, uint32_t reg_set, const char *reg_name, DNBRegisterValue *value) 1844{ 1845 MachProcessSP procSP; 1846 ::bzero (value, sizeof(DNBRegisterValue)); 1847 if (GetProcessSP (pid, procSP)) 1848 { 1849 const struct DNBRegisterSetInfo *set_info; 1850 nub_size_t num_reg_sets = 0; 1851 set_info = DNBGetRegisterSetInfo (&num_reg_sets); 1852 if (set_info) 1853 { 1854 uint32_t set = reg_set; 1855 uint32_t reg; 1856 if (set == REGISTER_SET_ALL) 1857 { 1858 for (set = 1; set < num_reg_sets; ++set) 1859 { 1860 for (reg = 0; reg < set_info[set].num_registers; ++reg) 1861 { 1862 if (strcasecmp(reg_name, set_info[set].registers[reg].name) == 0) 1863 return procSP->GetRegisterValue (tid, set, reg, value); 1864 } 1865 } 1866 } 1867 else 1868 { 1869 for (reg = 0; reg < set_info[set].num_registers; ++reg) 1870 { 1871 if (strcasecmp(reg_name, set_info[set].registers[reg].name) == 0) 1872 return procSP->GetRegisterValue (tid, set, reg, value); 1873 } 1874 } 1875 } 1876 } 1877 return false; 1878} 1879 1880 1881//---------------------------------------------------------------------- 1882// Read a register set and register number from the register name. 1883//---------------------------------------------------------------------- 1884nub_bool_t 1885DNBGetRegisterInfoByName (const char *reg_name, DNBRegisterInfo* info) 1886{ 1887 const struct DNBRegisterSetInfo *set_info; 1888 nub_size_t num_reg_sets = 0; 1889 set_info = DNBGetRegisterSetInfo (&num_reg_sets); 1890 if (set_info) 1891 { 1892 uint32_t set, reg; 1893 for (set = 1; set < num_reg_sets; ++set) 1894 { 1895 for (reg = 0; reg < set_info[set].num_registers; ++reg) 1896 { 1897 if (strcasecmp(reg_name, set_info[set].registers[reg].name) == 0) 1898 { 1899 *info = set_info[set].registers[reg]; 1900 return true; 1901 } 1902 } 1903 } 1904 1905 for (set = 1; set < num_reg_sets; ++set) 1906 { 1907 uint32_t reg; 1908 for (reg = 0; reg < set_info[set].num_registers; ++reg) 1909 { 1910 if (set_info[set].registers[reg].alt == NULL) 1911 continue; 1912 1913 if (strcasecmp(reg_name, set_info[set].registers[reg].alt) == 0) 1914 { 1915 *info = set_info[set].registers[reg]; 1916 return true; 1917 } 1918 } 1919 } 1920 } 1921 1922 ::bzero (info, sizeof(DNBRegisterInfo)); 1923 return false; 1924} 1925 1926 1927//---------------------------------------------------------------------- 1928// Set the name to address callback function that this nub can use 1929// for any name to address lookups that are needed. 1930//---------------------------------------------------------------------- 1931nub_bool_t 1932DNBProcessSetNameToAddressCallback (nub_process_t pid, DNBCallbackNameToAddress callback, void *baton) 1933{ 1934 MachProcessSP procSP; 1935 if (GetProcessSP (pid, procSP)) 1936 { 1937 procSP->SetNameToAddressCallback (callback, baton); 1938 return true; 1939 } 1940 return false; 1941} 1942 1943 1944//---------------------------------------------------------------------- 1945// Set the name to address callback function that this nub can use 1946// for any name to address lookups that are needed. 1947//---------------------------------------------------------------------- 1948nub_bool_t 1949DNBProcessSetSharedLibraryInfoCallback (nub_process_t pid, DNBCallbackCopyExecutableImageInfos callback, void *baton) 1950{ 1951 MachProcessSP procSP; 1952 if (GetProcessSP (pid, procSP)) 1953 { 1954 procSP->SetSharedLibraryInfoCallback (callback, baton); 1955 return true; 1956 } 1957 return false; 1958} 1959 1960nub_addr_t 1961DNBProcessLookupAddress (nub_process_t pid, const char *name, const char *shlib) 1962{ 1963 MachProcessSP procSP; 1964 if (GetProcessSP (pid, procSP)) 1965 { 1966 return procSP->LookupSymbol (name, shlib); 1967 } 1968 return INVALID_NUB_ADDRESS; 1969} 1970 1971 1972nub_size_t 1973DNBProcessGetAvailableSTDOUT (nub_process_t pid, char *buf, nub_size_t buf_size) 1974{ 1975 MachProcessSP procSP; 1976 if (GetProcessSP (pid, procSP)) 1977 return procSP->GetAvailableSTDOUT (buf, buf_size); 1978 return 0; 1979} 1980 1981nub_size_t 1982DNBProcessGetAvailableSTDERR (nub_process_t pid, char *buf, nub_size_t buf_size) 1983{ 1984 MachProcessSP procSP; 1985 if (GetProcessSP (pid, procSP)) 1986 return procSP->GetAvailableSTDERR (buf, buf_size); 1987 return 0; 1988} 1989 1990nub_size_t 1991DNBProcessGetStopCount (nub_process_t pid) 1992{ 1993 MachProcessSP procSP; 1994 if (GetProcessSP (pid, procSP)) 1995 return procSP->StopCount(); 1996 return 0; 1997} 1998 1999uint32_t 2000DNBProcessGetCPUType (nub_process_t pid) 2001{ 2002 MachProcessSP procSP; 2003 if (GetProcessSP (pid, procSP)) 2004 return procSP->GetCPUType (); 2005 return 0; 2006 2007} 2008 2009nub_bool_t 2010DNBResolveExecutablePath (const char *path, char *resolved_path, size_t resolved_path_size) 2011{ 2012 if (path == NULL || path[0] == '\0') 2013 return false; 2014 2015 char max_path[PATH_MAX]; 2016 std::string result; 2017 CFString::GlobPath(path, result); 2018 2019 if (result.empty()) 2020 result = path; 2021 2022 if (realpath(path, max_path)) 2023 { 2024 // Found the path relatively... 2025 ::strncpy(resolved_path, max_path, resolved_path_size); 2026 return strlen(resolved_path) + 1 < resolved_path_size; 2027 } 2028 else 2029 { 2030 // Not a relative path, check the PATH environment variable if the 2031 const char *PATH = getenv("PATH"); 2032 if (PATH) 2033 { 2034 const char *curr_path_start = PATH; 2035 const char *curr_path_end; 2036 while (curr_path_start && *curr_path_start) 2037 { 2038 curr_path_end = strchr(curr_path_start, ':'); 2039 if (curr_path_end == NULL) 2040 { 2041 result.assign(curr_path_start); 2042 curr_path_start = NULL; 2043 } 2044 else if (curr_path_end > curr_path_start) 2045 { 2046 size_t len = curr_path_end - curr_path_start; 2047 result.assign(curr_path_start, len); 2048 curr_path_start += len + 1; 2049 } 2050 else 2051 break; 2052 2053 result += '/'; 2054 result += path; 2055 struct stat s; 2056 if (stat(result.c_str(), &s) == 0) 2057 { 2058 ::strncpy(resolved_path, result.c_str(), resolved_path_size); 2059 return result.size() + 1 < resolved_path_size; 2060 } 2061 } 2062 } 2063 } 2064 return false; 2065} 2066 2067 2068void 2069DNBInitialize() 2070{ 2071 DNBLogThreadedIf (LOG_PROCESS, "DNBInitialize ()"); 2072#if defined (__i386__) || defined (__x86_64__) 2073 DNBArchImplI386::Initialize(); 2074 DNBArchImplX86_64::Initialize(); 2075#elif defined (__arm__) 2076 DNBArchMachARM::Initialize(); 2077#endif 2078} 2079 2080void 2081DNBTerminate() 2082{ 2083} 2084 2085nub_bool_t 2086DNBSetArchitecture (const char *arch) 2087{ 2088 if (arch && arch[0]) 2089 { 2090 if (strcasecmp (arch, "i386") == 0) 2091 return DNBArchProtocol::SetArchitecture (CPU_TYPE_I386); 2092 else if (strcasecmp (arch, "x86_64") == 0) 2093 return DNBArchProtocol::SetArchitecture (CPU_TYPE_X86_64); 2094 else if (strstr (arch, "arm") == arch) 2095 return DNBArchProtocol::SetArchitecture (CPU_TYPE_ARM); 2096 } 2097 return false; 2098} 2099