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