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 "CommandObjectBreakpoint.h" 11 #include "CommandObjectTrace.h" 12 #include "CommandOptionsProcessAttach.h" 13 #include "CommandOptionsProcessLaunch.h" 14 #include "lldb/Breakpoint/Breakpoint.h" 15 #include "lldb/Breakpoint/BreakpointIDList.h" 16 #include "lldb/Breakpoint/BreakpointLocation.h" 17 #include "lldb/Breakpoint/BreakpointName.h" 18 #include "lldb/Breakpoint/BreakpointSite.h" 19 #include "lldb/Core/Module.h" 20 #include "lldb/Core/PluginManager.h" 21 #include "lldb/Host/OptionParser.h" 22 #include "lldb/Interpreter/CommandInterpreter.h" 23 #include "lldb/Interpreter/CommandOptionArgumentTable.h" 24 #include "lldb/Interpreter/CommandReturnObject.h" 25 #include "lldb/Interpreter/OptionArgParser.h" 26 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h" 27 #include "lldb/Interpreter/Options.h" 28 #include "lldb/Symbol/SaveCoreOptions.h" 29 #include "lldb/Target/Platform.h" 30 #include "lldb/Target/Process.h" 31 #include "lldb/Target/StopInfo.h" 32 #include "lldb/Target/Target.h" 33 #include "lldb/Target/Thread.h" 34 #include "lldb/Target/UnixSignals.h" 35 #include "lldb/Utility/Args.h" 36 #include "lldb/Utility/ScriptedMetadata.h" 37 #include "lldb/Utility/State.h" 38 39 #include "llvm/ADT/ScopeExit.h" 40 41 #include <bitset> 42 #include <optional> 43 44 using namespace lldb; 45 using namespace lldb_private; 46 47 class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed { 48 public: 49 CommandObjectProcessLaunchOrAttach(CommandInterpreter &interpreter, 50 const char *name, const char *help, 51 const char *syntax, uint32_t flags, 52 const char *new_process_action) 53 : CommandObjectParsed(interpreter, name, help, syntax, flags), 54 m_new_process_action(new_process_action) {} 55 56 ~CommandObjectProcessLaunchOrAttach() override = default; 57 58 protected: 59 bool StopProcessIfNecessary(Process *process, StateType &state, 60 CommandReturnObject &result) { 61 state = eStateInvalid; 62 if (process) { 63 state = process->GetState(); 64 65 if (process->IsAlive() && state != eStateConnected) { 66 std::string message; 67 if (process->GetState() == eStateAttaching) 68 message = 69 llvm::formatv("There is a pending attach, abort it and {0}?", 70 m_new_process_action); 71 else if (process->GetShouldDetach()) 72 message = llvm::formatv( 73 "There is a running process, detach from it and {0}?", 74 m_new_process_action); 75 else 76 message = 77 llvm::formatv("There is a running process, kill it and {0}?", 78 m_new_process_action); 79 80 if (!m_interpreter.Confirm(message, true)) { 81 result.SetStatus(eReturnStatusFailed); 82 return false; 83 } else { 84 if (process->GetShouldDetach()) { 85 bool keep_stopped = false; 86 Status detach_error(process->Detach(keep_stopped)); 87 if (detach_error.Success()) { 88 result.SetStatus(eReturnStatusSuccessFinishResult); 89 process = nullptr; 90 } else { 91 result.AppendErrorWithFormat( 92 "Failed to detach from process: %s\n", 93 detach_error.AsCString()); 94 } 95 } else { 96 Status destroy_error(process->Destroy(false)); 97 if (destroy_error.Success()) { 98 result.SetStatus(eReturnStatusSuccessFinishResult); 99 process = nullptr; 100 } else { 101 result.AppendErrorWithFormat("Failed to kill process: %s\n", 102 destroy_error.AsCString()); 103 } 104 } 105 } 106 } 107 } 108 return result.Succeeded(); 109 } 110 111 std::string m_new_process_action; 112 }; 113 114 // CommandObjectProcessLaunch 115 #pragma mark CommandObjectProcessLaunch 116 class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach { 117 public: 118 CommandObjectProcessLaunch(CommandInterpreter &interpreter) 119 : CommandObjectProcessLaunchOrAttach( 120 interpreter, "process launch", 121 "Launch the executable in the debugger.", nullptr, 122 eCommandRequiresTarget, "restart"), 123 124 m_class_options("scripted process", true, 'C', 'k', 'v', 0) { 125 m_all_options.Append(&m_options); 126 m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2, 127 LLDB_OPT_SET_ALL); 128 m_all_options.Finalize(); 129 130 AddSimpleArgumentList(eArgTypeRunArgs, eArgRepeatOptional); 131 } 132 133 ~CommandObjectProcessLaunch() override = default; 134 135 Options *GetOptions() override { return &m_all_options; } 136 137 std::optional<std::string> GetRepeatCommand(Args ¤t_command_args, 138 uint32_t index) override { 139 // No repeat for "process launch"... 140 return std::string(""); 141 } 142 143 protected: 144 void DoExecute(Args &launch_args, CommandReturnObject &result) override { 145 Debugger &debugger = GetDebugger(); 146 Target *target = debugger.GetSelectedTarget().get(); 147 // If our listener is nullptr, users aren't allows to launch 148 ModuleSP exe_module_sp = target->GetExecutableModule(); 149 150 // If the target already has an executable module, then use that. If it 151 // doesn't then someone must be trying to launch using a path that will 152 // make sense to the remote stub, but doesn't exist on the local host. 153 // In that case use the ExecutableFile that was set in the target's 154 // ProcessLaunchInfo. 155 if (exe_module_sp == nullptr && !target->GetProcessLaunchInfo().GetExecutableFile()) { 156 result.AppendError("no file in target, create a debug target using the " 157 "'target create' command"); 158 return; 159 } 160 161 StateType state = eStateInvalid; 162 163 if (!StopProcessIfNecessary(m_exe_ctx.GetProcessPtr(), state, result)) 164 return; 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 (!m_class_options.GetName().empty()) { 183 m_options.launch_info.SetProcessPluginName("ScriptedProcess"); 184 ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>( 185 m_class_options.GetName(), m_class_options.GetStructuredData()); 186 m_options.launch_info.SetScriptedMetadata(metadata_sp); 187 target->SetProcessLaunchInfo(m_options.launch_info); 188 } 189 190 if (disable_aslr) 191 m_options.launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 192 else 193 m_options.launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 194 195 if (target->GetInheritTCC()) 196 m_options.launch_info.GetFlags().Set(eLaunchFlagInheritTCCFromParent); 197 198 if (target->GetDetachOnError()) 199 m_options.launch_info.GetFlags().Set(eLaunchFlagDetachOnError); 200 201 if (target->GetDisableSTDIO()) 202 m_options.launch_info.GetFlags().Set(eLaunchFlagDisableSTDIO); 203 204 if (!m_options.launch_info.GetWorkingDirectory()) { 205 if (llvm::StringRef wd = target->GetLaunchWorkingDirectory(); 206 !wd.empty()) { 207 m_options.launch_info.SetWorkingDirectory(FileSpec(wd)); 208 } 209 } 210 211 // Merge the launch info environment with the target environment. 212 Environment target_env = target->GetEnvironment(); 213 m_options.launch_info.GetEnvironment().insert(target_env.begin(), 214 target_env.end()); 215 216 llvm::StringRef target_settings_argv0 = target->GetArg0(); 217 218 if (!target_settings_argv0.empty()) { 219 m_options.launch_info.GetArguments().AppendArgument( 220 target_settings_argv0); 221 if (exe_module_sp) 222 m_options.launch_info.SetExecutableFile( 223 exe_module_sp->GetPlatformFileSpec(), false); 224 else 225 m_options.launch_info.SetExecutableFile(target->GetProcessLaunchInfo().GetExecutableFile(), false); 226 } else { 227 if (exe_module_sp) 228 m_options.launch_info.SetExecutableFile( 229 exe_module_sp->GetPlatformFileSpec(), true); 230 else 231 m_options.launch_info.SetExecutableFile(target->GetProcessLaunchInfo().GetExecutableFile(), true); 232 } 233 234 if (launch_args.GetArgumentCount() == 0) { 235 m_options.launch_info.GetArguments().AppendArguments( 236 target->GetProcessLaunchInfo().GetArguments()); 237 } else { 238 m_options.launch_info.GetArguments().AppendArguments(launch_args); 239 // Save the arguments for subsequent runs in the current target. 240 target->SetRunArguments(launch_args); 241 } 242 243 StreamString stream; 244 Status error = target->Launch(m_options.launch_info, &stream); 245 246 if (error.Success()) { 247 ProcessSP process_sp(target->GetProcessSP()); 248 if (process_sp) { 249 // There is a race condition where this thread will return up the call 250 // stack to the main command handler and show an (lldb) prompt before 251 // HandlePrivateEvent (from PrivateStateThread) has a chance to call 252 // PushProcessIOHandler(). 253 process_sp->SyncIOHandler(0, std::chrono::seconds(2)); 254 255 // If we didn't have a local executable, then we wouldn't have had an 256 // executable module before launch. 257 if (!exe_module_sp) 258 exe_module_sp = target->GetExecutableModule(); 259 if (!exe_module_sp) { 260 result.AppendWarning("Could not get executable module after launch."); 261 } else { 262 263 const char *archname = 264 exe_module_sp->GetArchitecture().GetArchitectureName(); 265 result.AppendMessageWithFormat( 266 "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(), 267 exe_module_sp->GetFileSpec().GetPath().c_str(), archname); 268 } 269 result.SetStatus(eReturnStatusSuccessFinishResult); 270 // This message will refer to an event that happened after the process 271 // launched. 272 llvm::StringRef data = stream.GetString(); 273 if (!data.empty()) 274 result.AppendMessage(data); 275 result.SetDidChangeProcessState(true); 276 } else { 277 result.AppendError( 278 "no error returned from Target::Launch, and target has no process"); 279 } 280 } else { 281 result.AppendError(error.AsCString()); 282 } 283 } 284 285 CommandOptionsProcessLaunch m_options; 286 OptionGroupPythonClassWithDict m_class_options; 287 OptionGroupOptions m_all_options; 288 }; 289 290 #define LLDB_OPTIONS_process_attach 291 #include "CommandOptions.inc" 292 293 #pragma mark CommandObjectProcessAttach 294 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach { 295 public: 296 CommandObjectProcessAttach(CommandInterpreter &interpreter) 297 : CommandObjectProcessLaunchOrAttach( 298 interpreter, "process attach", "Attach to a process.", 299 "process attach <cmd-options>", 0, "attach"), 300 m_class_options("scripted process", true, 'C', 'k', 'v', 0) { 301 m_all_options.Append(&m_options); 302 m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2, 303 LLDB_OPT_SET_ALL); 304 m_all_options.Finalize(); 305 } 306 307 ~CommandObjectProcessAttach() override = default; 308 309 Options *GetOptions() override { return &m_all_options; } 310 311 protected: 312 void DoExecute(Args &command, CommandReturnObject &result) override { 313 PlatformSP platform_sp( 314 GetDebugger().GetPlatformList().GetSelectedPlatform()); 315 316 Target *target = GetDebugger().GetSelectedTarget().get(); 317 // N.B. The attach should be synchronous. It doesn't help much to get the 318 // prompt back between initiating the attach and the target actually 319 // stopping. So even if the interpreter is set to be asynchronous, we wait 320 // for the stop ourselves here. 321 322 StateType state = eStateInvalid; 323 Process *process = m_exe_ctx.GetProcessPtr(); 324 325 if (!StopProcessIfNecessary(process, state, result)) 326 return; 327 328 if (target == nullptr) { 329 // If there isn't a current target create one. 330 TargetSP new_target_sp; 331 Status error; 332 333 error = GetDebugger().GetTargetList().CreateTarget( 334 GetDebugger(), "", "", eLoadDependentsNo, 335 nullptr, // No platform options 336 new_target_sp); 337 target = new_target_sp.get(); 338 if (target == nullptr || error.Fail()) { 339 result.AppendError(error.AsCString("Error creating target")); 340 return; 341 } 342 } 343 344 if (!m_class_options.GetName().empty()) { 345 m_options.attach_info.SetProcessPluginName("ScriptedProcess"); 346 ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>( 347 m_class_options.GetName(), m_class_options.GetStructuredData()); 348 m_options.attach_info.SetScriptedMetadata(metadata_sp); 349 } 350 351 // Record the old executable module, we want to issue a warning if the 352 // process of attaching changed the current executable (like somebody said 353 // "file foo" then attached to a PID whose executable was bar.) 354 355 ModuleSP old_exec_module_sp = target->GetExecutableModule(); 356 ArchSpec old_arch_spec = target->GetArchitecture(); 357 358 StreamString stream; 359 ProcessSP process_sp; 360 const auto error = target->Attach(m_options.attach_info, &stream); 361 if (error.Success()) { 362 process_sp = target->GetProcessSP(); 363 if (process_sp) { 364 result.AppendMessage(stream.GetString()); 365 result.SetStatus(eReturnStatusSuccessFinishNoResult); 366 result.SetDidChangeProcessState(true); 367 } else { 368 result.AppendError( 369 "no error returned from Target::Attach, and target has no process"); 370 } 371 } else { 372 result.AppendErrorWithFormat("attach failed: %s\n", error.AsCString()); 373 } 374 375 if (!result.Succeeded()) 376 return; 377 378 // Okay, we're done. Last step is to warn if the executable module has 379 // changed: 380 ModuleSP new_exec_module_sp(target->GetExecutableModule()); 381 if (!old_exec_module_sp) { 382 // We might not have a module if we attached to a raw pid... 383 if (new_exec_module_sp) { 384 result.AppendMessageWithFormat( 385 "Executable binary set to \"%s\".\n", 386 new_exec_module_sp->GetFileSpec().GetPath().c_str()); 387 } 388 } else if (!new_exec_module_sp) { 389 result.AppendWarningWithFormat("No executable binary."); 390 } else if (old_exec_module_sp->GetFileSpec() != 391 new_exec_module_sp->GetFileSpec()) { 392 393 result.AppendWarningWithFormat( 394 "Executable binary changed from \"%s\" to \"%s\".\n", 395 old_exec_module_sp->GetFileSpec().GetPath().c_str(), 396 new_exec_module_sp->GetFileSpec().GetPath().c_str()); 397 } 398 399 if (!old_arch_spec.IsValid()) { 400 result.AppendMessageWithFormat( 401 "Architecture set to: %s.\n", 402 target->GetArchitecture().GetTriple().getTriple().c_str()); 403 } else if (!old_arch_spec.IsExactMatch(target->GetArchitecture())) { 404 result.AppendWarningWithFormat( 405 "Architecture changed from %s to %s.\n", 406 old_arch_spec.GetTriple().getTriple().c_str(), 407 target->GetArchitecture().GetTriple().getTriple().c_str()); 408 } 409 410 // This supports the use-case scenario of immediately continuing the 411 // process once attached. 412 if (m_options.attach_info.GetContinueOnceAttached()) { 413 // We have made a process but haven't told the interpreter about it yet, 414 // so CheckRequirements will fail for "process continue". Set the override 415 // here: 416 ExecutionContext exe_ctx(process_sp); 417 m_interpreter.HandleCommand("process continue", eLazyBoolNo, exe_ctx, result); 418 } 419 } 420 421 CommandOptionsProcessAttach m_options; 422 OptionGroupPythonClassWithDict m_class_options; 423 OptionGroupOptions m_all_options; 424 }; 425 426 // CommandObjectProcessContinue 427 428 #define LLDB_OPTIONS_process_continue 429 #include "CommandOptions.inc" 430 431 #pragma mark CommandObjectProcessContinue 432 433 class CommandObjectProcessContinue : public CommandObjectParsed { 434 public: 435 CommandObjectProcessContinue(CommandInterpreter &interpreter) 436 : CommandObjectParsed( 437 interpreter, "process continue", 438 "Continue execution of all threads in the current process.", 439 "process continue", 440 eCommandRequiresProcess | eCommandTryTargetAPILock | 441 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {} 442 443 ~CommandObjectProcessContinue() override = default; 444 445 protected: 446 class CommandOptions : public Options { 447 public: 448 CommandOptions() { 449 // Keep default values of all options in one place: OptionParsingStarting 450 // () 451 OptionParsingStarting(nullptr); 452 } 453 454 ~CommandOptions() override = default; 455 456 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 457 ExecutionContext *exe_ctx) override { 458 Status error; 459 const int short_option = m_getopt_table[option_idx].val; 460 switch (short_option) { 461 case 'i': 462 if (option_arg.getAsInteger(0, m_ignore)) 463 error = Status::FromErrorStringWithFormat( 464 "invalid value for ignore option: \"%s\", should be a number.", 465 option_arg.str().c_str()); 466 break; 467 case 'b': 468 m_run_to_bkpt_args.AppendArgument(option_arg); 469 m_any_bkpts_specified = true; 470 break; 471 default: 472 llvm_unreachable("Unimplemented option"); 473 } 474 return error; 475 } 476 477 void OptionParsingStarting(ExecutionContext *execution_context) override { 478 m_ignore = 0; 479 m_run_to_bkpt_args.Clear(); 480 m_any_bkpts_specified = false; 481 } 482 483 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 484 return llvm::ArrayRef(g_process_continue_options); 485 } 486 487 uint32_t m_ignore = 0; 488 Args m_run_to_bkpt_args; 489 bool m_any_bkpts_specified = false; 490 }; 491 492 void DoExecute(Args &command, CommandReturnObject &result) override { 493 Process *process = m_exe_ctx.GetProcessPtr(); 494 bool synchronous_execution = m_interpreter.GetSynchronous(); 495 StateType state = process->GetState(); 496 if (state == eStateStopped) { 497 if (m_options.m_ignore > 0) { 498 ThreadSP sel_thread_sp(GetDefaultThread()->shared_from_this()); 499 if (sel_thread_sp) { 500 StopInfoSP stop_info_sp = sel_thread_sp->GetStopInfo(); 501 if (stop_info_sp && 502 stop_info_sp->GetStopReason() == eStopReasonBreakpoint) { 503 lldb::break_id_t bp_site_id = 504 (lldb::break_id_t)stop_info_sp->GetValue(); 505 BreakpointSiteSP bp_site_sp( 506 process->GetBreakpointSiteList().FindByID(bp_site_id)); 507 if (bp_site_sp) { 508 const size_t num_owners = bp_site_sp->GetNumberOfConstituents(); 509 for (size_t i = 0; i < num_owners; i++) { 510 Breakpoint &bp_ref = 511 bp_site_sp->GetConstituentAtIndex(i)->GetBreakpoint(); 512 if (!bp_ref.IsInternal()) { 513 bp_ref.SetIgnoreCount(m_options.m_ignore); 514 } 515 } 516 } 517 } 518 } 519 } 520 521 Target &target = GetTarget(); 522 BreakpointIDList run_to_bkpt_ids; 523 // Don't pass an empty run_to_breakpoint list, as Verify will look for the 524 // default breakpoint. 525 if (m_options.m_run_to_bkpt_args.GetArgumentCount() > 0) 526 CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs( 527 m_options.m_run_to_bkpt_args, target, result, &run_to_bkpt_ids, 528 BreakpointName::Permissions::disablePerm); 529 if (!result.Succeeded()) { 530 return; 531 } 532 result.Clear(); 533 if (m_options.m_any_bkpts_specified && run_to_bkpt_ids.GetSize() == 0) { 534 result.AppendError("continue-to breakpoints did not specify any actual " 535 "breakpoints or locations"); 536 return; 537 } 538 539 // First figure out which breakpoints & locations were specified by the 540 // user: 541 size_t num_run_to_bkpt_ids = run_to_bkpt_ids.GetSize(); 542 std::vector<break_id_t> bkpts_disabled; 543 std::vector<BreakpointID> locs_disabled; 544 if (num_run_to_bkpt_ids != 0) { 545 // Go through the ID's specified, and separate the breakpoints from are 546 // the breakpoint.location specifications since the latter require 547 // special handling. We also figure out whether there's at least one 548 // specifier in the set that is enabled. 549 BreakpointList &bkpt_list = target.GetBreakpointList(); 550 std::unordered_set<break_id_t> bkpts_seen; 551 std::unordered_set<break_id_t> bkpts_with_locs_seen; 552 BreakpointIDList with_locs; 553 bool any_enabled = false; 554 555 for (size_t idx = 0; idx < num_run_to_bkpt_ids; idx++) { 556 BreakpointID bkpt_id = run_to_bkpt_ids.GetBreakpointIDAtIndex(idx); 557 break_id_t bp_id = bkpt_id.GetBreakpointID(); 558 break_id_t loc_id = bkpt_id.GetLocationID(); 559 BreakpointSP bp_sp 560 = bkpt_list.FindBreakpointByID(bp_id); 561 // Note, VerifyBreakpointOrLocationIDs checks for existence, so we 562 // don't need to do it again here. 563 if (bp_sp->IsEnabled()) { 564 if (loc_id == LLDB_INVALID_BREAK_ID) { 565 // A breakpoint (without location) was specified. Make sure that 566 // at least one of the locations is enabled. 567 size_t num_locations = bp_sp->GetNumLocations(); 568 for (size_t loc_idx = 0; loc_idx < num_locations; loc_idx++) { 569 BreakpointLocationSP loc_sp 570 = bp_sp->GetLocationAtIndex(loc_idx); 571 if (loc_sp->IsEnabled()) { 572 any_enabled = true; 573 break; 574 } 575 } 576 } else { 577 // A location was specified, check if it was enabled: 578 BreakpointLocationSP loc_sp = bp_sp->FindLocationByID(loc_id); 579 if (loc_sp->IsEnabled()) 580 any_enabled = true; 581 } 582 583 // Then sort the bp & bp.loc entries for later use: 584 if (bkpt_id.GetLocationID() == LLDB_INVALID_BREAK_ID) 585 bkpts_seen.insert(bkpt_id.GetBreakpointID()); 586 else { 587 bkpts_with_locs_seen.insert(bkpt_id.GetBreakpointID()); 588 with_locs.AddBreakpointID(bkpt_id); 589 } 590 } 591 } 592 // Do all the error checking here so once we start disabling we don't 593 // have to back out half-way through. 594 595 // Make sure at least one of the specified breakpoints is enabled. 596 if (!any_enabled) { 597 result.AppendError("at least one of the continue-to breakpoints must " 598 "be enabled."); 599 return; 600 } 601 602 // Also, if you specify BOTH a breakpoint and one of it's locations, 603 // we flag that as an error, since it won't do what you expect, the 604 // breakpoint directive will mean "run to all locations", which is not 605 // what the location directive means... 606 for (break_id_t bp_id : bkpts_with_locs_seen) { 607 if (bkpts_seen.count(bp_id)) { 608 result.AppendErrorWithFormatv("can't specify both a breakpoint and " 609 "one of its locations: {0}", bp_id); 610 } 611 } 612 613 // Now go through the breakpoints in the target, disabling all the ones 614 // that the user didn't mention: 615 for (BreakpointSP bp_sp : bkpt_list.Breakpoints()) { 616 break_id_t bp_id = bp_sp->GetID(); 617 // Handle the case where no locations were specified. Note we don't 618 // have to worry about the case where a breakpoint and one of its 619 // locations are both in the lists, we've already disallowed that. 620 if (!bkpts_with_locs_seen.count(bp_id)) { 621 if (!bkpts_seen.count(bp_id) && bp_sp->IsEnabled()) { 622 bkpts_disabled.push_back(bp_id); 623 bp_sp->SetEnabled(false); 624 } 625 continue; 626 } 627 // Next, handle the case where a location was specified: 628 // Run through all the locations of this breakpoint and disable 629 // the ones that aren't on our "with locations" BreakpointID list: 630 size_t num_locations = bp_sp->GetNumLocations(); 631 BreakpointID tmp_id(bp_id, LLDB_INVALID_BREAK_ID); 632 for (size_t loc_idx = 0; loc_idx < num_locations; loc_idx++) { 633 BreakpointLocationSP loc_sp = bp_sp->GetLocationAtIndex(loc_idx); 634 tmp_id.SetBreakpointLocationID(loc_idx); 635 if (!with_locs.Contains(tmp_id) && loc_sp->IsEnabled()) { 636 locs_disabled.push_back(tmp_id); 637 loc_sp->SetEnabled(false); 638 } 639 } 640 } 641 } 642 643 { // Scope for thread list mutex: 644 std::lock_guard<std::recursive_mutex> guard( 645 process->GetThreadList().GetMutex()); 646 const uint32_t num_threads = process->GetThreadList().GetSize(); 647 648 // Set the actions that the threads should each take when resuming 649 for (uint32_t idx = 0; idx < num_threads; ++idx) { 650 const bool override_suspend = false; 651 process->GetThreadList().GetThreadAtIndex(idx)->SetResumeState( 652 eStateRunning, override_suspend); 653 } 654 } 655 656 const uint32_t iohandler_id = process->GetIOHandlerID(); 657 658 StreamString stream; 659 Status error; 660 // For now we can only do -b with synchronous: 661 bool old_sync = GetDebugger().GetAsyncExecution(); 662 663 if (run_to_bkpt_ids.GetSize() != 0) { 664 GetDebugger().SetAsyncExecution(false); 665 synchronous_execution = true; 666 } 667 if (synchronous_execution) 668 error = process->ResumeSynchronous(&stream); 669 else 670 error = process->Resume(); 671 672 if (run_to_bkpt_ids.GetSize() != 0) { 673 GetDebugger().SetAsyncExecution(old_sync); 674 } 675 676 // Now re-enable the breakpoints we disabled: 677 BreakpointList &bkpt_list = target.GetBreakpointList(); 678 for (break_id_t bp_id : bkpts_disabled) { 679 BreakpointSP bp_sp = bkpt_list.FindBreakpointByID(bp_id); 680 if (bp_sp) 681 bp_sp->SetEnabled(true); 682 } 683 for (const BreakpointID &bkpt_id : locs_disabled) { 684 BreakpointSP bp_sp 685 = bkpt_list.FindBreakpointByID(bkpt_id.GetBreakpointID()); 686 if (bp_sp) { 687 BreakpointLocationSP loc_sp 688 = bp_sp->FindLocationByID(bkpt_id.GetLocationID()); 689 if (loc_sp) 690 loc_sp->SetEnabled(true); 691 } 692 } 693 694 if (error.Success()) { 695 // There is a race condition where this thread will return up the call 696 // stack to the main command handler and show an (lldb) prompt before 697 // HandlePrivateEvent (from PrivateStateThread) has a chance to call 698 // PushProcessIOHandler(). 699 process->SyncIOHandler(iohandler_id, std::chrono::seconds(2)); 700 701 result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n", 702 process->GetID()); 703 if (synchronous_execution) { 704 // If any state changed events had anything to say, add that to the 705 // result 706 result.AppendMessage(stream.GetString()); 707 708 result.SetDidChangeProcessState(true); 709 result.SetStatus(eReturnStatusSuccessFinishNoResult); 710 } else { 711 result.SetStatus(eReturnStatusSuccessContinuingNoResult); 712 } 713 } else { 714 result.AppendErrorWithFormat("Failed to resume process: %s.\n", 715 error.AsCString()); 716 } 717 } else { 718 result.AppendErrorWithFormat( 719 "Process cannot be continued from its current state (%s).\n", 720 StateAsCString(state)); 721 } 722 } 723 724 Options *GetOptions() override { return &m_options; } 725 726 CommandOptions m_options; 727 }; 728 729 // CommandObjectProcessDetach 730 #define LLDB_OPTIONS_process_detach 731 #include "CommandOptions.inc" 732 733 #pragma mark CommandObjectProcessDetach 734 735 class CommandObjectProcessDetach : public CommandObjectParsed { 736 public: 737 class CommandOptions : public Options { 738 public: 739 CommandOptions() { OptionParsingStarting(nullptr); } 740 741 ~CommandOptions() override = default; 742 743 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 744 ExecutionContext *execution_context) override { 745 Status error; 746 const int short_option = m_getopt_table[option_idx].val; 747 748 switch (short_option) { 749 case 's': 750 bool tmp_result; 751 bool success; 752 tmp_result = OptionArgParser::ToBoolean(option_arg, false, &success); 753 if (!success) 754 error = Status::FromErrorStringWithFormat( 755 "invalid boolean option: \"%s\"", option_arg.str().c_str()); 756 else { 757 if (tmp_result) 758 m_keep_stopped = eLazyBoolYes; 759 else 760 m_keep_stopped = eLazyBoolNo; 761 } 762 break; 763 default: 764 llvm_unreachable("Unimplemented option"); 765 } 766 return error; 767 } 768 769 void OptionParsingStarting(ExecutionContext *execution_context) override { 770 m_keep_stopped = eLazyBoolCalculate; 771 } 772 773 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 774 return llvm::ArrayRef(g_process_detach_options); 775 } 776 777 // Instance variables to hold the values for command options. 778 LazyBool m_keep_stopped; 779 }; 780 781 CommandObjectProcessDetach(CommandInterpreter &interpreter) 782 : CommandObjectParsed(interpreter, "process detach", 783 "Detach from the current target process.", 784 "process detach", 785 eCommandRequiresProcess | eCommandTryTargetAPILock | 786 eCommandProcessMustBeLaunched) {} 787 788 ~CommandObjectProcessDetach() override = default; 789 790 Options *GetOptions() override { return &m_options; } 791 792 protected: 793 void DoExecute(Args &command, CommandReturnObject &result) override { 794 Process *process = m_exe_ctx.GetProcessPtr(); 795 // FIXME: This will be a Command Option: 796 bool keep_stopped; 797 if (m_options.m_keep_stopped == eLazyBoolCalculate) { 798 // Check the process default: 799 keep_stopped = process->GetDetachKeepsStopped(); 800 } else if (m_options.m_keep_stopped == eLazyBoolYes) 801 keep_stopped = true; 802 else 803 keep_stopped = false; 804 805 Status error(process->Detach(keep_stopped)); 806 if (error.Success()) { 807 result.SetStatus(eReturnStatusSuccessFinishResult); 808 } else { 809 result.AppendErrorWithFormat("Detach failed: %s\n", error.AsCString()); 810 } 811 } 812 813 CommandOptions m_options; 814 }; 815 816 // CommandObjectProcessConnect 817 #define LLDB_OPTIONS_process_connect 818 #include "CommandOptions.inc" 819 820 #pragma mark CommandObjectProcessConnect 821 822 class CommandObjectProcessConnect : public CommandObjectParsed { 823 public: 824 class CommandOptions : public Options { 825 public: 826 CommandOptions() { 827 // Keep default values of all options in one place: OptionParsingStarting 828 // () 829 OptionParsingStarting(nullptr); 830 } 831 832 ~CommandOptions() override = default; 833 834 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 835 ExecutionContext *execution_context) override { 836 Status error; 837 const int short_option = m_getopt_table[option_idx].val; 838 839 switch (short_option) { 840 case 'p': 841 plugin_name.assign(std::string(option_arg)); 842 break; 843 844 default: 845 llvm_unreachable("Unimplemented option"); 846 } 847 return error; 848 } 849 850 void OptionParsingStarting(ExecutionContext *execution_context) override { 851 plugin_name.clear(); 852 } 853 854 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 855 return llvm::ArrayRef(g_process_connect_options); 856 } 857 858 // Instance variables to hold the values for command options. 859 860 std::string plugin_name; 861 }; 862 863 CommandObjectProcessConnect(CommandInterpreter &interpreter) 864 : CommandObjectParsed(interpreter, "process connect", 865 "Connect to a remote debug service.", 866 "process connect <remote-url>", 0) { 867 AddSimpleArgumentList(eArgTypeConnectURL); 868 } 869 870 ~CommandObjectProcessConnect() override = default; 871 872 Options *GetOptions() override { return &m_options; } 873 874 protected: 875 void DoExecute(Args &command, CommandReturnObject &result) override { 876 if (command.GetArgumentCount() != 1) { 877 result.AppendErrorWithFormat( 878 "'%s' takes exactly one argument:\nUsage: %s\n", m_cmd_name.c_str(), 879 m_cmd_syntax.c_str()); 880 return; 881 } 882 883 Process *process = m_exe_ctx.GetProcessPtr(); 884 if (process && process->IsAlive()) { 885 result.AppendErrorWithFormat( 886 "Process %" PRIu64 887 " is currently being debugged, kill the process before connecting.\n", 888 process->GetID()); 889 return; 890 } 891 892 const char *plugin_name = nullptr; 893 if (!m_options.plugin_name.empty()) 894 plugin_name = m_options.plugin_name.c_str(); 895 896 Status error; 897 Debugger &debugger = GetDebugger(); 898 PlatformSP platform_sp = m_interpreter.GetPlatform(true); 899 ProcessSP process_sp = 900 debugger.GetAsyncExecution() 901 ? platform_sp->ConnectProcess( 902 command.GetArgumentAtIndex(0), plugin_name, debugger, 903 debugger.GetSelectedTarget().get(), error) 904 : platform_sp->ConnectProcessSynchronous( 905 command.GetArgumentAtIndex(0), plugin_name, debugger, 906 result.GetOutputStream(), debugger.GetSelectedTarget().get(), 907 error); 908 if (error.Fail() || process_sp == nullptr) { 909 result.AppendError(error.AsCString("Error connecting to the process")); 910 } 911 } 912 913 CommandOptions m_options; 914 }; 915 916 // CommandObjectProcessPlugin 917 #pragma mark CommandObjectProcessPlugin 918 919 class CommandObjectProcessPlugin : public CommandObjectProxy { 920 public: 921 CommandObjectProcessPlugin(CommandInterpreter &interpreter) 922 : CommandObjectProxy( 923 interpreter, "process plugin", 924 "Send a custom command to the current target process plug-in.", 925 "process plugin <args>", 0) {} 926 927 ~CommandObjectProcessPlugin() override = default; 928 929 CommandObject *GetProxyCommandObject() override { 930 Process *process = m_interpreter.GetExecutionContext().GetProcessPtr(); 931 if (process) 932 return process->GetPluginCommandObject(); 933 return nullptr; 934 } 935 }; 936 937 // CommandObjectProcessLoad 938 #define LLDB_OPTIONS_process_load 939 #include "CommandOptions.inc" 940 941 #pragma mark CommandObjectProcessLoad 942 943 class CommandObjectProcessLoad : public CommandObjectParsed { 944 public: 945 class CommandOptions : public Options { 946 public: 947 CommandOptions() { 948 // Keep default values of all options in one place: OptionParsingStarting 949 // () 950 OptionParsingStarting(nullptr); 951 } 952 953 ~CommandOptions() override = default; 954 955 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 956 ExecutionContext *execution_context) override { 957 Status error; 958 const int short_option = m_getopt_table[option_idx].val; 959 ArchSpec arch = 960 execution_context->GetProcessPtr()->GetSystemArchitecture(); 961 switch (short_option) { 962 case 'i': 963 do_install = true; 964 if (!option_arg.empty()) 965 install_path.SetFile(option_arg, arch.GetTriple()); 966 break; 967 default: 968 llvm_unreachable("Unimplemented option"); 969 } 970 return error; 971 } 972 973 void OptionParsingStarting(ExecutionContext *execution_context) override { 974 do_install = false; 975 install_path.Clear(); 976 } 977 978 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 979 return llvm::ArrayRef(g_process_load_options); 980 } 981 982 // Instance variables to hold the values for command options. 983 bool do_install; 984 FileSpec install_path; 985 }; 986 987 CommandObjectProcessLoad(CommandInterpreter &interpreter) 988 : CommandObjectParsed(interpreter, "process load", 989 "Load a shared library into the current process.", 990 "process load <filename> [<filename> ...]", 991 eCommandRequiresProcess | eCommandTryTargetAPILock | 992 eCommandProcessMustBeLaunched | 993 eCommandProcessMustBePaused) { 994 AddSimpleArgumentList(eArgTypePath, eArgRepeatPlus); 995 } 996 997 ~CommandObjectProcessLoad() override = default; 998 999 void 1000 HandleArgumentCompletion(CompletionRequest &request, 1001 OptionElementVector &opt_element_vector) override { 1002 if (!m_exe_ctx.HasProcessScope()) 1003 return; 1004 CommandObject::HandleArgumentCompletion(request, opt_element_vector); 1005 } 1006 1007 Options *GetOptions() override { return &m_options; } 1008 1009 protected: 1010 void DoExecute(Args &command, CommandReturnObject &result) override { 1011 Process *process = m_exe_ctx.GetProcessPtr(); 1012 1013 for (auto &entry : command.entries()) { 1014 Status error; 1015 PlatformSP platform = process->GetTarget().GetPlatform(); 1016 llvm::StringRef image_path = entry.ref(); 1017 uint32_t image_token = LLDB_INVALID_IMAGE_TOKEN; 1018 1019 if (!m_options.do_install) { 1020 FileSpec image_spec(image_path); 1021 platform->ResolveRemotePath(image_spec, image_spec); 1022 image_token = 1023 platform->LoadImage(process, FileSpec(), image_spec, error); 1024 } else if (m_options.install_path) { 1025 FileSpec image_spec(image_path); 1026 FileSystem::Instance().Resolve(image_spec); 1027 platform->ResolveRemotePath(m_options.install_path, 1028 m_options.install_path); 1029 image_token = platform->LoadImage(process, image_spec, 1030 m_options.install_path, error); 1031 } else { 1032 FileSpec image_spec(image_path); 1033 FileSystem::Instance().Resolve(image_spec); 1034 image_token = 1035 platform->LoadImage(process, image_spec, FileSpec(), error); 1036 } 1037 1038 if (image_token != LLDB_INVALID_IMAGE_TOKEN) { 1039 result.AppendMessageWithFormat( 1040 "Loading \"%s\"...ok\nImage %u loaded.\n", image_path.str().c_str(), 1041 image_token); 1042 result.SetStatus(eReturnStatusSuccessFinishResult); 1043 } else { 1044 result.AppendErrorWithFormat("failed to load '%s': %s", 1045 image_path.str().c_str(), 1046 error.AsCString()); 1047 } 1048 } 1049 } 1050 1051 CommandOptions m_options; 1052 }; 1053 1054 // CommandObjectProcessUnload 1055 #pragma mark CommandObjectProcessUnload 1056 1057 class CommandObjectProcessUnload : public CommandObjectParsed { 1058 public: 1059 CommandObjectProcessUnload(CommandInterpreter &interpreter) 1060 : CommandObjectParsed( 1061 interpreter, "process unload", 1062 "Unload a shared library from the current process using the index " 1063 "returned by a previous call to \"process load\".", 1064 "process unload <index>", 1065 eCommandRequiresProcess | eCommandTryTargetAPILock | 1066 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) { 1067 AddSimpleArgumentList(eArgTypeUnsignedInteger); 1068 } 1069 1070 ~CommandObjectProcessUnload() override = default; 1071 1072 void 1073 HandleArgumentCompletion(CompletionRequest &request, 1074 OptionElementVector &opt_element_vector) override { 1075 1076 if (request.GetCursorIndex() || !m_exe_ctx.HasProcessScope()) 1077 return; 1078 1079 Process *process = m_exe_ctx.GetProcessPtr(); 1080 1081 const std::vector<lldb::addr_t> &tokens = process->GetImageTokens(); 1082 const size_t token_num = tokens.size(); 1083 for (size_t i = 0; i < token_num; ++i) { 1084 if (tokens[i] == LLDB_INVALID_IMAGE_TOKEN) 1085 continue; 1086 request.TryCompleteCurrentArg(std::to_string(i)); 1087 } 1088 } 1089 1090 protected: 1091 void DoExecute(Args &command, CommandReturnObject &result) override { 1092 Process *process = m_exe_ctx.GetProcessPtr(); 1093 1094 for (auto &entry : command.entries()) { 1095 uint32_t image_token; 1096 if (entry.ref().getAsInteger(0, image_token)) { 1097 result.AppendErrorWithFormat("invalid image index argument '%s'", 1098 entry.ref().str().c_str()); 1099 break; 1100 } else { 1101 Status error(process->GetTarget().GetPlatform()->UnloadImage( 1102 process, image_token)); 1103 if (error.Success()) { 1104 result.AppendMessageWithFormat( 1105 "Unloading shared library with index %u...ok\n", image_token); 1106 result.SetStatus(eReturnStatusSuccessFinishResult); 1107 } else { 1108 result.AppendErrorWithFormat("failed to unload image: %s", 1109 error.AsCString()); 1110 break; 1111 } 1112 } 1113 } 1114 } 1115 }; 1116 1117 // CommandObjectProcessSignal 1118 #pragma mark CommandObjectProcessSignal 1119 1120 class CommandObjectProcessSignal : public CommandObjectParsed { 1121 public: 1122 CommandObjectProcessSignal(CommandInterpreter &interpreter) 1123 : CommandObjectParsed( 1124 interpreter, "process signal", 1125 "Send a UNIX signal to the current target process.", nullptr, 1126 eCommandRequiresProcess | eCommandTryTargetAPILock) { 1127 AddSimpleArgumentList(eArgTypeUnixSignal); 1128 } 1129 1130 ~CommandObjectProcessSignal() override = default; 1131 1132 void 1133 HandleArgumentCompletion(CompletionRequest &request, 1134 OptionElementVector &opt_element_vector) override { 1135 if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0) 1136 return; 1137 1138 UnixSignalsSP signals = m_exe_ctx.GetProcessPtr()->GetUnixSignals(); 1139 int signo = signals->GetFirstSignalNumber(); 1140 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1141 request.TryCompleteCurrentArg(signals->GetSignalAsStringRef(signo)); 1142 signo = signals->GetNextSignalNumber(signo); 1143 } 1144 } 1145 1146 protected: 1147 void DoExecute(Args &command, CommandReturnObject &result) override { 1148 Process *process = m_exe_ctx.GetProcessPtr(); 1149 1150 if (command.GetArgumentCount() == 1) { 1151 int signo = LLDB_INVALID_SIGNAL_NUMBER; 1152 1153 const char *signal_name = command.GetArgumentAtIndex(0); 1154 if (::isxdigit(signal_name[0])) { 1155 if (!llvm::to_integer(signal_name, signo)) 1156 signo = LLDB_INVALID_SIGNAL_NUMBER; 1157 } else 1158 signo = process->GetUnixSignals()->GetSignalNumberFromName(signal_name); 1159 1160 if (signo == LLDB_INVALID_SIGNAL_NUMBER) { 1161 result.AppendErrorWithFormat("Invalid signal argument '%s'.\n", 1162 command.GetArgumentAtIndex(0)); 1163 } else { 1164 Status error(process->Signal(signo)); 1165 if (error.Success()) { 1166 result.SetStatus(eReturnStatusSuccessFinishResult); 1167 } else { 1168 result.AppendErrorWithFormat("Failed to send signal %i: %s\n", signo, 1169 error.AsCString()); 1170 } 1171 } 1172 } else { 1173 result.AppendErrorWithFormat( 1174 "'%s' takes exactly one signal number argument:\nUsage: %s\n", 1175 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1176 } 1177 } 1178 }; 1179 1180 // CommandObjectProcessInterrupt 1181 #pragma mark CommandObjectProcessInterrupt 1182 1183 class CommandObjectProcessInterrupt : public CommandObjectParsed { 1184 public: 1185 CommandObjectProcessInterrupt(CommandInterpreter &interpreter) 1186 : CommandObjectParsed(interpreter, "process interrupt", 1187 "Interrupt the current target process.", 1188 "process interrupt", 1189 eCommandRequiresProcess | eCommandTryTargetAPILock | 1190 eCommandProcessMustBeLaunched) {} 1191 1192 ~CommandObjectProcessInterrupt() override = default; 1193 1194 protected: 1195 void DoExecute(Args &command, CommandReturnObject &result) override { 1196 Process *process = m_exe_ctx.GetProcessPtr(); 1197 if (process == nullptr) { 1198 result.AppendError("no process to halt"); 1199 return; 1200 } 1201 1202 bool clear_thread_plans = true; 1203 Status error(process->Halt(clear_thread_plans)); 1204 if (error.Success()) { 1205 result.SetStatus(eReturnStatusSuccessFinishResult); 1206 } else { 1207 result.AppendErrorWithFormat("Failed to halt process: %s\n", 1208 error.AsCString()); 1209 } 1210 } 1211 }; 1212 1213 // CommandObjectProcessKill 1214 #pragma mark CommandObjectProcessKill 1215 1216 class CommandObjectProcessKill : public CommandObjectParsed { 1217 public: 1218 CommandObjectProcessKill(CommandInterpreter &interpreter) 1219 : CommandObjectParsed(interpreter, "process kill", 1220 "Terminate the current target process.", 1221 "process kill", 1222 eCommandRequiresProcess | eCommandTryTargetAPILock | 1223 eCommandProcessMustBeLaunched) {} 1224 1225 ~CommandObjectProcessKill() override = default; 1226 1227 protected: 1228 void DoExecute(Args &command, CommandReturnObject &result) override { 1229 Process *process = m_exe_ctx.GetProcessPtr(); 1230 if (process == nullptr) { 1231 result.AppendError("no process to kill"); 1232 return; 1233 } 1234 1235 Status error(process->Destroy(true)); 1236 if (error.Success()) { 1237 result.SetStatus(eReturnStatusSuccessFinishResult); 1238 } else { 1239 result.AppendErrorWithFormat("Failed to kill process: %s\n", 1240 error.AsCString()); 1241 } 1242 } 1243 }; 1244 1245 #define LLDB_OPTIONS_process_save_core 1246 #include "CommandOptions.inc" 1247 1248 class CommandObjectProcessSaveCore : public CommandObjectParsed { 1249 public: 1250 CommandObjectProcessSaveCore(CommandInterpreter &interpreter) 1251 : CommandObjectParsed( 1252 interpreter, "process save-core", 1253 "Save the current process as a core file using an " 1254 "appropriate file type.", 1255 "process save-core [-s corefile-style -p plugin-name] FILE", 1256 eCommandRequiresProcess | eCommandTryTargetAPILock | 1257 eCommandProcessMustBeLaunched) { 1258 AddSimpleArgumentList(eArgTypePath); 1259 } 1260 1261 ~CommandObjectProcessSaveCore() override = default; 1262 1263 Options *GetOptions() override { return &m_options; } 1264 1265 class CommandOptions : public Options { 1266 public: 1267 CommandOptions() = default; 1268 1269 ~CommandOptions() override = default; 1270 1271 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1272 return llvm::ArrayRef(g_process_save_core_options); 1273 } 1274 1275 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1276 ExecutionContext *execution_context) override { 1277 const int short_option = m_getopt_table[option_idx].val; 1278 Status error; 1279 1280 switch (short_option) { 1281 case 'p': 1282 error = m_core_dump_options.SetPluginName(option_arg.data()); 1283 break; 1284 case 's': 1285 m_core_dump_options.SetStyle( 1286 (lldb::SaveCoreStyle)OptionArgParser::ToOptionEnum( 1287 option_arg, GetDefinitions()[option_idx].enum_values, 1288 eSaveCoreUnspecified, error)); 1289 break; 1290 default: 1291 llvm_unreachable("Unimplemented option"); 1292 } 1293 1294 return {}; 1295 } 1296 1297 void OptionParsingStarting(ExecutionContext *execution_context) override { 1298 m_core_dump_options.Clear(); 1299 } 1300 1301 // Instance variables to hold the values for command options. 1302 SaveCoreOptions m_core_dump_options; 1303 }; 1304 1305 protected: 1306 void DoExecute(Args &command, CommandReturnObject &result) override { 1307 ProcessSP process_sp = m_exe_ctx.GetProcessSP(); 1308 if (process_sp) { 1309 if (command.GetArgumentCount() == 1) { 1310 FileSpec output_file(command.GetArgumentAtIndex(0)); 1311 FileSystem::Instance().Resolve(output_file); 1312 auto &core_dump_options = m_options.m_core_dump_options; 1313 core_dump_options.SetOutputFile(output_file); 1314 Status error = PluginManager::SaveCore(process_sp, core_dump_options); 1315 if (error.Success()) { 1316 if (core_dump_options.GetStyle() == 1317 SaveCoreStyle::eSaveCoreDirtyOnly || 1318 core_dump_options.GetStyle() == 1319 SaveCoreStyle::eSaveCoreStackOnly) { 1320 result.AppendMessageWithFormat( 1321 "\nModified-memory or stack-memory only corefile " 1322 "created. This corefile may \n" 1323 "not show library/framework/app binaries " 1324 "on a different system, or when \n" 1325 "those binaries have " 1326 "been updated/modified. Copies are not included\n" 1327 "in this corefile. Use --style full to include all " 1328 "process memory.\n"); 1329 } 1330 result.SetStatus(eReturnStatusSuccessFinishResult); 1331 } else { 1332 result.AppendErrorWithFormat( 1333 "Failed to save core file for process: %s\n", error.AsCString()); 1334 } 1335 } else { 1336 result.AppendErrorWithFormat("'%s' takes one arguments:\nUsage: %s\n", 1337 m_cmd_name.c_str(), m_cmd_syntax.c_str()); 1338 } 1339 } else { 1340 result.AppendError("invalid process"); 1341 } 1342 } 1343 1344 CommandOptions m_options; 1345 }; 1346 1347 // CommandObjectProcessStatus 1348 #pragma mark CommandObjectProcessStatus 1349 #define LLDB_OPTIONS_process_status 1350 #include "CommandOptions.inc" 1351 1352 class CommandObjectProcessStatus : public CommandObjectParsed { 1353 public: 1354 CommandObjectProcessStatus(CommandInterpreter &interpreter) 1355 : CommandObjectParsed( 1356 interpreter, "process status", 1357 "Show status and stop location for the current target process.", 1358 "process status", 1359 eCommandRequiresProcess | eCommandTryTargetAPILock) {} 1360 1361 ~CommandObjectProcessStatus() override = default; 1362 1363 Options *GetOptions() override { return &m_options; } 1364 1365 class CommandOptions : public Options { 1366 public: 1367 CommandOptions() = default; 1368 1369 ~CommandOptions() override = default; 1370 1371 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1372 ExecutionContext *execution_context) override { 1373 const int short_option = m_getopt_table[option_idx].val; 1374 1375 switch (short_option) { 1376 case 'v': 1377 m_verbose = true; 1378 break; 1379 default: 1380 llvm_unreachable("Unimplemented option"); 1381 } 1382 1383 return {}; 1384 } 1385 1386 void OptionParsingStarting(ExecutionContext *execution_context) override { 1387 m_verbose = false; 1388 } 1389 1390 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1391 return llvm::ArrayRef(g_process_status_options); 1392 } 1393 1394 // Instance variables to hold the values for command options. 1395 bool m_verbose = false; 1396 }; 1397 1398 protected: 1399 void DoExecute(Args &command, CommandReturnObject &result) override { 1400 Stream &strm = result.GetOutputStream(); 1401 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1402 1403 // No need to check "process" for validity as eCommandRequiresProcess 1404 // ensures it is valid 1405 Process *process = m_exe_ctx.GetProcessPtr(); 1406 const bool only_threads_with_stop_reason = true; 1407 const uint32_t start_frame = 0; 1408 const uint32_t num_frames = 1; 1409 const uint32_t num_frames_with_source = 1; 1410 const bool stop_format = true; 1411 process->GetStatus(strm); 1412 process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame, 1413 num_frames, num_frames_with_source, stop_format); 1414 1415 if (m_options.m_verbose) { 1416 addr_t code_mask = process->GetCodeAddressMask(); 1417 addr_t data_mask = process->GetDataAddressMask(); 1418 if (code_mask != LLDB_INVALID_ADDRESS_MASK) { 1419 int bits = std::bitset<64>(~code_mask).count(); 1420 result.AppendMessageWithFormat( 1421 "Addressable code address mask: 0x%" PRIx64 "\n", code_mask); 1422 result.AppendMessageWithFormat( 1423 "Addressable data address mask: 0x%" PRIx64 "\n", data_mask); 1424 result.AppendMessageWithFormat( 1425 "Number of bits used in addressing (code): %d\n", bits); 1426 } 1427 1428 PlatformSP platform_sp = process->GetTarget().GetPlatform(); 1429 if (!platform_sp) { 1430 result.AppendError("Couldn't retrieve the target's platform"); 1431 return; 1432 } 1433 1434 auto expected_crash_info = 1435 platform_sp->FetchExtendedCrashInformation(*process); 1436 1437 if (!expected_crash_info) { 1438 result.AppendError(llvm::toString(expected_crash_info.takeError())); 1439 return; 1440 } 1441 1442 StructuredData::DictionarySP crash_info_sp = *expected_crash_info; 1443 1444 if (crash_info_sp) { 1445 strm.EOL(); 1446 strm.PutCString("Extended Crash Information:\n"); 1447 crash_info_sp->GetDescription(strm); 1448 } 1449 } 1450 } 1451 1452 private: 1453 CommandOptions m_options; 1454 }; 1455 1456 // CommandObjectProcessHandle 1457 #define LLDB_OPTIONS_process_handle 1458 #include "CommandOptions.inc" 1459 1460 #pragma mark CommandObjectProcessHandle 1461 1462 class CommandObjectProcessHandle : public CommandObjectParsed { 1463 public: 1464 class CommandOptions : public Options { 1465 public: 1466 CommandOptions() { OptionParsingStarting(nullptr); } 1467 1468 ~CommandOptions() override = default; 1469 1470 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1471 ExecutionContext *execution_context) override { 1472 Status error; 1473 const int short_option = m_getopt_table[option_idx].val; 1474 1475 switch (short_option) { 1476 case 'c': 1477 do_clear = true; 1478 break; 1479 case 'd': 1480 dummy = true; 1481 break; 1482 case 's': 1483 stop = std::string(option_arg); 1484 break; 1485 case 'n': 1486 notify = std::string(option_arg); 1487 break; 1488 case 'p': 1489 pass = std::string(option_arg); 1490 break; 1491 case 't': 1492 only_target_values = true; 1493 break; 1494 default: 1495 llvm_unreachable("Unimplemented option"); 1496 } 1497 return error; 1498 } 1499 1500 void OptionParsingStarting(ExecutionContext *execution_context) override { 1501 stop.clear(); 1502 notify.clear(); 1503 pass.clear(); 1504 only_target_values = false; 1505 do_clear = false; 1506 dummy = false; 1507 } 1508 1509 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1510 return llvm::ArrayRef(g_process_handle_options); 1511 } 1512 1513 // Instance variables to hold the values for command options. 1514 1515 std::string stop; 1516 std::string notify; 1517 std::string pass; 1518 bool only_target_values = false; 1519 bool do_clear = false; 1520 bool dummy = false; 1521 }; 1522 1523 CommandObjectProcessHandle(CommandInterpreter &interpreter) 1524 : CommandObjectParsed(interpreter, "process handle", 1525 "Manage LLDB handling of OS signals for the " 1526 "current target process. Defaults to showing " 1527 "current policy.", 1528 nullptr) { 1529 SetHelpLong("\nIf no signals are specified but one or more actions are, " 1530 "and there is a live process, update them all. If no action " 1531 "is specified, list the current values.\n" 1532 "If you specify actions with no target (e.g. in an init file) " 1533 "or in a target with no process " 1534 "the values will get copied into subsequent targets, but " 1535 "lldb won't be able to spell-check the options since it can't " 1536 "know which signal set will later be in force." 1537 "\nYou can see the signal modifications held by the target" 1538 "by passing the -t option." 1539 "\nYou can also clear the target modification for a signal" 1540 "by passing the -c option"); 1541 AddSimpleArgumentList(eArgTypeUnixSignal, eArgRepeatStar); 1542 } 1543 1544 ~CommandObjectProcessHandle() override = default; 1545 1546 Options *GetOptions() override { return &m_options; } 1547 1548 void PrintSignalHeader(Stream &str) { 1549 str.Printf("NAME PASS STOP NOTIFY\n"); 1550 str.Printf("=========== ===== ===== ======\n"); 1551 } 1552 1553 void PrintSignal(Stream &str, int32_t signo, llvm::StringRef sig_name, 1554 const UnixSignalsSP &signals_sp) { 1555 bool stop; 1556 bool suppress; 1557 bool notify; 1558 1559 str.Format("{0, -11} ", sig_name); 1560 if (signals_sp->GetSignalInfo(signo, suppress, stop, notify)) { 1561 bool pass = !suppress; 1562 str.Printf("%s %s %s", (pass ? "true " : "false"), 1563 (stop ? "true " : "false"), (notify ? "true " : "false")); 1564 } 1565 str.Printf("\n"); 1566 } 1567 1568 void PrintSignalInformation(Stream &str, Args &signal_args, 1569 int num_valid_signals, 1570 const UnixSignalsSP &signals_sp) { 1571 PrintSignalHeader(str); 1572 1573 if (num_valid_signals > 0) { 1574 size_t num_args = signal_args.GetArgumentCount(); 1575 for (size_t i = 0; i < num_args; ++i) { 1576 int32_t signo = signals_sp->GetSignalNumberFromName( 1577 signal_args.GetArgumentAtIndex(i)); 1578 if (signo != LLDB_INVALID_SIGNAL_NUMBER) 1579 PrintSignal(str, signo, signal_args.GetArgumentAtIndex(i), 1580 signals_sp); 1581 } 1582 } else // Print info for ALL signals 1583 { 1584 int32_t signo = signals_sp->GetFirstSignalNumber(); 1585 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1586 PrintSignal(str, signo, signals_sp->GetSignalAsStringRef(signo), 1587 signals_sp); 1588 signo = signals_sp->GetNextSignalNumber(signo); 1589 } 1590 } 1591 } 1592 1593 protected: 1594 void DoExecute(Args &signal_args, CommandReturnObject &result) override { 1595 Target &target = GetTarget(); 1596 1597 // Any signals that are being set should be added to the Target's 1598 // DummySignals so they will get applied on rerun, etc. 1599 // If we have a process, however, we can do a more accurate job of vetting 1600 // the user's options. 1601 ProcessSP process_sp = target.GetProcessSP(); 1602 1603 std::optional<bool> stop_action = {}; 1604 std::optional<bool> pass_action = {}; 1605 std::optional<bool> notify_action = {}; 1606 1607 if (!m_options.stop.empty()) { 1608 bool success = false; 1609 bool value = OptionArgParser::ToBoolean(m_options.stop, false, &success); 1610 if (!success) { 1611 result.AppendError( 1612 "Invalid argument for command option --stop; must be " 1613 "true or false.\n"); 1614 return; 1615 } 1616 1617 stop_action = value; 1618 } 1619 1620 if (!m_options.pass.empty()) { 1621 bool success = false; 1622 bool value = OptionArgParser::ToBoolean(m_options.pass, false, &success); 1623 if (!success) { 1624 result.AppendError( 1625 "Invalid argument for command option --pass; must be " 1626 "true or false.\n"); 1627 return; 1628 } 1629 pass_action = value; 1630 } 1631 1632 if (!m_options.notify.empty()) { 1633 bool success = false; 1634 bool value = 1635 OptionArgParser::ToBoolean(m_options.notify, false, &success); 1636 if (!success) { 1637 result.AppendError("Invalid argument for command option --notify; must " 1638 "be true or false.\n"); 1639 return; 1640 } 1641 notify_action = value; 1642 } 1643 1644 if (!m_options.notify.empty() && !notify_action.has_value()) { 1645 } 1646 1647 bool no_actions = (!stop_action.has_value() && !pass_action.has_value() && 1648 !notify_action.has_value()); 1649 if (m_options.only_target_values && !no_actions) { 1650 result.AppendError("-t is for reporting, not setting, target values."); 1651 return; 1652 } 1653 1654 size_t num_args = signal_args.GetArgumentCount(); 1655 UnixSignalsSP signals_sp; 1656 if (process_sp) 1657 signals_sp = process_sp->GetUnixSignals(); 1658 1659 int num_signals_set = 0; 1660 1661 // If we were just asked to print the target values, do that here and 1662 // return: 1663 if (m_options.only_target_values) { 1664 target.PrintDummySignals(result.GetOutputStream(), signal_args); 1665 result.SetStatus(eReturnStatusSuccessFinishResult); 1666 return; 1667 } 1668 1669 // This handles clearing values: 1670 if (m_options.do_clear) { 1671 target.ClearDummySignals(signal_args); 1672 if (m_options.dummy) 1673 GetDummyTarget().ClearDummySignals(signal_args); 1674 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1675 return; 1676 } 1677 1678 // This rest handles setting values: 1679 if (num_args > 0) { 1680 for (const auto &arg : signal_args) { 1681 // Do the process first. If we have a process we can catch 1682 // invalid signal names, which we do here. 1683 if (signals_sp) { 1684 int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str()); 1685 if (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1686 if (stop_action.has_value()) 1687 signals_sp->SetShouldStop(signo, *stop_action); 1688 if (pass_action.has_value()) { 1689 bool suppress = !*pass_action; 1690 signals_sp->SetShouldSuppress(signo, suppress); 1691 } 1692 if (notify_action.has_value()) 1693 signals_sp->SetShouldNotify(signo, *notify_action); 1694 ++num_signals_set; 1695 } else { 1696 result.AppendErrorWithFormat("Invalid signal name '%s'\n", 1697 arg.c_str()); 1698 continue; 1699 } 1700 } else { 1701 // If there's no process we can't check, so we just set them all. 1702 // But since the map signal name -> signal number across all platforms 1703 // is not 1-1, we can't sensibly set signal actions by number before 1704 // we have a process. Check that here: 1705 int32_t signo; 1706 if (llvm::to_integer(arg.c_str(), signo)) { 1707 result.AppendErrorWithFormat("Can't set signal handling by signal " 1708 "number with no process"); 1709 return; 1710 } 1711 num_signals_set = num_args; 1712 } 1713 auto set_lazy_bool = [](std::optional<bool> action) -> LazyBool { 1714 if (!action.has_value()) 1715 return eLazyBoolCalculate; 1716 return (*action) ? eLazyBoolYes : eLazyBoolNo; 1717 }; 1718 1719 // If there were no actions, we're just listing, don't add the dummy: 1720 if (!no_actions) 1721 target.AddDummySignal(arg.ref(), set_lazy_bool(pass_action), 1722 set_lazy_bool(notify_action), 1723 set_lazy_bool(stop_action)); 1724 } 1725 } else { 1726 // No signal specified, if any command options were specified, update ALL 1727 // signals. But we can't do this without a process since we don't know 1728 // all the possible signals that might be valid for this target. 1729 if ((notify_action.has_value() || stop_action.has_value() || 1730 pass_action.has_value()) && 1731 process_sp) { 1732 if (m_interpreter.Confirm( 1733 "Do you really want to update all the signals?", false)) { 1734 int32_t signo = signals_sp->GetFirstSignalNumber(); 1735 while (signo != LLDB_INVALID_SIGNAL_NUMBER) { 1736 if (notify_action.has_value()) 1737 signals_sp->SetShouldNotify(signo, *notify_action); 1738 if (stop_action.has_value()) 1739 signals_sp->SetShouldStop(signo, *stop_action); 1740 if (pass_action.has_value()) { 1741 bool suppress = !*pass_action; 1742 signals_sp->SetShouldSuppress(signo, suppress); 1743 } 1744 signo = signals_sp->GetNextSignalNumber(signo); 1745 } 1746 } 1747 } 1748 } 1749 1750 if (signals_sp) 1751 PrintSignalInformation(result.GetOutputStream(), signal_args, 1752 num_signals_set, signals_sp); 1753 else 1754 target.PrintDummySignals(result.GetOutputStream(), 1755 signal_args); 1756 1757 if (num_signals_set > 0) 1758 result.SetStatus(eReturnStatusSuccessFinishResult); 1759 else 1760 result.SetStatus(eReturnStatusFailed); 1761 } 1762 1763 CommandOptions m_options; 1764 }; 1765 1766 // Next are the subcommands of CommandObjectMultiwordProcessTrace 1767 1768 // CommandObjectProcessTraceStart 1769 class CommandObjectProcessTraceStart : public CommandObjectTraceProxy { 1770 public: 1771 CommandObjectProcessTraceStart(CommandInterpreter &interpreter) 1772 : CommandObjectTraceProxy( 1773 /*live_debug_session_only*/ true, interpreter, 1774 "process trace start", 1775 "Start tracing this process with the corresponding trace " 1776 "plug-in.", 1777 "process trace start [<trace-options>]") {} 1778 1779 protected: 1780 lldb::CommandObjectSP GetDelegateCommand(Trace &trace) override { 1781 return trace.GetProcessTraceStartCommand(m_interpreter); 1782 } 1783 }; 1784 1785 // CommandObjectProcessTraceStop 1786 class CommandObjectProcessTraceStop : public CommandObjectParsed { 1787 public: 1788 CommandObjectProcessTraceStop(CommandInterpreter &interpreter) 1789 : CommandObjectParsed(interpreter, "process trace stop", 1790 "Stop tracing this process. This does not affect " 1791 "traces started with the " 1792 "\"thread trace start\" command.", 1793 "process trace stop", 1794 eCommandRequiresProcess | eCommandTryTargetAPILock | 1795 eCommandProcessMustBeLaunched | 1796 eCommandProcessMustBePaused | 1797 eCommandProcessMustBeTraced) {} 1798 1799 ~CommandObjectProcessTraceStop() override = default; 1800 1801 void DoExecute(Args &command, CommandReturnObject &result) override { 1802 ProcessSP process_sp = m_exe_ctx.GetProcessSP(); 1803 1804 TraceSP trace_sp = process_sp->GetTarget().GetTrace(); 1805 1806 if (llvm::Error err = trace_sp->Stop()) 1807 result.AppendError(toString(std::move(err))); 1808 else 1809 result.SetStatus(eReturnStatusSuccessFinishResult); 1810 } 1811 }; 1812 1813 // CommandObjectMultiwordProcessTrace 1814 class CommandObjectMultiwordProcessTrace : public CommandObjectMultiword { 1815 public: 1816 CommandObjectMultiwordProcessTrace(CommandInterpreter &interpreter) 1817 : CommandObjectMultiword( 1818 interpreter, "trace", "Commands for tracing the current process.", 1819 "process trace <subcommand> [<subcommand objects>]") { 1820 LoadSubCommand("start", CommandObjectSP(new CommandObjectProcessTraceStart( 1821 interpreter))); 1822 LoadSubCommand("stop", CommandObjectSP( 1823 new CommandObjectProcessTraceStop(interpreter))); 1824 } 1825 1826 ~CommandObjectMultiwordProcessTrace() override = default; 1827 }; 1828 1829 // CommandObjectMultiwordProcess 1830 1831 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess( 1832 CommandInterpreter &interpreter) 1833 : CommandObjectMultiword( 1834 interpreter, "process", 1835 "Commands for interacting with processes on the current platform.", 1836 "process <subcommand> [<subcommand-options>]") { 1837 LoadSubCommand("attach", 1838 CommandObjectSP(new CommandObjectProcessAttach(interpreter))); 1839 LoadSubCommand("launch", 1840 CommandObjectSP(new CommandObjectProcessLaunch(interpreter))); 1841 LoadSubCommand("continue", CommandObjectSP(new CommandObjectProcessContinue( 1842 interpreter))); 1843 LoadSubCommand("connect", 1844 CommandObjectSP(new CommandObjectProcessConnect(interpreter))); 1845 LoadSubCommand("detach", 1846 CommandObjectSP(new CommandObjectProcessDetach(interpreter))); 1847 LoadSubCommand("load", 1848 CommandObjectSP(new CommandObjectProcessLoad(interpreter))); 1849 LoadSubCommand("unload", 1850 CommandObjectSP(new CommandObjectProcessUnload(interpreter))); 1851 LoadSubCommand("signal", 1852 CommandObjectSP(new CommandObjectProcessSignal(interpreter))); 1853 LoadSubCommand("handle", 1854 CommandObjectSP(new CommandObjectProcessHandle(interpreter))); 1855 LoadSubCommand("status", 1856 CommandObjectSP(new CommandObjectProcessStatus(interpreter))); 1857 LoadSubCommand("interrupt", CommandObjectSP(new CommandObjectProcessInterrupt( 1858 interpreter))); 1859 LoadSubCommand("kill", 1860 CommandObjectSP(new CommandObjectProcessKill(interpreter))); 1861 LoadSubCommand("plugin", 1862 CommandObjectSP(new CommandObjectProcessPlugin(interpreter))); 1863 LoadSubCommand("save-core", CommandObjectSP(new CommandObjectProcessSaveCore( 1864 interpreter))); 1865 LoadSubCommand( 1866 "trace", 1867 CommandObjectSP(new CommandObjectMultiwordProcessTrace(interpreter))); 1868 } 1869 1870 CommandObjectMultiwordProcess::~CommandObjectMultiwordProcess() = default; 1871