1 //===-- CommandObjectProcess.cpp ------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "CommandObjectProcess.h" 10 #include "lldb/Breakpoint/Breakpoint.h" 11 #include "lldb/Breakpoint/BreakpointLocation.h" 12 #include "lldb/Breakpoint/BreakpointSite.h" 13 #include "lldb/Core/Module.h" 14 #include "lldb/Core/PluginManager.h" 15 #include "lldb/Host/OptionParser.h" 16 #include "lldb/Interpreter/CommandInterpreter.h" 17 #include "lldb/Interpreter/CommandReturnObject.h" 18 #include "lldb/Interpreter/OptionArgParser.h" 19 #include "lldb/Interpreter/Options.h" 20 #include "lldb/Target/Platform.h" 21 #include "lldb/Target/Process.h" 22 #include "lldb/Target/StopInfo.h" 23 #include "lldb/Target/Target.h" 24 #include "lldb/Target/Thread.h" 25 #include "lldb/Target/UnixSignals.h" 26 #include "lldb/Utility/Args.h" 27 #include "lldb/Utility/State.h" 28 29 using namespace lldb; 30 using namespace lldb_private; 31 32 class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed { 33 public: 34 CommandObjectProcessLaunchOrAttach(CommandInterpreter &interpreter, 35 const char *name, const char *help, 36 const char *syntax, uint32_t flags, 37 const char *new_process_action) 38 : CommandObjectParsed(interpreter, name, help, syntax, flags), 39 m_new_process_action(new_process_action) {} 40 41 ~CommandObjectProcessLaunchOrAttach() override = default; 42 43 protected: 44 bool StopProcessIfNecessary(Process *process, StateType &state, 45 CommandReturnObject &result) { 46 state = eStateInvalid; 47 if (process) { 48 state = process->GetState(); 49 50 if (process->IsAlive() && state != eStateConnected) { 51 char message[1024]; 52 if (process->GetState() == eStateAttaching) 53 ::snprintf(message, sizeof(message), 54 "There is a pending attach, abort it and %s?", 55 m_new_process_action.c_str()); 56 else if (process->GetShouldDetach()) 57 ::snprintf(message, sizeof(message), 58 "There is a running process, detach from it and %s?", 59 m_new_process_action.c_str()); 60 else 61 ::snprintf(message, sizeof(message), 62 "There is a running process, kill it and %s?", 63 m_new_process_action.c_str()); 64 65 if (!m_interpreter.Confirm(message, true)) { 66 result.SetStatus(eReturnStatusFailed); 67 return false; 68 } else { 69 if (process->GetShouldDetach()) { 70 bool keep_stopped = false; 71 Status detach_error(process->Detach(keep_stopped)); 72 if (detach_error.Success()) { 73 result.SetStatus(eReturnStatusSuccessFinishResult); 74 process = nullptr; 75 } else { 76 result.AppendErrorWithFormat( 77 "Failed to detach from process: %s\n", 78 detach_error.AsCString()); 79 result.SetStatus(eReturnStatusFailed); 80 } 81 } else { 82 Status destroy_error(process->Destroy(false)); 83 if (destroy_error.Success()) { 84 result.SetStatus(eReturnStatusSuccessFinishResult); 85 process = nullptr; 86 } else { 87 result.AppendErrorWithFormat("Failed to kill process: %s\n", 88 destroy_error.AsCString()); 89 result.SetStatus(eReturnStatusFailed); 90 } 91 } 92 } 93 } 94 } 95 return result.Succeeded(); 96 } 97 98 std::string m_new_process_action; 99 }; 100 101 // CommandObjectProcessLaunch 102 #pragma mark CommandObjectProcessLaunch 103 class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach { 104 public: 105 CommandObjectProcessLaunch(CommandInterpreter &interpreter) 106 : CommandObjectProcessLaunchOrAttach( 107 interpreter, "process launch", 108 "Launch the executable in the debugger.", nullptr, 109 eCommandRequiresTarget, "restart"), 110 m_options() { 111 CommandArgumentEntry arg; 112 CommandArgumentData run_args_arg; 113 114 // Define the first (and only) variant of this arg. 115 run_args_arg.arg_type = eArgTypeRunArgs; 116 run_args_arg.arg_repetition = eArgRepeatOptional; 117 118 // There is only one variant this argument could be; put it into the 119 // argument entry. 120 arg.push_back(run_args_arg); 121 122 // Push the data for the first argument into the m_arguments vector. 123 m_arguments.push_back(arg); 124 } 125 126 ~CommandObjectProcessLaunch() override = default; 127 128 void 129 HandleArgumentCompletion(CompletionRequest &request, 130 OptionElementVector &opt_element_vector) override { 131 132 CommandCompletions::InvokeCommonCompletionCallbacks( 133 GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion, 134 request, nullptr); 135 } 136 137 Options *GetOptions() override { return &m_options; } 138 139 const char *GetRepeatCommand(Args ¤t_command_args, 140 uint32_t index) override { 141 // No repeat for "process launch"... 142 return ""; 143 } 144 145 protected: 146 bool DoExecute(Args &launch_args, CommandReturnObject &result) override { 147 Debugger &debugger = GetDebugger(); 148 Target *target = debugger.GetSelectedTarget().get(); 149 // If our listener is nullptr, users aren't allows to launch 150 ModuleSP exe_module_sp = target->GetExecutableModule(); 151 152 if (exe_module_sp == nullptr) { 153 result.AppendError("no file in target, create a debug target using the " 154 "'target create' command"); 155 result.SetStatus(eReturnStatusFailed); 156 return false; 157 } 158 159 StateType state = eStateInvalid; 160 161 if (!StopProcessIfNecessary(m_exe_ctx.GetProcessPtr(), state, result)) 162 return false; 163 164 llvm::StringRef target_settings_argv0 = target->GetArg0(); 165 166 // Determine whether we will disable ASLR or leave it in the default state 167 // (i.e. enabled if the platform supports it). First check if the process 168 // launch options explicitly turn on/off 169 // disabling ASLR. If so, use that setting; 170 // otherwise, use the 'settings target.disable-aslr' setting. 171 bool disable_aslr = false; 172 if (m_options.disable_aslr != eLazyBoolCalculate) { 173 // The user specified an explicit setting on the process launch line. 174 // Use it. 175 disable_aslr = (m_options.disable_aslr == eLazyBoolYes); 176 } else { 177 // The user did not explicitly specify whether to disable ASLR. Fall 178 // back to the target.disable-aslr setting. 179 disable_aslr = target->GetDisableASLR(); 180 } 181 182 if (disable_aslr) 183 m_options.launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 184 else 185 m_options.launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 186 187 if (target->GetDetachOnError()) 188 m_options.launch_info.GetFlags().Set(eLaunchFlagDetachOnError); 189 190 if (target->GetDisableSTDIO()) 191 m_options.launch_info.GetFlags().Set(eLaunchFlagDisableSTDIO); 192 193 // Merge the launch info environment with the target environment. 194 Environment target_env = target->GetEnvironment(); 195 m_options.launch_info.GetEnvironment().insert(target_env.begin(), 196 target_env.end()); 197 198 if (!target_settings_argv0.empty()) { 199 m_options.launch_info.GetArguments().AppendArgument( 200 target_settings_argv0); 201 m_options.launch_info.SetExecutableFile( 202 exe_module_sp->GetPlatformFileSpec(), false); 203 } else { 204 m_options.launch_info.SetExecutableFile( 205 exe_module_sp->GetPlatformFileSpec(), true); 206 } 207 208 if (launch_args.GetArgumentCount() == 0) { 209 m_options.launch_info.GetArguments().AppendArguments( 210 target->GetProcessLaunchInfo().GetArguments()); 211 } else { 212 m_options.launch_info.GetArguments().AppendArguments(launch_args); 213 // Save the arguments for subsequent runs in the current target. 214 target->SetRunArguments(launch_args); 215 } 216 217 StreamString stream; 218 Status error = target->Launch(m_options.launch_info, &stream); 219 220 if (error.Success()) { 221 ProcessSP process_sp(target->GetProcessSP()); 222 if (process_sp) { 223 // There is a race condition where this thread will return up the call 224 // stack to the main command handler and show an (lldb) prompt before 225 // HandlePrivateEvent (from PrivateStateThread) has a chance to call 226 // PushProcessIOHandler(). 227 process_sp->SyncIOHandler(0, std::chrono::seconds(2)); 228 229 llvm::StringRef data = stream.GetString(); 230 if (!data.empty()) 231 result.AppendMessage(data); 232 const char *archname = 233 exe_module_sp->GetArchitecture().GetArchitectureName(); 234 result.AppendMessageWithFormat( 235 "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(), 236 exe_module_sp->GetFileSpec().GetPath().c_str(), archname); 237 result.SetStatus(eReturnStatusSuccessFinishResult); 238 result.SetDidChangeProcessState(true); 239 } else { 240 result.AppendError( 241 "no error returned from Target::Launch, and target has no process"); 242 result.SetStatus(eReturnStatusFailed); 243 } 244 } else { 245 result.AppendError(error.AsCString()); 246 result.SetStatus(eReturnStatusFailed); 247 } 248 return result.Succeeded(); 249 } 250 251 ProcessLaunchCommandOptions m_options; 252 }; 253 254 #define LLDB_OPTIONS_process_attach 255 #include "CommandOptions.inc" 256 257 #pragma mark CommandObjectProcessAttach 258 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach { 259 public: 260 class CommandOptions : public Options { 261 public: 262 CommandOptions() : Options() { 263 // Keep default values of all options in one place: OptionParsingStarting 264 // () 265 OptionParsingStarting(nullptr); 266 } 267 268 ~CommandOptions() override = default; 269 270 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 271 ExecutionContext *execution_context) override { 272 Status error; 273 const int short_option = m_getopt_table[option_idx].val; 274 switch (short_option) { 275 case 'c': 276 attach_info.SetContinueOnceAttached(true); 277 break; 278 279 case 'p': { 280 lldb::pid_t pid; 281 if (option_arg.getAsInteger(0, pid)) { 282 error.SetErrorStringWithFormat("invalid process ID '%s'", 283 option_arg.str().c_str()); 284 } else { 285 attach_info.SetProcessID(pid); 286 } 287 } break; 288 289 case 'P': 290 attach_info.SetProcessPluginName(option_arg); 291 break; 292 293 case 'n': 294 attach_info.GetExecutableFile().SetFile(option_arg, 295 FileSpec::Style::native); 296 break; 297 298 case 'w': 299 attach_info.SetWaitForLaunch(true); 300 break; 301 302 case 'i': 303 attach_info.SetIgnoreExisting(false); 304 break; 305 306 default: 307 llvm_unreachable("Unimplemented option"); 308 } 309 return error; 310 } 311 312 void OptionParsingStarting(ExecutionContext *execution_context) override { 313 attach_info.Clear(); 314 } 315 316 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 317 return llvm::makeArrayRef(g_process_attach_options); 318 } 319 320 void HandleOptionArgumentCompletion( 321 CompletionRequest &request, OptionElementVector &opt_element_vector, 322 int opt_element_index, CommandInterpreter &interpreter) override { 323 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; 324 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; 325 326 switch (GetDefinitions()[opt_defs_index].short_option) { 327 case 'n': { 328 // Look to see if there is a -P argument provided, and if so use that 329 // plugin, otherwise use the default plugin. 330 331 const char *partial_name = nullptr; 332 partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos); 333 334 PlatformSP platform_sp(interpreter.GetPlatform(true)); 335 if (!platform_sp) 336 return; 337 ProcessInstanceInfoList process_infos; 338 ProcessInstanceInfoMatch match_info; 339 if (partial_name) { 340 match_info.GetProcessInfo().GetExecutableFile().SetFile( 341 partial_name, FileSpec::Style::native); 342 match_info.SetNameMatchType(NameMatch::StartsWith); 343 } 344 platform_sp->FindProcesses(match_info, process_infos); 345 const size_t num_matches = process_infos.size(); 346 if (num_matches == 0) 347 return; 348 for (size_t i = 0; i < num_matches; ++i) { 349 request.AddCompletion(process_infos[i].GetNameAsStringRef()); 350 } 351 } break; 352 353 case 'P': 354 CommandCompletions::InvokeCommonCompletionCallbacks( 355 interpreter, CommandCompletions::eProcessPluginCompletion, request, 356 nullptr); 357 break; 358 } 359 } 360 361 // Instance variables to hold the values for command options. 362 363 ProcessAttachInfo attach_info; 364 }; 365 366 CommandObjectProcessAttach(CommandInterpreter &interpreter) 367 : CommandObjectProcessLaunchOrAttach( 368 interpreter, "process attach", "Attach to a process.", 369 "process attach <cmd-options>", 0, "attach"), 370 m_options() {} 371 372 ~CommandObjectProcessAttach() override = default; 373 374 Options *GetOptions() override { return &m_options; } 375 376 protected: 377 bool DoExecute(Args &command, CommandReturnObject &result) override { 378 PlatformSP platform_sp( 379 GetDebugger().GetPlatformList().GetSelectedPlatform()); 380 381 Target *target = GetDebugger().GetSelectedTarget().get(); 382 // N.B. The attach should be synchronous. It doesn't help much to get the 383 // prompt back between initiating the attach and the target actually 384 // stopping. So even if the interpreter is set to be asynchronous, we wait 385 // for the stop ourselves here. 386 387 StateType state = eStateInvalid; 388 Process *process = m_exe_ctx.GetProcessPtr(); 389 390 if (!StopProcessIfNecessary(process, state, result)) 391 return false; 392 393 if (target == nullptr) { 394 // If there isn't a current target create one. 395 TargetSP new_target_sp; 396 Status error; 397 398 error = GetDebugger().GetTargetList().CreateTarget( 399 GetDebugger(), "", "", eLoadDependentsNo, 400 nullptr, // No platform options 401 new_target_sp); 402 target = new_target_sp.get(); 403 if (target == nullptr || error.Fail()) { 404 result.AppendError(error.AsCString("Error creating target")); 405 return false; 406 } 407 GetDebugger().GetTargetList().SetSelectedTarget(target); 408 } 409 410 // Record the old executable module, we want to issue a warning if the 411 // process of attaching changed the current executable (like somebody said 412 // "file foo" then attached to a PID whose executable was bar.) 413 414 ModuleSP old_exec_module_sp = target->GetExecutableModule(); 415 ArchSpec old_arch_spec = target->GetArchitecture(); 416 417 if (command.GetArgumentCount()) { 418 result.AppendErrorWithFormat("Invalid arguments for '%s'.\nUsage: %s\n", 419 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 420 result.SetStatus(eReturnStatusFailed); 421 return false; 422 } 423 424 m_interpreter.UpdateExecutionContext(nullptr); 425 StreamString stream; 426 const auto error = target->Attach(m_options.attach_info, &stream); 427 if (error.Success()) { 428 ProcessSP process_sp(target->GetProcessSP()); 429 if (process_sp) { 430 result.AppendMessage(stream.GetString()); 431 result.SetStatus(eReturnStatusSuccessFinishNoResult); 432 result.SetDidChangeProcessState(true); 433 } else { 434 result.AppendError( 435 "no error returned from Target::Attach, and target has no process"); 436 result.SetStatus(eReturnStatusFailed); 437 } 438 } else { 439 result.AppendErrorWithFormat("attach failed: %s\n", error.AsCString()); 440 result.SetStatus(eReturnStatusFailed); 441 } 442 443 if (!result.Succeeded()) 444 return false; 445 446 // Okay, we're done. Last step is to warn if the executable module has 447 // changed: 448 char new_path[PATH_MAX]; 449 ModuleSP new_exec_module_sp(target->GetExecutableModule()); 450 if (!old_exec_module_sp) { 451 // We might not have a module if we attached to a raw pid... 452 if (new_exec_module_sp) { 453 new_exec_module_sp->GetFileSpec().GetPath(new_path, PATH_MAX); 454 result.AppendMessageWithFormat("Executable module set to \"%s\".\n", 455 new_path); 456 } 457 } else if (old_exec_module_sp->GetFileSpec() != 458 new_exec_module_sp->GetFileSpec()) { 459 char old_path[PATH_MAX]; 460 461 old_exec_module_sp->GetFileSpec().GetPath(old_path, PATH_MAX); 462 new_exec_module_sp->GetFileSpec().GetPath(new_path, PATH_MAX); 463 464 result.AppendWarningWithFormat( 465 "Executable module changed from \"%s\" to \"%s\".\n", old_path, 466 new_path); 467 } 468 469 if (!old_arch_spec.IsValid()) { 470 result.AppendMessageWithFormat( 471 "Architecture set to: %s.\n", 472 target->GetArchitecture().GetTriple().getTriple().c_str()); 473 } else if (!old_arch_spec.IsExactMatch(target->GetArchitecture())) { 474 result.AppendWarningWithFormat( 475 "Architecture changed from %s to %s.\n", 476 old_arch_spec.GetTriple().getTriple().c_str(), 477 target->GetArchitecture().GetTriple().getTriple().c_str()); 478 } 479 480 // This supports the use-case scenario of immediately continuing the 481 // process once attached. 482 if (m_options.attach_info.GetContinueOnceAttached()) 483 m_interpreter.HandleCommand("process continue", eLazyBoolNo, result); 484 485 return result.Succeeded(); 486 } 487 488 CommandOptions m_options; 489 }; 490 491 // CommandObjectProcessContinue 492 493 #define LLDB_OPTIONS_process_continue 494 #include "CommandOptions.inc" 495 496 #pragma mark CommandObjectProcessContinue 497 498 class CommandObjectProcessContinue : public CommandObjectParsed { 499 public: 500 CommandObjectProcessContinue(CommandInterpreter &interpreter) 501 : CommandObjectParsed( 502 interpreter, "process continue", 503 "Continue execution of all threads in the current process.", 504 "process continue", 505 eCommandRequiresProcess | eCommandTryTargetAPILock | 506 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused), 507 m_options() {} 508 509 ~CommandObjectProcessContinue() override = default; 510 511 protected: 512 class CommandOptions : public Options { 513 public: 514 CommandOptions() : Options() { 515 // Keep default values of all options in one place: OptionParsingStarting 516 // () 517 OptionParsingStarting(nullptr); 518 } 519 520 ~CommandOptions() override = default; 521 522 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 523 ExecutionContext *execution_context) override { 524 Status error; 525 const int short_option = m_getopt_table[option_idx].val; 526 switch (short_option) { 527 case 'i': 528 if (option_arg.getAsInteger(0, m_ignore)) 529 error.SetErrorStringWithFormat( 530 "invalid value for ignore option: \"%s\", should be a number.", 531 option_arg.str().c_str()); 532 break; 533 534 default: 535 llvm_unreachable("Unimplemented option"); 536 } 537 return error; 538 } 539 540 void OptionParsingStarting(ExecutionContext *execution_context) override { 541 m_ignore = 0; 542 } 543 544 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 545 return llvm::makeArrayRef(g_process_continue_options); 546 } 547 548 uint32_t m_ignore; 549 }; 550 551 bool DoExecute(Args &command, CommandReturnObject &result) override { 552 Process *process = m_exe_ctx.GetProcessPtr(); 553 bool synchronous_execution = m_interpreter.GetSynchronous(); 554 StateType state = process->GetState(); 555 if (state == eStateStopped) { 556 if (command.GetArgumentCount() != 0) { 557 result.AppendErrorWithFormat( 558 "The '%s' command does not take any arguments.\n", 559 m_cmd_name.c_str()); 560 result.SetStatus(eReturnStatusFailed); 561 return false; 562 } 563 564 if (m_options.m_ignore > 0) { 565 ThreadSP sel_thread_sp(GetDefaultThread()->shared_from_this()); 566 if (sel_thread_sp) { 567 StopInfoSP stop_info_sp = sel_thread_sp->GetStopInfo(); 568 if (stop_info_sp && 569 stop_info_sp->GetStopReason() == eStopReasonBreakpoint) { 570 lldb::break_id_t bp_site_id = 571 (lldb::break_id_t)stop_info_sp->GetValue(); 572 BreakpointSiteSP bp_site_sp( 573 process->GetBreakpointSiteList().FindByID(bp_site_id)); 574 if (bp_site_sp) { 575 const size_t num_owners = bp_site_sp->GetNumberOfOwners(); 576 for (size_t i = 0; i < num_owners; i++) { 577 Breakpoint &bp_ref = 578 bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint(); 579 if (!bp_ref.IsInternal()) { 580 bp_ref.SetIgnoreCount(m_options.m_ignore); 581 } 582 } 583 } 584 } 585 } 586 } 587 588 { // Scope for thread list mutex: 589 std::lock_guard<std::recursive_mutex> guard( 590 process->GetThreadList().GetMutex()); 591 const uint32_t num_threads = process->GetThreadList().GetSize(); 592 593 // Set the actions that the threads should each take when resuming 594 for (uint32_t idx = 0; idx < num_threads; ++idx) { 595 const bool override_suspend = false; 596 process->GetThreadList().GetThreadAtIndex(idx)->SetResumeState( 597 eStateRunning, override_suspend); 598 } 599 } 600 601 const uint32_t iohandler_id = process->GetIOHandlerID(); 602 603 StreamString stream; 604 Status error; 605 if (synchronous_execution) 606 error = process->ResumeSynchronous(&stream); 607 else 608 error = process->Resume(); 609 610 if (error.Success()) { 611 // There is a race condition where this thread will return up the call 612 // stack to the main command handler and show an (lldb) prompt before 613 // HandlePrivateEvent (from PrivateStateThread) has a chance to call 614 // PushProcessIOHandler(). 615 process->SyncIOHandler(iohandler_id, std::chrono::seconds(2)); 616 617 result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n", 618 process->GetID()); 619 if (synchronous_execution) { 620 // If any state changed events had anything to say, add that to the 621 // result 622 result.AppendMessage(stream.GetString()); 623 624 result.SetDidChangeProcessState(true); 625 result.SetStatus(eReturnStatusSuccessFinishNoResult); 626 } else { 627 result.SetStatus(eReturnStatusSuccessContinuingNoResult); 628 } 629 } else { 630 result.AppendErrorWithFormat("Failed to resume process: %s.\n", 631 error.AsCString()); 632 result.SetStatus(eReturnStatusFailed); 633 } 634 } else { 635 result.AppendErrorWithFormat( 636 "Process cannot be continued from its current state (%s).\n", 637 StateAsCString(state)); 638 result.SetStatus(eReturnStatusFailed); 639 } 640 return result.Succeeded(); 641 } 642 643 Options *GetOptions() override { return &m_options; } 644 645 CommandOptions m_options; 646 }; 647 648 // CommandObjectProcessDetach 649 #define LLDB_OPTIONS_process_detach 650 #include "CommandOptions.inc" 651 652 #pragma mark CommandObjectProcessDetach 653 654 class CommandObjectProcessDetach : public CommandObjectParsed { 655 public: 656 class CommandOptions : public Options { 657 public: 658 CommandOptions() : Options() { OptionParsingStarting(nullptr); } 659 660 ~CommandOptions() override = default; 661 662 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 663 ExecutionContext *execution_context) override { 664 Status error; 665 const int short_option = m_getopt_table[option_idx].val; 666 667 switch (short_option) { 668 case 's': 669 bool tmp_result; 670 bool success; 671 tmp_result = OptionArgParser::ToBoolean(option_arg, false, &success); 672 if (!success) 673 error.SetErrorStringWithFormat("invalid boolean option: \"%s\"", 674 option_arg.str().c_str()); 675 else { 676 if (tmp_result) 677 m_keep_stopped = eLazyBoolYes; 678 else 679 m_keep_stopped = eLazyBoolNo; 680 } 681 break; 682 default: 683 llvm_unreachable("Unimplemented option"); 684 } 685 return error; 686 } 687 688 void OptionParsingStarting(ExecutionContext *execution_context) override { 689 m_keep_stopped = eLazyBoolCalculate; 690 } 691 692 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 693 return llvm::makeArrayRef(g_process_detach_options); 694 } 695 696 // Instance variables to hold the values for command options. 697 LazyBool m_keep_stopped; 698 }; 699 700 CommandObjectProcessDetach(CommandInterpreter &interpreter) 701 : CommandObjectParsed(interpreter, "process detach", 702 "Detach from the current target process.", 703 "process detach", 704 eCommandRequiresProcess | eCommandTryTargetAPILock | 705 eCommandProcessMustBeLaunched), 706 m_options() {} 707 708 ~CommandObjectProcessDetach() override = default; 709 710 Options *GetOptions() override { return &m_options; } 711 712 protected: 713 bool DoExecute(Args &command, CommandReturnObject &result) override { 714 Process *process = m_exe_ctx.GetProcessPtr(); 715 // FIXME: This will be a Command Option: 716 bool keep_stopped; 717 if (m_options.m_keep_stopped == eLazyBoolCalculate) { 718 // Check the process default: 719 keep_stopped = process->GetDetachKeepsStopped(); 720 } else if (m_options.m_keep_stopped == eLazyBoolYes) 721 keep_stopped = true; 722 else 723 keep_stopped = false; 724 725 Status error(process->Detach(keep_stopped)); 726 if (error.Success()) { 727 result.SetStatus(eReturnStatusSuccessFinishResult); 728 } else { 729 result.AppendErrorWithFormat("Detach failed: %s\n", error.AsCString()); 730 result.SetStatus(eReturnStatusFailed); 731 return false; 732 } 733 return result.Succeeded(); 734 } 735 736 CommandOptions m_options; 737 }; 738 739 // CommandObjectProcessConnect 740 #define LLDB_OPTIONS_process_connect 741 #include "CommandOptions.inc" 742 743 #pragma mark CommandObjectProcessConnect 744 745 class CommandObjectProcessConnect : public CommandObjectParsed { 746 public: 747 class CommandOptions : public Options { 748 public: 749 CommandOptions() : Options() { 750 // Keep default values of all options in one place: OptionParsingStarting 751 // () 752 OptionParsingStarting(nullptr); 753 } 754 755 ~CommandOptions() override = default; 756 757 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 758 ExecutionContext *execution_context) override { 759 Status error; 760 const int short_option = m_getopt_table[option_idx].val; 761 762 switch (short_option) { 763 case 'p': 764 plugin_name.assign(std::string(option_arg)); 765 break; 766 767 default: 768 llvm_unreachable("Unimplemented option"); 769 } 770 return error; 771 } 772 773 void OptionParsingStarting(ExecutionContext *execution_context) override { 774 plugin_name.clear(); 775 } 776 777 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 778 return llvm::makeArrayRef(g_process_connect_options); 779 } 780 781 // Instance variables to hold the values for command options. 782 783 std::string plugin_name; 784 }; 785 786 CommandObjectProcessConnect(CommandInterpreter &interpreter) 787 : CommandObjectParsed(interpreter, "process connect", 788 "Connect to a remote debug service.", 789 "process connect <remote-url>", 0), 790 m_options() {} 791 792 ~CommandObjectProcessConnect() override = default; 793 794 Options *GetOptions() override { return &m_options; } 795 796 protected: 797 bool DoExecute(Args &command, CommandReturnObject &result) override { 798 if (command.GetArgumentCount() != 1) { 799 result.AppendErrorWithFormat( 800 "'%s' takes exactly one argument:\nUsage: %s\n", m_cmd_name.c_str(), 801 m_cmd_syntax.c_str()); 802 result.SetStatus(eReturnStatusFailed); 803 return false; 804 } 805 806 Process *process = m_exe_ctx.GetProcessPtr(); 807 if (process && process->IsAlive()) { 808 result.AppendErrorWithFormat( 809 "Process %" PRIu64 810 " is currently being debugged, kill the process before connecting.\n", 811 process->GetID()); 812 result.SetStatus(eReturnStatusFailed); 813 return false; 814 } 815 816 const char *plugin_name = nullptr; 817 if (!m_options.plugin_name.empty()) 818 plugin_name = m_options.plugin_name.c_str(); 819 820 Status error; 821 Debugger &debugger = GetDebugger(); 822 PlatformSP platform_sp = m_interpreter.GetPlatform(true); 823 ProcessSP process_sp = 824 debugger.GetAsyncExecution() 825 ? platform_sp->ConnectProcess( 826 command.GetArgumentAtIndex(0), plugin_name, debugger, 827 debugger.GetSelectedTarget().get(), error) 828 : platform_sp->ConnectProcessSynchronous( 829 command.GetArgumentAtIndex(0), plugin_name, debugger, 830 result.GetOutputStream(), debugger.GetSelectedTarget().get(), 831 error); 832 if (error.Fail() || process_sp == nullptr) { 833 result.AppendError(error.AsCString("Error connecting to the process")); 834 result.SetStatus(eReturnStatusFailed); 835 return false; 836 } 837 return true; 838 } 839 840 CommandOptions m_options; 841 }; 842 843 // CommandObjectProcessPlugin 844 #pragma mark CommandObjectProcessPlugin 845 846 class CommandObjectProcessPlugin : public CommandObjectProxy { 847 public: 848 CommandObjectProcessPlugin(CommandInterpreter &interpreter) 849 : CommandObjectProxy( 850 interpreter, "process plugin", 851 "Send a custom command to the current target process plug-in.", 852 "process plugin <args>", 0) {} 853 854 ~CommandObjectProcessPlugin() override = default; 855 856 CommandObject *GetProxyCommandObject() override { 857 Process *process = m_interpreter.GetExecutionContext().GetProcessPtr(); 858 if (process) 859 return process->GetPluginCommandObject(); 860 return nullptr; 861 } 862 }; 863 864 // CommandObjectProcessLoad 865 #define LLDB_OPTIONS_process_load 866 #include "CommandOptions.inc" 867 868 #pragma mark CommandObjectProcessLoad 869 870 class CommandObjectProcessLoad : public CommandObjectParsed { 871 public: 872 class CommandOptions : public Options { 873 public: 874 CommandOptions() : Options() { 875 // Keep default values of all options in one place: OptionParsingStarting 876 // () 877 OptionParsingStarting(nullptr); 878 } 879 880 ~CommandOptions() override = default; 881 882 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 883 ExecutionContext *execution_context) override { 884 Status error; 885 const int short_option = m_getopt_table[option_idx].val; 886 switch (short_option) { 887 case 'i': 888 do_install = true; 889 if (!option_arg.empty()) 890 install_path.SetFile(option_arg, FileSpec::Style::native); 891 break; 892 default: 893 llvm_unreachable("Unimplemented option"); 894 } 895 return error; 896 } 897 898 void OptionParsingStarting(ExecutionContext *execution_context) override { 899 do_install = false; 900 install_path.Clear(); 901 } 902 903 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 904 return llvm::makeArrayRef(g_process_load_options); 905 } 906 907 // Instance variables to hold the values for command options. 908 bool do_install; 909 FileSpec install_path; 910 }; 911 912 CommandObjectProcessLoad(CommandInterpreter &interpreter) 913 : CommandObjectParsed(interpreter, "process load", 914 "Load a shared library into the current process.", 915 "process load <filename> [<filename> ...]", 916 eCommandRequiresProcess | eCommandTryTargetAPILock | 917 eCommandProcessMustBeLaunched | 918 eCommandProcessMustBePaused), 919 m_options() {} 920 921 ~CommandObjectProcessLoad() override = default; 922 923 Options *GetOptions() override { return &m_options; } 924 925 protected: 926 bool DoExecute(Args &command, CommandReturnObject &result) override { 927 Process *process = m_exe_ctx.GetProcessPtr(); 928 929 for (auto &entry : command.entries()) { 930 Status error; 931 PlatformSP platform = process->GetTarget().GetPlatform(); 932 llvm::StringRef image_path = entry.ref(); 933 uint32_t image_token = LLDB_INVALID_IMAGE_TOKEN; 934 935 if (!m_options.do_install) { 936 FileSpec image_spec(image_path); 937 platform->ResolveRemotePath(image_spec, image_spec); 938 image_token = 939 platform->LoadImage(process, FileSpec(), image_spec, error); 940 } else if (m_options.install_path) { 941 FileSpec image_spec(image_path); 942 FileSystem::Instance().Resolve(image_spec); 943 platform->ResolveRemotePath(m_options.install_path, 944 m_options.install_path); 945 image_token = platform->LoadImage(process, image_spec, 946 m_options.install_path, error); 947 } else { 948 FileSpec image_spec(image_path); 949 FileSystem::Instance().Resolve(image_spec); 950 image_token = 951 platform->LoadImage(process, image_spec, FileSpec(), error); 952 } 953 954 if (image_token != LLDB_INVALID_IMAGE_TOKEN) { 955 result.AppendMessageWithFormat( 956 "Loading \"%s\"...ok\nImage %u loaded.\n", image_path.str().c_str(), 957 image_token); 958 result.SetStatus(eReturnStatusSuccessFinishResult); 959 } else { 960 result.AppendErrorWithFormat("failed to load '%s': %s", 961 image_path.str().c_str(), 962 error.AsCString()); 963 result.SetStatus(eReturnStatusFailed); 964 } 965 } 966 return result.Succeeded(); 967 } 968 969 CommandOptions m_options; 970 }; 971 972 // CommandObjectProcessUnload 973 #pragma mark CommandObjectProcessUnload 974 975 class CommandObjectProcessUnload : public CommandObjectParsed { 976 public: 977 CommandObjectProcessUnload(CommandInterpreter &interpreter) 978 : CommandObjectParsed( 979 interpreter, "process unload", 980 "Unload a shared library from the current process using the index " 981 "returned by a previous call to \"process load\".", 982 "process unload <index>", 983 eCommandRequiresProcess | eCommandTryTargetAPILock | 984 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {} 985 986 ~CommandObjectProcessUnload() override = default; 987 988 protected: 989 bool DoExecute(Args &command, CommandReturnObject &result) override { 990 Process *process = m_exe_ctx.GetProcessPtr(); 991 992 for (auto &entry : command.entries()) { 993 uint32_t image_token; 994 if (entry.ref().getAsInteger(0, image_token)) { 995 result.AppendErrorWithFormat("invalid image index argument '%s'", 996 entry.ref().str().c_str()); 997 result.SetStatus(eReturnStatusFailed); 998 break; 999 } else { 1000 Status error(process->GetTarget().GetPlatform()->UnloadImage( 1001 process, image_token)); 1002 if (error.Success()) { 1003 result.AppendMessageWithFormat( 1004 "Unloading shared library with index %u...ok\n", image_token); 1005 result.SetStatus(eReturnStatusSuccessFinishResult); 1006 } else { 1007 result.AppendErrorWithFormat("failed to unload image: %s", 1008 error.AsCString()); 1009 result.SetStatus(eReturnStatusFailed); 1010 break; 1011 } 1012 } 1013 } 1014 return result.Succeeded(); 1015 } 1016 }; 1017 1018 // CommandObjectProcessSignal 1019 #pragma mark CommandObjectProcessSignal 1020 1021 class CommandObjectProcessSignal : public CommandObjectParsed { 1022 public: 1023 CommandObjectProcessSignal(CommandInterpreter &interpreter) 1024 : CommandObjectParsed( 1025 interpreter, "process signal", 1026 "Send a UNIX signal to the current target process.", nullptr, 1027 eCommandRequiresProcess | eCommandTryTargetAPILock) { 1028 CommandArgumentEntry arg; 1029 CommandArgumentData signal_arg; 1030 1031 // Define the first (and only) variant of this arg. 1032 signal_arg.arg_type = eArgTypeUnixSignal; 1033 signal_arg.arg_repetition = eArgRepeatPlain; 1034 1035 // There is only one variant this argument could be; put it into the 1036 // argument entry. 1037 arg.push_back(signal_arg); 1038 1039 // Push the data for the first argument into the m_arguments vector. 1040 m_arguments.push_back(arg); 1041 } 1042 1043 ~CommandObjectProcessSignal() override = default; 1044 1045 void 1046 HandleArgumentCompletion(CompletionRequest &request, 1047 OptionElementVector &opt_element_vector) override { 1048 if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0) 1049 return; 1050 1051 UnixSignalsSP signals = m_exe_ctx.GetProcessPtr()->GetUnixSignals(); 1052 int signo = signals->GetFirstSignalNumber(); 1053 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1054 request.AddCompletion(signals->GetSignalAsCString(signo), ""); 1055 signo = signals->GetNextSignalNumber(signo); 1056 } 1057 } 1058 1059 protected: 1060 bool DoExecute(Args &command, CommandReturnObject &result) override { 1061 Process *process = m_exe_ctx.GetProcessPtr(); 1062 1063 if (command.GetArgumentCount() == 1) { 1064 int signo = LLDB_INVALID_SIGNAL_NUMBER; 1065 1066 const char *signal_name = command.GetArgumentAtIndex(0); 1067 if (::isxdigit(signal_name[0])) { 1068 if (!llvm::to_integer(signal_name, signo)) 1069 signo = LLDB_INVALID_SIGNAL_NUMBER; 1070 } else 1071 signo = process->GetUnixSignals()->GetSignalNumberFromName(signal_name); 1072 1073 if (signo == LLDB_INVALID_SIGNAL_NUMBER) { 1074 result.AppendErrorWithFormat("Invalid signal argument '%s'.\n", 1075 command.GetArgumentAtIndex(0)); 1076 result.SetStatus(eReturnStatusFailed); 1077 } else { 1078 Status error(process->Signal(signo)); 1079 if (error.Success()) { 1080 result.SetStatus(eReturnStatusSuccessFinishResult); 1081 } else { 1082 result.AppendErrorWithFormat("Failed to send signal %i: %s\n", signo, 1083 error.AsCString()); 1084 result.SetStatus(eReturnStatusFailed); 1085 } 1086 } 1087 } else { 1088 result.AppendErrorWithFormat( 1089 "'%s' takes exactly one signal number argument:\nUsage: %s\n", 1090 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1091 result.SetStatus(eReturnStatusFailed); 1092 } 1093 return result.Succeeded(); 1094 } 1095 }; 1096 1097 // CommandObjectProcessInterrupt 1098 #pragma mark CommandObjectProcessInterrupt 1099 1100 class CommandObjectProcessInterrupt : public CommandObjectParsed { 1101 public: 1102 CommandObjectProcessInterrupt(CommandInterpreter &interpreter) 1103 : CommandObjectParsed(interpreter, "process interrupt", 1104 "Interrupt the current target process.", 1105 "process interrupt", 1106 eCommandRequiresProcess | eCommandTryTargetAPILock | 1107 eCommandProcessMustBeLaunched) {} 1108 1109 ~CommandObjectProcessInterrupt() override = default; 1110 1111 protected: 1112 bool DoExecute(Args &command, CommandReturnObject &result) override { 1113 Process *process = m_exe_ctx.GetProcessPtr(); 1114 if (process == nullptr) { 1115 result.AppendError("no process to halt"); 1116 result.SetStatus(eReturnStatusFailed); 1117 return false; 1118 } 1119 1120 if (command.GetArgumentCount() == 0) { 1121 bool clear_thread_plans = true; 1122 Status error(process->Halt(clear_thread_plans)); 1123 if (error.Success()) { 1124 result.SetStatus(eReturnStatusSuccessFinishResult); 1125 } else { 1126 result.AppendErrorWithFormat("Failed to halt process: %s\n", 1127 error.AsCString()); 1128 result.SetStatus(eReturnStatusFailed); 1129 } 1130 } else { 1131 result.AppendErrorWithFormat("'%s' takes no arguments:\nUsage: %s\n", 1132 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1133 result.SetStatus(eReturnStatusFailed); 1134 } 1135 return result.Succeeded(); 1136 } 1137 }; 1138 1139 // CommandObjectProcessKill 1140 #pragma mark CommandObjectProcessKill 1141 1142 class CommandObjectProcessKill : public CommandObjectParsed { 1143 public: 1144 CommandObjectProcessKill(CommandInterpreter &interpreter) 1145 : CommandObjectParsed(interpreter, "process kill", 1146 "Terminate the current target process.", 1147 "process kill", 1148 eCommandRequiresProcess | eCommandTryTargetAPILock | 1149 eCommandProcessMustBeLaunched) {} 1150 1151 ~CommandObjectProcessKill() override = default; 1152 1153 protected: 1154 bool DoExecute(Args &command, CommandReturnObject &result) override { 1155 Process *process = m_exe_ctx.GetProcessPtr(); 1156 if (process == nullptr) { 1157 result.AppendError("no process to kill"); 1158 result.SetStatus(eReturnStatusFailed); 1159 return false; 1160 } 1161 1162 if (command.GetArgumentCount() == 0) { 1163 Status error(process->Destroy(true)); 1164 if (error.Success()) { 1165 result.SetStatus(eReturnStatusSuccessFinishResult); 1166 } else { 1167 result.AppendErrorWithFormat("Failed to kill process: %s\n", 1168 error.AsCString()); 1169 result.SetStatus(eReturnStatusFailed); 1170 } 1171 } else { 1172 result.AppendErrorWithFormat("'%s' takes no arguments:\nUsage: %s\n", 1173 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1174 result.SetStatus(eReturnStatusFailed); 1175 } 1176 return result.Succeeded(); 1177 } 1178 }; 1179 1180 // CommandObjectProcessSaveCore 1181 #pragma mark CommandObjectProcessSaveCore 1182 1183 class CommandObjectProcessSaveCore : public CommandObjectParsed { 1184 public: 1185 CommandObjectProcessSaveCore(CommandInterpreter &interpreter) 1186 : CommandObjectParsed(interpreter, "process save-core", 1187 "Save the current process as a core file using an " 1188 "appropriate file type.", 1189 "process save-core FILE", 1190 eCommandRequiresProcess | eCommandTryTargetAPILock | 1191 eCommandProcessMustBeLaunched) {} 1192 1193 ~CommandObjectProcessSaveCore() override = default; 1194 1195 protected: 1196 bool DoExecute(Args &command, CommandReturnObject &result) override { 1197 ProcessSP process_sp = m_exe_ctx.GetProcessSP(); 1198 if (process_sp) { 1199 if (command.GetArgumentCount() == 1) { 1200 FileSpec output_file(command.GetArgumentAtIndex(0)); 1201 Status error = PluginManager::SaveCore(process_sp, output_file); 1202 if (error.Success()) { 1203 result.SetStatus(eReturnStatusSuccessFinishResult); 1204 } else { 1205 result.AppendErrorWithFormat( 1206 "Failed to save core file for process: %s\n", error.AsCString()); 1207 result.SetStatus(eReturnStatusFailed); 1208 } 1209 } else { 1210 result.AppendErrorWithFormat("'%s' takes one arguments:\nUsage: %s\n", 1211 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1212 result.SetStatus(eReturnStatusFailed); 1213 } 1214 } else { 1215 result.AppendError("invalid process"); 1216 result.SetStatus(eReturnStatusFailed); 1217 return false; 1218 } 1219 1220 return result.Succeeded(); 1221 } 1222 }; 1223 1224 // CommandObjectProcessStatus 1225 #pragma mark CommandObjectProcessStatus 1226 #define LLDB_OPTIONS_process_status 1227 #include "CommandOptions.inc" 1228 1229 class CommandObjectProcessStatus : public CommandObjectParsed { 1230 public: 1231 CommandObjectProcessStatus(CommandInterpreter &interpreter) 1232 : CommandObjectParsed( 1233 interpreter, "process status", 1234 "Show status and stop location for the current target process.", 1235 "process status", 1236 eCommandRequiresProcess | eCommandTryTargetAPILock), 1237 m_options() {} 1238 1239 ~CommandObjectProcessStatus() override = default; 1240 1241 Options *GetOptions() override { return &m_options; } 1242 1243 class CommandOptions : public Options { 1244 public: 1245 CommandOptions() : Options(), m_verbose(false) {} 1246 1247 ~CommandOptions() override = default; 1248 1249 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1250 ExecutionContext *execution_context) override { 1251 const int short_option = m_getopt_table[option_idx].val; 1252 1253 switch (short_option) { 1254 case 'v': 1255 m_verbose = true; 1256 break; 1257 default: 1258 llvm_unreachable("Unimplemented option"); 1259 } 1260 1261 return {}; 1262 } 1263 1264 void OptionParsingStarting(ExecutionContext *execution_context) override { 1265 m_verbose = false; 1266 } 1267 1268 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1269 return llvm::makeArrayRef(g_process_status_options); 1270 } 1271 1272 // Instance variables to hold the values for command options. 1273 bool m_verbose; 1274 }; 1275 1276 protected: 1277 bool DoExecute(Args &command, CommandReturnObject &result) override { 1278 Stream &strm = result.GetOutputStream(); 1279 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1280 1281 if (command.GetArgumentCount()) { 1282 result.AppendError("'process status' takes no arguments"); 1283 result.SetStatus(eReturnStatusFailed); 1284 return result.Succeeded(); 1285 } 1286 1287 // No need to check "process" for validity as eCommandRequiresProcess 1288 // ensures it is valid 1289 Process *process = m_exe_ctx.GetProcessPtr(); 1290 const bool only_threads_with_stop_reason = true; 1291 const uint32_t start_frame = 0; 1292 const uint32_t num_frames = 1; 1293 const uint32_t num_frames_with_source = 1; 1294 const bool stop_format = true; 1295 process->GetStatus(strm); 1296 process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame, 1297 num_frames, num_frames_with_source, stop_format); 1298 1299 if (m_options.m_verbose) { 1300 PlatformSP platform_sp = process->GetTarget().GetPlatform(); 1301 if (!platform_sp) { 1302 result.AppendError("Couldn'retrieve the target's platform"); 1303 result.SetStatus(eReturnStatusFailed); 1304 return result.Succeeded(); 1305 } 1306 1307 auto expected_crash_info = 1308 platform_sp->FetchExtendedCrashInformation(*process); 1309 1310 if (!expected_crash_info) { 1311 result.AppendError(llvm::toString(expected_crash_info.takeError())); 1312 result.SetStatus(eReturnStatusFailed); 1313 return result.Succeeded(); 1314 } 1315 1316 StructuredData::DictionarySP crash_info_sp = *expected_crash_info; 1317 1318 if (crash_info_sp) { 1319 strm.PutCString("Extended Crash Information:\n"); 1320 crash_info_sp->Dump(strm); 1321 } 1322 } 1323 1324 return result.Succeeded(); 1325 } 1326 1327 private: 1328 CommandOptions m_options; 1329 }; 1330 1331 // CommandObjectProcessHandle 1332 #define LLDB_OPTIONS_process_handle 1333 #include "CommandOptions.inc" 1334 1335 #pragma mark CommandObjectProcessHandle 1336 1337 class CommandObjectProcessHandle : public CommandObjectParsed { 1338 public: 1339 class CommandOptions : public Options { 1340 public: 1341 CommandOptions() : Options() { OptionParsingStarting(nullptr); } 1342 1343 ~CommandOptions() override = default; 1344 1345 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1346 ExecutionContext *execution_context) override { 1347 Status error; 1348 const int short_option = m_getopt_table[option_idx].val; 1349 1350 switch (short_option) { 1351 case 's': 1352 stop = std::string(option_arg); 1353 break; 1354 case 'n': 1355 notify = std::string(option_arg); 1356 break; 1357 case 'p': 1358 pass = std::string(option_arg); 1359 break; 1360 default: 1361 llvm_unreachable("Unimplemented option"); 1362 } 1363 return error; 1364 } 1365 1366 void OptionParsingStarting(ExecutionContext *execution_context) override { 1367 stop.clear(); 1368 notify.clear(); 1369 pass.clear(); 1370 } 1371 1372 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1373 return llvm::makeArrayRef(g_process_handle_options); 1374 } 1375 1376 // Instance variables to hold the values for command options. 1377 1378 std::string stop; 1379 std::string notify; 1380 std::string pass; 1381 }; 1382 1383 CommandObjectProcessHandle(CommandInterpreter &interpreter) 1384 : CommandObjectParsed(interpreter, "process handle", 1385 "Manage LLDB handling of OS signals for the " 1386 "current target process. Defaults to showing " 1387 "current policy.", 1388 nullptr, eCommandRequiresTarget), 1389 m_options() { 1390 SetHelpLong("\nIf no signals are specified, update them all. If no update " 1391 "option is specified, list the current values."); 1392 CommandArgumentEntry arg; 1393 CommandArgumentData signal_arg; 1394 1395 signal_arg.arg_type = eArgTypeUnixSignal; 1396 signal_arg.arg_repetition = eArgRepeatStar; 1397 1398 arg.push_back(signal_arg); 1399 1400 m_arguments.push_back(arg); 1401 } 1402 1403 ~CommandObjectProcessHandle() override = default; 1404 1405 Options *GetOptions() override { return &m_options; } 1406 1407 bool VerifyCommandOptionValue(const std::string &option, int &real_value) { 1408 bool okay = true; 1409 bool success = false; 1410 bool tmp_value = OptionArgParser::ToBoolean(option, false, &success); 1411 1412 if (success && tmp_value) 1413 real_value = 1; 1414 else if (success && !tmp_value) 1415 real_value = 0; 1416 else { 1417 // If the value isn't 'true' or 'false', it had better be 0 or 1. 1418 if (!llvm::to_integer(option, real_value)) 1419 real_value = 3; 1420 if (real_value != 0 && real_value != 1) 1421 okay = false; 1422 } 1423 1424 return okay; 1425 } 1426 1427 void PrintSignalHeader(Stream &str) { 1428 str.Printf("NAME PASS STOP NOTIFY\n"); 1429 str.Printf("=========== ===== ===== ======\n"); 1430 } 1431 1432 void PrintSignal(Stream &str, int32_t signo, const char *sig_name, 1433 const UnixSignalsSP &signals_sp) { 1434 bool stop; 1435 bool suppress; 1436 bool notify; 1437 1438 str.Printf("%-11s ", sig_name); 1439 if (signals_sp->GetSignalInfo(signo, suppress, stop, notify)) { 1440 bool pass = !suppress; 1441 str.Printf("%s %s %s", (pass ? "true " : "false"), 1442 (stop ? "true " : "false"), (notify ? "true " : "false")); 1443 } 1444 str.Printf("\n"); 1445 } 1446 1447 void PrintSignalInformation(Stream &str, Args &signal_args, 1448 int num_valid_signals, 1449 const UnixSignalsSP &signals_sp) { 1450 PrintSignalHeader(str); 1451 1452 if (num_valid_signals > 0) { 1453 size_t num_args = signal_args.GetArgumentCount(); 1454 for (size_t i = 0; i < num_args; ++i) { 1455 int32_t signo = signals_sp->GetSignalNumberFromName( 1456 signal_args.GetArgumentAtIndex(i)); 1457 if (signo != LLDB_INVALID_SIGNAL_NUMBER) 1458 PrintSignal(str, signo, signal_args.GetArgumentAtIndex(i), 1459 signals_sp); 1460 } 1461 } else // Print info for ALL signals 1462 { 1463 int32_t signo = signals_sp->GetFirstSignalNumber(); 1464 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1465 PrintSignal(str, signo, signals_sp->GetSignalAsCString(signo), 1466 signals_sp); 1467 signo = signals_sp->GetNextSignalNumber(signo); 1468 } 1469 } 1470 } 1471 1472 protected: 1473 bool DoExecute(Args &signal_args, CommandReturnObject &result) override { 1474 Target *target_sp = &GetSelectedTarget(); 1475 1476 ProcessSP process_sp = target_sp->GetProcessSP(); 1477 1478 if (!process_sp) { 1479 result.AppendError("No current process; cannot handle signals until you " 1480 "have a valid process.\n"); 1481 result.SetStatus(eReturnStatusFailed); 1482 return false; 1483 } 1484 1485 int stop_action = -1; // -1 means leave the current setting alone 1486 int pass_action = -1; // -1 means leave the current setting alone 1487 int notify_action = -1; // -1 means leave the current setting alone 1488 1489 if (!m_options.stop.empty() && 1490 !VerifyCommandOptionValue(m_options.stop, stop_action)) { 1491 result.AppendError("Invalid argument for command option --stop; must be " 1492 "true or false.\n"); 1493 result.SetStatus(eReturnStatusFailed); 1494 return false; 1495 } 1496 1497 if (!m_options.notify.empty() && 1498 !VerifyCommandOptionValue(m_options.notify, notify_action)) { 1499 result.AppendError("Invalid argument for command option --notify; must " 1500 "be true or false.\n"); 1501 result.SetStatus(eReturnStatusFailed); 1502 return false; 1503 } 1504 1505 if (!m_options.pass.empty() && 1506 !VerifyCommandOptionValue(m_options.pass, pass_action)) { 1507 result.AppendError("Invalid argument for command option --pass; must be " 1508 "true or false.\n"); 1509 result.SetStatus(eReturnStatusFailed); 1510 return false; 1511 } 1512 1513 size_t num_args = signal_args.GetArgumentCount(); 1514 UnixSignalsSP signals_sp = process_sp->GetUnixSignals(); 1515 int num_signals_set = 0; 1516 1517 if (num_args > 0) { 1518 for (const auto &arg : signal_args) { 1519 int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str()); 1520 if (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1521 // Casting the actions as bools here should be okay, because 1522 // VerifyCommandOptionValue guarantees the value is either 0 or 1. 1523 if (stop_action != -1) 1524 signals_sp->SetShouldStop(signo, stop_action); 1525 if (pass_action != -1) { 1526 bool suppress = !pass_action; 1527 signals_sp->SetShouldSuppress(signo, suppress); 1528 } 1529 if (notify_action != -1) 1530 signals_sp->SetShouldNotify(signo, notify_action); 1531 ++num_signals_set; 1532 } else { 1533 result.AppendErrorWithFormat("Invalid signal name '%s'\n", 1534 arg.c_str()); 1535 } 1536 } 1537 } else { 1538 // No signal specified, if any command options were specified, update ALL 1539 // signals. 1540 if ((notify_action != -1) || (stop_action != -1) || (pass_action != -1)) { 1541 if (m_interpreter.Confirm( 1542 "Do you really want to update all the signals?", false)) { 1543 int32_t signo = signals_sp->GetFirstSignalNumber(); 1544 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1545 if (notify_action != -1) 1546 signals_sp->SetShouldNotify(signo, notify_action); 1547 if (stop_action != -1) 1548 signals_sp->SetShouldStop(signo, stop_action); 1549 if (pass_action != -1) { 1550 bool suppress = !pass_action; 1551 signals_sp->SetShouldSuppress(signo, suppress); 1552 } 1553 signo = signals_sp->GetNextSignalNumber(signo); 1554 } 1555 } 1556 } 1557 } 1558 1559 PrintSignalInformation(result.GetOutputStream(), signal_args, 1560 num_signals_set, signals_sp); 1561 1562 if (num_signals_set > 0) 1563 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1564 else 1565 result.SetStatus(eReturnStatusFailed); 1566 1567 return result.Succeeded(); 1568 } 1569 1570 CommandOptions m_options; 1571 }; 1572 1573 // CommandObjectMultiwordProcess 1574 1575 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess( 1576 CommandInterpreter &interpreter) 1577 : CommandObjectMultiword( 1578 interpreter, "process", 1579 "Commands for interacting with processes on the current platform.", 1580 "process <subcommand> [<subcommand-options>]") { 1581 LoadSubCommand("attach", 1582 CommandObjectSP(new CommandObjectProcessAttach(interpreter))); 1583 LoadSubCommand("launch", 1584 CommandObjectSP(new CommandObjectProcessLaunch(interpreter))); 1585 LoadSubCommand("continue", CommandObjectSP(new CommandObjectProcessContinue( 1586 interpreter))); 1587 LoadSubCommand("connect", 1588 CommandObjectSP(new CommandObjectProcessConnect(interpreter))); 1589 LoadSubCommand("detach", 1590 CommandObjectSP(new CommandObjectProcessDetach(interpreter))); 1591 LoadSubCommand("load", 1592 CommandObjectSP(new CommandObjectProcessLoad(interpreter))); 1593 LoadSubCommand("unload", 1594 CommandObjectSP(new CommandObjectProcessUnload(interpreter))); 1595 LoadSubCommand("signal", 1596 CommandObjectSP(new CommandObjectProcessSignal(interpreter))); 1597 LoadSubCommand("handle", 1598 CommandObjectSP(new CommandObjectProcessHandle(interpreter))); 1599 LoadSubCommand("status", 1600 CommandObjectSP(new CommandObjectProcessStatus(interpreter))); 1601 LoadSubCommand("interrupt", CommandObjectSP(new CommandObjectProcessInterrupt( 1602 interpreter))); 1603 LoadSubCommand("kill", 1604 CommandObjectSP(new CommandObjectProcessKill(interpreter))); 1605 LoadSubCommand("plugin", 1606 CommandObjectSP(new CommandObjectProcessPlugin(interpreter))); 1607 LoadSubCommand("save-core", CommandObjectSP(new CommandObjectProcessSaveCore( 1608 interpreter))); 1609 } 1610 1611 CommandObjectMultiwordProcess::~CommandObjectMultiwordProcess() = default; 1612