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