1 //===-- CommandObjectPlatform.cpp -------------------------------*- C++ -*-===// 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 <mutex> 10 #include "CommandObjectPlatform.h" 11 #include "lldb/Core/Debugger.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/PluginManager.h" 14 #include "lldb/Host/OptionParser.h" 15 #include "lldb/Host/StringConvert.h" 16 #include "lldb/Interpreter/CommandInterpreter.h" 17 #include "lldb/Interpreter/CommandOptionValidators.h" 18 #include "lldb/Interpreter/CommandReturnObject.h" 19 #include "lldb/Interpreter/OptionGroupFile.h" 20 #include "lldb/Interpreter/OptionGroupPlatform.h" 21 #include "lldb/Target/ExecutionContext.h" 22 #include "lldb/Target/Platform.h" 23 #include "lldb/Target/Process.h" 24 #include "lldb/Utility/Args.h" 25 #include "lldb/Utility/DataExtractor.h" 26 27 #include "llvm/ADT/SmallString.h" 28 #include "llvm/Support/Threading.h" 29 30 using namespace lldb; 31 using namespace lldb_private; 32 33 static mode_t ParsePermissionString(const char *) = delete; 34 35 static mode_t ParsePermissionString(llvm::StringRef permissions) { 36 if (permissions.size() != 9) 37 return (mode_t)(-1); 38 bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w, 39 world_x; 40 41 user_r = (permissions[0] == 'r'); 42 user_w = (permissions[1] == 'w'); 43 user_x = (permissions[2] == 'x'); 44 45 group_r = (permissions[3] == 'r'); 46 group_w = (permissions[4] == 'w'); 47 group_x = (permissions[5] == 'x'); 48 49 world_r = (permissions[6] == 'r'); 50 world_w = (permissions[7] == 'w'); 51 world_x = (permissions[8] == 'x'); 52 53 mode_t user, group, world; 54 user = (user_r ? 4 : 0) | (user_w ? 2 : 0) | (user_x ? 1 : 0); 55 group = (group_r ? 4 : 0) | (group_w ? 2 : 0) | (group_x ? 1 : 0); 56 world = (world_r ? 4 : 0) | (world_w ? 2 : 0) | (world_x ? 1 : 0); 57 58 return user | group | world; 59 } 60 61 static constexpr OptionDefinition g_permissions_options[] = { 62 #define LLDB_OPTIONS_permissions 63 #include "CommandOptions.inc" 64 }; 65 66 class OptionPermissions : public OptionGroup { 67 public: 68 OptionPermissions() {} 69 70 ~OptionPermissions() override = default; 71 72 lldb_private::Status 73 SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 74 ExecutionContext *execution_context) override { 75 Status error; 76 char short_option = (char)GetDefinitions()[option_idx].short_option; 77 switch (short_option) { 78 case 'v': { 79 if (option_arg.getAsInteger(8, m_permissions)) { 80 m_permissions = 0777; 81 error.SetErrorStringWithFormat("invalid value for permissions: %s", 82 option_arg.str().c_str()); 83 } 84 85 } break; 86 case 's': { 87 mode_t perms = ParsePermissionString(option_arg); 88 if (perms == (mode_t)-1) 89 error.SetErrorStringWithFormat("invalid value for permissions: %s", 90 option_arg.str().c_str()); 91 else 92 m_permissions = perms; 93 } break; 94 case 'r': 95 m_permissions |= lldb::eFilePermissionsUserRead; 96 break; 97 case 'w': 98 m_permissions |= lldb::eFilePermissionsUserWrite; 99 break; 100 case 'x': 101 m_permissions |= lldb::eFilePermissionsUserExecute; 102 break; 103 case 'R': 104 m_permissions |= lldb::eFilePermissionsGroupRead; 105 break; 106 case 'W': 107 m_permissions |= lldb::eFilePermissionsGroupWrite; 108 break; 109 case 'X': 110 m_permissions |= lldb::eFilePermissionsGroupExecute; 111 break; 112 case 'd': 113 m_permissions |= lldb::eFilePermissionsWorldRead; 114 break; 115 case 't': 116 m_permissions |= lldb::eFilePermissionsWorldWrite; 117 break; 118 case 'e': 119 m_permissions |= lldb::eFilePermissionsWorldExecute; 120 break; 121 default: 122 error.SetErrorStringWithFormat("unrecognized option '%c'", short_option); 123 break; 124 } 125 126 return error; 127 } 128 129 void OptionParsingStarting(ExecutionContext *execution_context) override { 130 m_permissions = 0; 131 } 132 133 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 134 return llvm::makeArrayRef(g_permissions_options); 135 } 136 137 // Instance variables to hold the values for command options. 138 139 uint32_t m_permissions; 140 141 private: 142 DISALLOW_COPY_AND_ASSIGN(OptionPermissions); 143 }; 144 145 // "platform select <platform-name>" 146 class CommandObjectPlatformSelect : public CommandObjectParsed { 147 public: 148 CommandObjectPlatformSelect(CommandInterpreter &interpreter) 149 : CommandObjectParsed(interpreter, "platform select", 150 "Create a platform if needed and select it as the " 151 "current platform.", 152 "platform select <platform-name>", 0), 153 m_option_group(), 154 m_platform_options( 155 false) // Don't include the "--platform" option by passing false 156 { 157 m_option_group.Append(&m_platform_options, LLDB_OPT_SET_ALL, 1); 158 m_option_group.Finalize(); 159 } 160 161 ~CommandObjectPlatformSelect() override = default; 162 163 int HandleCompletion(CompletionRequest &request) override { 164 CommandCompletions::PlatformPluginNames(GetCommandInterpreter(), request, 165 nullptr); 166 return request.GetNumberOfMatches(); 167 } 168 169 Options *GetOptions() override { return &m_option_group; } 170 171 protected: 172 bool DoExecute(Args &args, CommandReturnObject &result) override { 173 if (args.GetArgumentCount() == 1) { 174 const char *platform_name = args.GetArgumentAtIndex(0); 175 if (platform_name && platform_name[0]) { 176 const bool select = true; 177 m_platform_options.SetPlatformName(platform_name); 178 Status error; 179 ArchSpec platform_arch; 180 PlatformSP platform_sp(m_platform_options.CreatePlatformWithOptions( 181 m_interpreter, ArchSpec(), select, error, platform_arch)); 182 if (platform_sp) { 183 GetDebugger().GetPlatformList().SetSelectedPlatform(platform_sp); 184 185 platform_sp->GetStatus(result.GetOutputStream()); 186 result.SetStatus(eReturnStatusSuccessFinishResult); 187 } else { 188 result.AppendError(error.AsCString()); 189 result.SetStatus(eReturnStatusFailed); 190 } 191 } else { 192 result.AppendError("invalid platform name"); 193 result.SetStatus(eReturnStatusFailed); 194 } 195 } else { 196 result.AppendError( 197 "platform create takes a platform name as an argument\n"); 198 result.SetStatus(eReturnStatusFailed); 199 } 200 return result.Succeeded(); 201 } 202 203 OptionGroupOptions m_option_group; 204 OptionGroupPlatform m_platform_options; 205 }; 206 207 // "platform list" 208 class CommandObjectPlatformList : public CommandObjectParsed { 209 public: 210 CommandObjectPlatformList(CommandInterpreter &interpreter) 211 : CommandObjectParsed(interpreter, "platform list", 212 "List all platforms that are available.", nullptr, 213 0) {} 214 215 ~CommandObjectPlatformList() override = default; 216 217 protected: 218 bool DoExecute(Args &args, CommandReturnObject &result) override { 219 Stream &ostrm = result.GetOutputStream(); 220 ostrm.Printf("Available platforms:\n"); 221 222 PlatformSP host_platform_sp(Platform::GetHostPlatform()); 223 ostrm.Printf("%s: %s\n", host_platform_sp->GetPluginName().GetCString(), 224 host_platform_sp->GetDescription()); 225 226 uint32_t idx; 227 for (idx = 0; true; ++idx) { 228 const char *plugin_name = 229 PluginManager::GetPlatformPluginNameAtIndex(idx); 230 if (plugin_name == nullptr) 231 break; 232 const char *plugin_desc = 233 PluginManager::GetPlatformPluginDescriptionAtIndex(idx); 234 if (plugin_desc == nullptr) 235 break; 236 ostrm.Printf("%s: %s\n", plugin_name, plugin_desc); 237 } 238 239 if (idx == 0) { 240 result.AppendError("no platforms are available\n"); 241 result.SetStatus(eReturnStatusFailed); 242 } else 243 result.SetStatus(eReturnStatusSuccessFinishResult); 244 return result.Succeeded(); 245 } 246 }; 247 248 // "platform status" 249 class CommandObjectPlatformStatus : public CommandObjectParsed { 250 public: 251 CommandObjectPlatformStatus(CommandInterpreter &interpreter) 252 : CommandObjectParsed(interpreter, "platform status", 253 "Display status for the current platform.", nullptr, 254 0) {} 255 256 ~CommandObjectPlatformStatus() override = default; 257 258 protected: 259 bool DoExecute(Args &args, CommandReturnObject &result) override { 260 Stream &ostrm = result.GetOutputStream(); 261 262 Target *target = GetDebugger().GetSelectedTarget().get(); 263 PlatformSP platform_sp; 264 if (target) { 265 platform_sp = target->GetPlatform(); 266 } 267 if (!platform_sp) { 268 platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform(); 269 } 270 if (platform_sp) { 271 platform_sp->GetStatus(ostrm); 272 result.SetStatus(eReturnStatusSuccessFinishResult); 273 } else { 274 result.AppendError("no platform is currently selected\n"); 275 result.SetStatus(eReturnStatusFailed); 276 } 277 return result.Succeeded(); 278 } 279 }; 280 281 // "platform connect <connect-url>" 282 class CommandObjectPlatformConnect : public CommandObjectParsed { 283 public: 284 CommandObjectPlatformConnect(CommandInterpreter &interpreter) 285 : CommandObjectParsed( 286 interpreter, "platform connect", 287 "Select the current platform by providing a connection URL.", 288 "platform connect <connect-url>", 0) {} 289 290 ~CommandObjectPlatformConnect() override = default; 291 292 protected: 293 bool DoExecute(Args &args, CommandReturnObject &result) override { 294 Stream &ostrm = result.GetOutputStream(); 295 296 PlatformSP platform_sp( 297 GetDebugger().GetPlatformList().GetSelectedPlatform()); 298 if (platform_sp) { 299 Status error(platform_sp->ConnectRemote(args)); 300 if (error.Success()) { 301 platform_sp->GetStatus(ostrm); 302 result.SetStatus(eReturnStatusSuccessFinishResult); 303 304 platform_sp->ConnectToWaitingProcesses(GetDebugger(), error); 305 if (error.Fail()) { 306 result.AppendError(error.AsCString()); 307 result.SetStatus(eReturnStatusFailed); 308 } 309 } else { 310 result.AppendErrorWithFormat("%s\n", error.AsCString()); 311 result.SetStatus(eReturnStatusFailed); 312 } 313 } else { 314 result.AppendError("no platform is currently selected\n"); 315 result.SetStatus(eReturnStatusFailed); 316 } 317 return result.Succeeded(); 318 } 319 320 Options *GetOptions() override { 321 PlatformSP platform_sp( 322 GetDebugger().GetPlatformList().GetSelectedPlatform()); 323 OptionGroupOptions *m_platform_options = nullptr; 324 if (platform_sp) { 325 m_platform_options = platform_sp->GetConnectionOptions(m_interpreter); 326 if (m_platform_options != nullptr && !m_platform_options->m_did_finalize) 327 m_platform_options->Finalize(); 328 } 329 return m_platform_options; 330 } 331 }; 332 333 // "platform disconnect" 334 class CommandObjectPlatformDisconnect : public CommandObjectParsed { 335 public: 336 CommandObjectPlatformDisconnect(CommandInterpreter &interpreter) 337 : CommandObjectParsed(interpreter, "platform disconnect", 338 "Disconnect from the current platform.", 339 "platform disconnect", 0) {} 340 341 ~CommandObjectPlatformDisconnect() override = default; 342 343 protected: 344 bool DoExecute(Args &args, CommandReturnObject &result) override { 345 PlatformSP platform_sp( 346 GetDebugger().GetPlatformList().GetSelectedPlatform()); 347 if (platform_sp) { 348 if (args.GetArgumentCount() == 0) { 349 Status error; 350 351 if (platform_sp->IsConnected()) { 352 // Cache the instance name if there is one since we are about to 353 // disconnect and the name might go with it. 354 const char *hostname_cstr = platform_sp->GetHostname(); 355 std::string hostname; 356 if (hostname_cstr) 357 hostname.assign(hostname_cstr); 358 359 error = platform_sp->DisconnectRemote(); 360 if (error.Success()) { 361 Stream &ostrm = result.GetOutputStream(); 362 if (hostname.empty()) 363 ostrm.Printf("Disconnected from \"%s\"\n", 364 platform_sp->GetPluginName().GetCString()); 365 else 366 ostrm.Printf("Disconnected from \"%s\"\n", hostname.c_str()); 367 result.SetStatus(eReturnStatusSuccessFinishResult); 368 } else { 369 result.AppendErrorWithFormat("%s", error.AsCString()); 370 result.SetStatus(eReturnStatusFailed); 371 } 372 } else { 373 // Not connected... 374 result.AppendErrorWithFormat( 375 "not connected to '%s'", 376 platform_sp->GetPluginName().GetCString()); 377 result.SetStatus(eReturnStatusFailed); 378 } 379 } else { 380 // Bad args 381 result.AppendError( 382 "\"platform disconnect\" doesn't take any arguments"); 383 result.SetStatus(eReturnStatusFailed); 384 } 385 } else { 386 result.AppendError("no platform is currently selected"); 387 result.SetStatus(eReturnStatusFailed); 388 } 389 return result.Succeeded(); 390 } 391 }; 392 393 // "platform settings" 394 class CommandObjectPlatformSettings : public CommandObjectParsed { 395 public: 396 CommandObjectPlatformSettings(CommandInterpreter &interpreter) 397 : CommandObjectParsed(interpreter, "platform settings", 398 "Set settings for the current target's platform, " 399 "or for a platform by name.", 400 "platform settings", 0), 401 m_options(), 402 m_option_working_dir(LLDB_OPT_SET_1, false, "working-dir", 'w', 0, 403 eArgTypePath, 404 "The working directory for the platform.") { 405 m_options.Append(&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 406 } 407 408 ~CommandObjectPlatformSettings() override = default; 409 410 protected: 411 bool DoExecute(Args &args, CommandReturnObject &result) override { 412 PlatformSP platform_sp( 413 GetDebugger().GetPlatformList().GetSelectedPlatform()); 414 if (platform_sp) { 415 if (m_option_working_dir.GetOptionValue().OptionWasSet()) 416 platform_sp->SetWorkingDirectory( 417 m_option_working_dir.GetOptionValue().GetCurrentValue()); 418 } else { 419 result.AppendError("no platform is currently selected"); 420 result.SetStatus(eReturnStatusFailed); 421 } 422 return result.Succeeded(); 423 } 424 425 Options *GetOptions() override { 426 if (!m_options.DidFinalize()) 427 m_options.Finalize(); 428 return &m_options; 429 } 430 431 protected: 432 OptionGroupOptions m_options; 433 OptionGroupFile m_option_working_dir; 434 }; 435 436 // "platform mkdir" 437 class CommandObjectPlatformMkDir : public CommandObjectParsed { 438 public: 439 CommandObjectPlatformMkDir(CommandInterpreter &interpreter) 440 : CommandObjectParsed(interpreter, "platform mkdir", 441 "Make a new directory on the remote end.", nullptr, 442 0), 443 m_options() {} 444 445 ~CommandObjectPlatformMkDir() override = default; 446 447 bool DoExecute(Args &args, CommandReturnObject &result) override { 448 PlatformSP platform_sp( 449 GetDebugger().GetPlatformList().GetSelectedPlatform()); 450 if (platform_sp) { 451 std::string cmd_line; 452 args.GetCommandString(cmd_line); 453 uint32_t mode; 454 const OptionPermissions *options_permissions = 455 (const OptionPermissions *)m_options.GetGroupWithOption('r'); 456 if (options_permissions) 457 mode = options_permissions->m_permissions; 458 else 459 mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX | 460 lldb::eFilePermissionsWorldRX; 461 Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode); 462 if (error.Success()) { 463 result.SetStatus(eReturnStatusSuccessFinishResult); 464 } else { 465 result.AppendError(error.AsCString()); 466 result.SetStatus(eReturnStatusFailed); 467 } 468 } else { 469 result.AppendError("no platform currently selected\n"); 470 result.SetStatus(eReturnStatusFailed); 471 } 472 return result.Succeeded(); 473 } 474 475 Options *GetOptions() override { 476 if (!m_options.DidFinalize()) { 477 m_options.Append(new OptionPermissions()); 478 m_options.Finalize(); 479 } 480 return &m_options; 481 } 482 483 OptionGroupOptions m_options; 484 }; 485 486 // "platform fopen" 487 class CommandObjectPlatformFOpen : public CommandObjectParsed { 488 public: 489 CommandObjectPlatformFOpen(CommandInterpreter &interpreter) 490 : CommandObjectParsed(interpreter, "platform file open", 491 "Open a file on the remote end.", nullptr, 0), 492 m_options() {} 493 494 ~CommandObjectPlatformFOpen() override = default; 495 496 bool DoExecute(Args &args, CommandReturnObject &result) override { 497 PlatformSP platform_sp( 498 GetDebugger().GetPlatformList().GetSelectedPlatform()); 499 if (platform_sp) { 500 Status error; 501 std::string cmd_line; 502 args.GetCommandString(cmd_line); 503 mode_t perms; 504 const OptionPermissions *options_permissions = 505 (const OptionPermissions *)m_options.GetGroupWithOption('r'); 506 if (options_permissions) 507 perms = options_permissions->m_permissions; 508 else 509 perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW | 510 lldb::eFilePermissionsWorldRead; 511 lldb::user_id_t fd = platform_sp->OpenFile( 512 FileSpec(cmd_line), 513 File::eOpenOptionRead | File::eOpenOptionWrite | 514 File::eOpenOptionAppend | File::eOpenOptionCanCreate, 515 perms, error); 516 if (error.Success()) { 517 result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n", fd); 518 result.SetStatus(eReturnStatusSuccessFinishResult); 519 } else { 520 result.AppendError(error.AsCString()); 521 result.SetStatus(eReturnStatusFailed); 522 } 523 } else { 524 result.AppendError("no platform currently selected\n"); 525 result.SetStatus(eReturnStatusFailed); 526 } 527 return result.Succeeded(); 528 } 529 530 Options *GetOptions() override { 531 if (!m_options.DidFinalize()) { 532 m_options.Append(new OptionPermissions()); 533 m_options.Finalize(); 534 } 535 return &m_options; 536 } 537 538 OptionGroupOptions m_options; 539 }; 540 541 // "platform fclose" 542 class CommandObjectPlatformFClose : public CommandObjectParsed { 543 public: 544 CommandObjectPlatformFClose(CommandInterpreter &interpreter) 545 : CommandObjectParsed(interpreter, "platform file close", 546 "Close a file on the remote end.", nullptr, 0) {} 547 548 ~CommandObjectPlatformFClose() override = default; 549 550 bool DoExecute(Args &args, CommandReturnObject &result) override { 551 PlatformSP platform_sp( 552 GetDebugger().GetPlatformList().GetSelectedPlatform()); 553 if (platform_sp) { 554 std::string cmd_line; 555 args.GetCommandString(cmd_line); 556 const lldb::user_id_t fd = 557 StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX); 558 Status error; 559 bool success = platform_sp->CloseFile(fd, error); 560 if (success) { 561 result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd); 562 result.SetStatus(eReturnStatusSuccessFinishResult); 563 } else { 564 result.AppendError(error.AsCString()); 565 result.SetStatus(eReturnStatusFailed); 566 } 567 } else { 568 result.AppendError("no platform currently selected\n"); 569 result.SetStatus(eReturnStatusFailed); 570 } 571 return result.Succeeded(); 572 } 573 }; 574 575 // "platform fread" 576 577 static constexpr OptionDefinition g_platform_fread_options[] = { 578 #define LLDB_OPTIONS_platform_fread 579 #include "CommandOptions.inc" 580 }; 581 582 class CommandObjectPlatformFRead : public CommandObjectParsed { 583 public: 584 CommandObjectPlatformFRead(CommandInterpreter &interpreter) 585 : CommandObjectParsed(interpreter, "platform file read", 586 "Read data from a file on the remote end.", nullptr, 587 0), 588 m_options() {} 589 590 ~CommandObjectPlatformFRead() override = default; 591 592 bool DoExecute(Args &args, CommandReturnObject &result) override { 593 PlatformSP platform_sp( 594 GetDebugger().GetPlatformList().GetSelectedPlatform()); 595 if (platform_sp) { 596 std::string cmd_line; 597 args.GetCommandString(cmd_line); 598 const lldb::user_id_t fd = 599 StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX); 600 std::string buffer(m_options.m_count, 0); 601 Status error; 602 uint32_t retcode = platform_sp->ReadFile( 603 fd, m_options.m_offset, &buffer[0], m_options.m_count, error); 604 result.AppendMessageWithFormat("Return = %d\n", retcode); 605 result.AppendMessageWithFormat("Data = \"%s\"\n", buffer.c_str()); 606 result.SetStatus(eReturnStatusSuccessFinishResult); 607 } else { 608 result.AppendError("no platform currently selected\n"); 609 result.SetStatus(eReturnStatusFailed); 610 } 611 return result.Succeeded(); 612 } 613 614 Options *GetOptions() override { return &m_options; } 615 616 protected: 617 class CommandOptions : public Options { 618 public: 619 CommandOptions() : Options() {} 620 621 ~CommandOptions() override = default; 622 623 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 624 ExecutionContext *execution_context) override { 625 Status error; 626 char short_option = (char)m_getopt_table[option_idx].val; 627 628 switch (short_option) { 629 case 'o': 630 if (option_arg.getAsInteger(0, m_offset)) 631 error.SetErrorStringWithFormat("invalid offset: '%s'", 632 option_arg.str().c_str()); 633 break; 634 case 'c': 635 if (option_arg.getAsInteger(0, m_count)) 636 error.SetErrorStringWithFormat("invalid offset: '%s'", 637 option_arg.str().c_str()); 638 break; 639 default: 640 error.SetErrorStringWithFormat("unrecognized option '%c'", 641 short_option); 642 break; 643 } 644 645 return error; 646 } 647 648 void OptionParsingStarting(ExecutionContext *execution_context) override { 649 m_offset = 0; 650 m_count = 1; 651 } 652 653 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 654 return llvm::makeArrayRef(g_platform_fread_options); 655 } 656 657 // Instance variables to hold the values for command options. 658 659 uint32_t m_offset; 660 uint32_t m_count; 661 }; 662 663 CommandOptions m_options; 664 }; 665 666 // "platform fwrite" 667 668 static constexpr OptionDefinition g_platform_fwrite_options[] = { 669 #define LLDB_OPTIONS_platform_fwrite 670 #include "CommandOptions.inc" 671 }; 672 673 class CommandObjectPlatformFWrite : public CommandObjectParsed { 674 public: 675 CommandObjectPlatformFWrite(CommandInterpreter &interpreter) 676 : CommandObjectParsed(interpreter, "platform file write", 677 "Write data to a file on the remote end.", nullptr, 678 0), 679 m_options() {} 680 681 ~CommandObjectPlatformFWrite() override = default; 682 683 bool DoExecute(Args &args, CommandReturnObject &result) override { 684 PlatformSP platform_sp( 685 GetDebugger().GetPlatformList().GetSelectedPlatform()); 686 if (platform_sp) { 687 std::string cmd_line; 688 args.GetCommandString(cmd_line); 689 Status error; 690 const lldb::user_id_t fd = 691 StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX); 692 uint32_t retcode = 693 platform_sp->WriteFile(fd, m_options.m_offset, &m_options.m_data[0], 694 m_options.m_data.size(), error); 695 result.AppendMessageWithFormat("Return = %d\n", retcode); 696 result.SetStatus(eReturnStatusSuccessFinishResult); 697 } else { 698 result.AppendError("no platform currently selected\n"); 699 result.SetStatus(eReturnStatusFailed); 700 } 701 return result.Succeeded(); 702 } 703 704 Options *GetOptions() override { return &m_options; } 705 706 protected: 707 class CommandOptions : public Options { 708 public: 709 CommandOptions() : Options() {} 710 711 ~CommandOptions() override = default; 712 713 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 714 ExecutionContext *execution_context) override { 715 Status error; 716 char short_option = (char)m_getopt_table[option_idx].val; 717 718 switch (short_option) { 719 case 'o': 720 if (option_arg.getAsInteger(0, m_offset)) 721 error.SetErrorStringWithFormat("invalid offset: '%s'", 722 option_arg.str().c_str()); 723 break; 724 case 'd': 725 m_data.assign(option_arg); 726 break; 727 default: 728 error.SetErrorStringWithFormat("unrecognized option '%c'", 729 short_option); 730 break; 731 } 732 733 return error; 734 } 735 736 void OptionParsingStarting(ExecutionContext *execution_context) override { 737 m_offset = 0; 738 m_data.clear(); 739 } 740 741 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 742 return llvm::makeArrayRef(g_platform_fwrite_options); 743 } 744 745 // Instance variables to hold the values for command options. 746 747 uint32_t m_offset; 748 std::string m_data; 749 }; 750 751 CommandOptions m_options; 752 }; 753 754 class CommandObjectPlatformFile : public CommandObjectMultiword { 755 public: 756 // Constructors and Destructors 757 CommandObjectPlatformFile(CommandInterpreter &interpreter) 758 : CommandObjectMultiword( 759 interpreter, "platform file", 760 "Commands to access files on the current platform.", 761 "platform file [open|close|read|write] ...") { 762 LoadSubCommand( 763 "open", CommandObjectSP(new CommandObjectPlatformFOpen(interpreter))); 764 LoadSubCommand( 765 "close", CommandObjectSP(new CommandObjectPlatformFClose(interpreter))); 766 LoadSubCommand( 767 "read", CommandObjectSP(new CommandObjectPlatformFRead(interpreter))); 768 LoadSubCommand( 769 "write", CommandObjectSP(new CommandObjectPlatformFWrite(interpreter))); 770 } 771 772 ~CommandObjectPlatformFile() override = default; 773 774 private: 775 // For CommandObjectPlatform only 776 DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformFile); 777 }; 778 779 // "platform get-file remote-file-path host-file-path" 780 class CommandObjectPlatformGetFile : public CommandObjectParsed { 781 public: 782 CommandObjectPlatformGetFile(CommandInterpreter &interpreter) 783 : CommandObjectParsed( 784 interpreter, "platform get-file", 785 "Transfer a file from the remote end to the local host.", 786 "platform get-file <remote-file-spec> <local-file-spec>", 0) { 787 SetHelpLong( 788 R"(Examples: 789 790 (lldb) platform get-file /the/remote/file/path /the/local/file/path 791 792 Transfer a file from the remote end with file path /the/remote/file/path to the local host.)"); 793 794 CommandArgumentEntry arg1, arg2; 795 CommandArgumentData file_arg_remote, file_arg_host; 796 797 // Define the first (and only) variant of this arg. 798 file_arg_remote.arg_type = eArgTypeFilename; 799 file_arg_remote.arg_repetition = eArgRepeatPlain; 800 // There is only one variant this argument could be; put it into the 801 // argument entry. 802 arg1.push_back(file_arg_remote); 803 804 // Define the second (and only) variant of this arg. 805 file_arg_host.arg_type = eArgTypeFilename; 806 file_arg_host.arg_repetition = eArgRepeatPlain; 807 // There is only one variant this argument could be; put it into the 808 // argument entry. 809 arg2.push_back(file_arg_host); 810 811 // Push the data for the first and the second arguments into the 812 // m_arguments vector. 813 m_arguments.push_back(arg1); 814 m_arguments.push_back(arg2); 815 } 816 817 ~CommandObjectPlatformGetFile() override = default; 818 819 bool DoExecute(Args &args, CommandReturnObject &result) override { 820 // If the number of arguments is incorrect, issue an error message. 821 if (args.GetArgumentCount() != 2) { 822 result.GetErrorStream().Printf("error: required arguments missing; " 823 "specify both the source and destination " 824 "file paths\n"); 825 result.SetStatus(eReturnStatusFailed); 826 return false; 827 } 828 829 PlatformSP platform_sp( 830 GetDebugger().GetPlatformList().GetSelectedPlatform()); 831 if (platform_sp) { 832 const char *remote_file_path = args.GetArgumentAtIndex(0); 833 const char *local_file_path = args.GetArgumentAtIndex(1); 834 Status error = platform_sp->GetFile(FileSpec(remote_file_path), 835 FileSpec(local_file_path)); 836 if (error.Success()) { 837 result.AppendMessageWithFormat( 838 "successfully get-file from %s (remote) to %s (host)\n", 839 remote_file_path, local_file_path); 840 result.SetStatus(eReturnStatusSuccessFinishResult); 841 } else { 842 result.AppendMessageWithFormat("get-file failed: %s\n", 843 error.AsCString()); 844 result.SetStatus(eReturnStatusFailed); 845 } 846 } else { 847 result.AppendError("no platform currently selected\n"); 848 result.SetStatus(eReturnStatusFailed); 849 } 850 return result.Succeeded(); 851 } 852 }; 853 854 // "platform get-size remote-file-path" 855 class CommandObjectPlatformGetSize : public CommandObjectParsed { 856 public: 857 CommandObjectPlatformGetSize(CommandInterpreter &interpreter) 858 : CommandObjectParsed(interpreter, "platform get-size", 859 "Get the file size from the remote end.", 860 "platform get-size <remote-file-spec>", 0) { 861 SetHelpLong( 862 R"(Examples: 863 864 (lldb) platform get-size /the/remote/file/path 865 866 Get the file size from the remote end with path /the/remote/file/path.)"); 867 868 CommandArgumentEntry arg1; 869 CommandArgumentData file_arg_remote; 870 871 // Define the first (and only) variant of this arg. 872 file_arg_remote.arg_type = eArgTypeFilename; 873 file_arg_remote.arg_repetition = eArgRepeatPlain; 874 // There is only one variant this argument could be; put it into the 875 // argument entry. 876 arg1.push_back(file_arg_remote); 877 878 // Push the data for the first argument into the m_arguments vector. 879 m_arguments.push_back(arg1); 880 } 881 882 ~CommandObjectPlatformGetSize() override = default; 883 884 bool DoExecute(Args &args, CommandReturnObject &result) override { 885 // If the number of arguments is incorrect, issue an error message. 886 if (args.GetArgumentCount() != 1) { 887 result.GetErrorStream().Printf("error: required argument missing; " 888 "specify the source file path as the only " 889 "argument\n"); 890 result.SetStatus(eReturnStatusFailed); 891 return false; 892 } 893 894 PlatformSP platform_sp( 895 GetDebugger().GetPlatformList().GetSelectedPlatform()); 896 if (platform_sp) { 897 std::string remote_file_path(args.GetArgumentAtIndex(0)); 898 user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path)); 899 if (size != UINT64_MAX) { 900 result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64 901 "\n", 902 remote_file_path.c_str(), size); 903 result.SetStatus(eReturnStatusSuccessFinishResult); 904 } else { 905 result.AppendMessageWithFormat( 906 "Error getting file size of %s (remote)\n", 907 remote_file_path.c_str()); 908 result.SetStatus(eReturnStatusFailed); 909 } 910 } else { 911 result.AppendError("no platform currently selected\n"); 912 result.SetStatus(eReturnStatusFailed); 913 } 914 return result.Succeeded(); 915 } 916 }; 917 918 // "platform put-file" 919 class CommandObjectPlatformPutFile : public CommandObjectParsed { 920 public: 921 CommandObjectPlatformPutFile(CommandInterpreter &interpreter) 922 : CommandObjectParsed( 923 interpreter, "platform put-file", 924 "Transfer a file from this system to the remote end.", nullptr, 0) { 925 } 926 927 ~CommandObjectPlatformPutFile() override = default; 928 929 bool DoExecute(Args &args, CommandReturnObject &result) override { 930 const char *src = args.GetArgumentAtIndex(0); 931 const char *dst = args.GetArgumentAtIndex(1); 932 933 FileSpec src_fs(src); 934 FileSystem::Instance().Resolve(src_fs); 935 FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString()); 936 937 PlatformSP platform_sp( 938 GetDebugger().GetPlatformList().GetSelectedPlatform()); 939 if (platform_sp) { 940 Status error(platform_sp->PutFile(src_fs, dst_fs)); 941 if (error.Success()) { 942 result.SetStatus(eReturnStatusSuccessFinishNoResult); 943 } else { 944 result.AppendError(error.AsCString()); 945 result.SetStatus(eReturnStatusFailed); 946 } 947 } else { 948 result.AppendError("no platform currently selected\n"); 949 result.SetStatus(eReturnStatusFailed); 950 } 951 return result.Succeeded(); 952 } 953 }; 954 955 // "platform process launch" 956 class CommandObjectPlatformProcessLaunch : public CommandObjectParsed { 957 public: 958 CommandObjectPlatformProcessLaunch(CommandInterpreter &interpreter) 959 : CommandObjectParsed(interpreter, "platform process launch", 960 "Launch a new process on a remote platform.", 961 "platform process launch program", 962 eCommandRequiresTarget | eCommandTryTargetAPILock), 963 m_options() {} 964 965 ~CommandObjectPlatformProcessLaunch() override = default; 966 967 Options *GetOptions() override { return &m_options; } 968 969 protected: 970 bool DoExecute(Args &args, CommandReturnObject &result) override { 971 Target *target = GetDebugger().GetSelectedTarget().get(); 972 PlatformSP platform_sp; 973 if (target) { 974 platform_sp = target->GetPlatform(); 975 } 976 if (!platform_sp) { 977 platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform(); 978 } 979 980 if (platform_sp) { 981 Status error; 982 const size_t argc = args.GetArgumentCount(); 983 Target *target = m_exe_ctx.GetTargetPtr(); 984 Module *exe_module = target->GetExecutableModulePointer(); 985 if (exe_module) { 986 m_options.launch_info.GetExecutableFile() = exe_module->GetFileSpec(); 987 llvm::SmallString<128> exe_path; 988 m_options.launch_info.GetExecutableFile().GetPath(exe_path); 989 if (!exe_path.empty()) 990 m_options.launch_info.GetArguments().AppendArgument(exe_path); 991 m_options.launch_info.GetArchitecture() = exe_module->GetArchitecture(); 992 } 993 994 if (argc > 0) { 995 if (m_options.launch_info.GetExecutableFile()) { 996 // We already have an executable file, so we will use this and all 997 // arguments to this function are extra arguments 998 m_options.launch_info.GetArguments().AppendArguments(args); 999 } else { 1000 // We don't have any file yet, so the first argument is our 1001 // executable, and the rest are program arguments 1002 const bool first_arg_is_executable = true; 1003 m_options.launch_info.SetArguments(args, first_arg_is_executable); 1004 } 1005 } 1006 1007 if (m_options.launch_info.GetExecutableFile()) { 1008 Debugger &debugger = GetDebugger(); 1009 1010 if (argc == 0) 1011 target->GetRunArguments(m_options.launch_info.GetArguments()); 1012 1013 ProcessSP process_sp(platform_sp->DebugProcess( 1014 m_options.launch_info, debugger, target, error)); 1015 if (process_sp && process_sp->IsAlive()) { 1016 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1017 return true; 1018 } 1019 1020 if (error.Success()) 1021 result.AppendError("process launch failed"); 1022 else 1023 result.AppendError(error.AsCString()); 1024 result.SetStatus(eReturnStatusFailed); 1025 } else { 1026 result.AppendError("'platform process launch' uses the current target " 1027 "file and arguments, or the executable and its " 1028 "arguments can be specified in this command"); 1029 result.SetStatus(eReturnStatusFailed); 1030 return false; 1031 } 1032 } else { 1033 result.AppendError("no platform is selected\n"); 1034 } 1035 return result.Succeeded(); 1036 } 1037 1038 protected: 1039 ProcessLaunchCommandOptions m_options; 1040 }; 1041 1042 // "platform process list" 1043 1044 static OptionDefinition g_platform_process_list_options[] = { 1045 #define LLDB_OPTIONS_platform_process_list 1046 #include "CommandOptions.inc" 1047 }; 1048 1049 class CommandObjectPlatformProcessList : public CommandObjectParsed { 1050 public: 1051 CommandObjectPlatformProcessList(CommandInterpreter &interpreter) 1052 : CommandObjectParsed(interpreter, "platform process list", 1053 "List processes on a remote platform by name, pid, " 1054 "or many other matching attributes.", 1055 "platform process list", 0), 1056 m_options() {} 1057 1058 ~CommandObjectPlatformProcessList() override = default; 1059 1060 Options *GetOptions() override { return &m_options; } 1061 1062 protected: 1063 bool DoExecute(Args &args, CommandReturnObject &result) override { 1064 Target *target = GetDebugger().GetSelectedTarget().get(); 1065 PlatformSP platform_sp; 1066 if (target) { 1067 platform_sp = target->GetPlatform(); 1068 } 1069 if (!platform_sp) { 1070 platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform(); 1071 } 1072 1073 if (platform_sp) { 1074 Status error; 1075 if (args.GetArgumentCount() == 0) { 1076 if (platform_sp) { 1077 Stream &ostrm = result.GetOutputStream(); 1078 1079 lldb::pid_t pid = 1080 m_options.match_info.GetProcessInfo().GetProcessID(); 1081 if (pid != LLDB_INVALID_PROCESS_ID) { 1082 ProcessInstanceInfo proc_info; 1083 if (platform_sp->GetProcessInfo(pid, proc_info)) { 1084 ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args, 1085 m_options.verbose); 1086 proc_info.DumpAsTableRow(ostrm, platform_sp->GetUserIDResolver(), 1087 m_options.show_args, m_options.verbose); 1088 result.SetStatus(eReturnStatusSuccessFinishResult); 1089 } else { 1090 result.AppendErrorWithFormat( 1091 "no process found with pid = %" PRIu64 "\n", pid); 1092 result.SetStatus(eReturnStatusFailed); 1093 } 1094 } else { 1095 ProcessInstanceInfoList proc_infos; 1096 const uint32_t matches = 1097 platform_sp->FindProcesses(m_options.match_info, proc_infos); 1098 const char *match_desc = nullptr; 1099 const char *match_name = 1100 m_options.match_info.GetProcessInfo().GetName(); 1101 if (match_name && match_name[0]) { 1102 switch (m_options.match_info.GetNameMatchType()) { 1103 case NameMatch::Ignore: 1104 break; 1105 case NameMatch::Equals: 1106 match_desc = "matched"; 1107 break; 1108 case NameMatch::Contains: 1109 match_desc = "contained"; 1110 break; 1111 case NameMatch::StartsWith: 1112 match_desc = "started with"; 1113 break; 1114 case NameMatch::EndsWith: 1115 match_desc = "ended with"; 1116 break; 1117 case NameMatch::RegularExpression: 1118 match_desc = "matched the regular expression"; 1119 break; 1120 } 1121 } 1122 1123 if (matches == 0) { 1124 if (match_desc) 1125 result.AppendErrorWithFormat( 1126 "no processes were found that %s \"%s\" on the \"%s\" " 1127 "platform\n", 1128 match_desc, match_name, 1129 platform_sp->GetPluginName().GetCString()); 1130 else 1131 result.AppendErrorWithFormat( 1132 "no processes were found on the \"%s\" platform\n", 1133 platform_sp->GetPluginName().GetCString()); 1134 result.SetStatus(eReturnStatusFailed); 1135 } else { 1136 result.AppendMessageWithFormat( 1137 "%u matching process%s found on \"%s\"", matches, 1138 matches > 1 ? "es were" : " was", 1139 platform_sp->GetName().GetCString()); 1140 if (match_desc) 1141 result.AppendMessageWithFormat(" whose name %s \"%s\"", 1142 match_desc, match_name); 1143 result.AppendMessageWithFormat("\n"); 1144 ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args, 1145 m_options.verbose); 1146 for (uint32_t i = 0; i < matches; ++i) { 1147 proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow( 1148 ostrm, platform_sp->GetUserIDResolver(), 1149 m_options.show_args, m_options.verbose); 1150 } 1151 } 1152 } 1153 } 1154 } else { 1155 result.AppendError("invalid args: process list takes only options\n"); 1156 result.SetStatus(eReturnStatusFailed); 1157 } 1158 } else { 1159 result.AppendError("no platform is selected\n"); 1160 result.SetStatus(eReturnStatusFailed); 1161 } 1162 return result.Succeeded(); 1163 } 1164 1165 class CommandOptions : public Options { 1166 public: 1167 CommandOptions() 1168 : Options(), match_info(), show_args(false), verbose(false) { 1169 static llvm::once_flag g_once_flag; 1170 llvm::call_once(g_once_flag, []() { 1171 PosixPlatformCommandOptionValidator *posix_validator = 1172 new PosixPlatformCommandOptionValidator(); 1173 for (auto &Option : g_platform_process_list_options) { 1174 switch (Option.short_option) { 1175 case 'u': 1176 case 'U': 1177 case 'g': 1178 case 'G': 1179 Option.validator = posix_validator; 1180 break; 1181 default: 1182 break; 1183 } 1184 } 1185 }); 1186 } 1187 1188 ~CommandOptions() override = default; 1189 1190 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1191 ExecutionContext *execution_context) override { 1192 Status error; 1193 const int short_option = m_getopt_table[option_idx].val; 1194 bool success = false; 1195 1196 uint32_t id = LLDB_INVALID_PROCESS_ID; 1197 success = !option_arg.getAsInteger(0, id); 1198 switch (short_option) { 1199 case 'p': { 1200 match_info.GetProcessInfo().SetProcessID(id); 1201 if (!success) 1202 error.SetErrorStringWithFormat("invalid process ID string: '%s'", 1203 option_arg.str().c_str()); 1204 break; 1205 } 1206 case 'P': 1207 match_info.GetProcessInfo().SetParentProcessID(id); 1208 if (!success) 1209 error.SetErrorStringWithFormat( 1210 "invalid parent process ID string: '%s'", 1211 option_arg.str().c_str()); 1212 break; 1213 1214 case 'u': 1215 match_info.GetProcessInfo().SetUserID(success ? id : UINT32_MAX); 1216 if (!success) 1217 error.SetErrorStringWithFormat("invalid user ID string: '%s'", 1218 option_arg.str().c_str()); 1219 break; 1220 1221 case 'U': 1222 match_info.GetProcessInfo().SetEffectiveUserID(success ? id 1223 : UINT32_MAX); 1224 if (!success) 1225 error.SetErrorStringWithFormat( 1226 "invalid effective user ID string: '%s'", 1227 option_arg.str().c_str()); 1228 break; 1229 1230 case 'g': 1231 match_info.GetProcessInfo().SetGroupID(success ? id : UINT32_MAX); 1232 if (!success) 1233 error.SetErrorStringWithFormat("invalid group ID string: '%s'", 1234 option_arg.str().c_str()); 1235 break; 1236 1237 case 'G': 1238 match_info.GetProcessInfo().SetEffectiveGroupID(success ? id 1239 : UINT32_MAX); 1240 if (!success) 1241 error.SetErrorStringWithFormat( 1242 "invalid effective group ID string: '%s'", 1243 option_arg.str().c_str()); 1244 break; 1245 1246 case 'a': { 1247 TargetSP target_sp = 1248 execution_context ? execution_context->GetTargetSP() : TargetSP(); 1249 DebuggerSP debugger_sp = 1250 target_sp ? target_sp->GetDebugger().shared_from_this() 1251 : DebuggerSP(); 1252 PlatformSP platform_sp = 1253 debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform() 1254 : PlatformSP(); 1255 match_info.GetProcessInfo().GetArchitecture() = 1256 Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg); 1257 } break; 1258 1259 case 'n': 1260 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1261 option_arg, FileSpec::Style::native); 1262 match_info.SetNameMatchType(NameMatch::Equals); 1263 break; 1264 1265 case 'e': 1266 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1267 option_arg, FileSpec::Style::native); 1268 match_info.SetNameMatchType(NameMatch::EndsWith); 1269 break; 1270 1271 case 's': 1272 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1273 option_arg, FileSpec::Style::native); 1274 match_info.SetNameMatchType(NameMatch::StartsWith); 1275 break; 1276 1277 case 'c': 1278 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1279 option_arg, FileSpec::Style::native); 1280 match_info.SetNameMatchType(NameMatch::Contains); 1281 break; 1282 1283 case 'r': 1284 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1285 option_arg, FileSpec::Style::native); 1286 match_info.SetNameMatchType(NameMatch::RegularExpression); 1287 break; 1288 1289 case 'A': 1290 show_args = true; 1291 break; 1292 1293 case 'v': 1294 verbose = true; 1295 break; 1296 1297 default: 1298 error.SetErrorStringWithFormat("unrecognized option '%c'", 1299 short_option); 1300 break; 1301 } 1302 1303 return error; 1304 } 1305 1306 void OptionParsingStarting(ExecutionContext *execution_context) override { 1307 match_info.Clear(); 1308 show_args = false; 1309 verbose = false; 1310 } 1311 1312 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1313 return llvm::makeArrayRef(g_platform_process_list_options); 1314 } 1315 1316 // Instance variables to hold the values for command options. 1317 1318 ProcessInstanceInfoMatch match_info; 1319 bool show_args; 1320 bool verbose; 1321 }; 1322 1323 CommandOptions m_options; 1324 }; 1325 1326 // "platform process info" 1327 class CommandObjectPlatformProcessInfo : public CommandObjectParsed { 1328 public: 1329 CommandObjectPlatformProcessInfo(CommandInterpreter &interpreter) 1330 : CommandObjectParsed( 1331 interpreter, "platform process info", 1332 "Get detailed information for one or more process by process ID.", 1333 "platform process info <pid> [<pid> <pid> ...]", 0) { 1334 CommandArgumentEntry arg; 1335 CommandArgumentData pid_args; 1336 1337 // Define the first (and only) variant of this arg. 1338 pid_args.arg_type = eArgTypePid; 1339 pid_args.arg_repetition = eArgRepeatStar; 1340 1341 // There is only one variant this argument could be; put it into the 1342 // argument entry. 1343 arg.push_back(pid_args); 1344 1345 // Push the data for the first argument into the m_arguments vector. 1346 m_arguments.push_back(arg); 1347 } 1348 1349 ~CommandObjectPlatformProcessInfo() override = default; 1350 1351 protected: 1352 bool DoExecute(Args &args, CommandReturnObject &result) override { 1353 Target *target = GetDebugger().GetSelectedTarget().get(); 1354 PlatformSP platform_sp; 1355 if (target) { 1356 platform_sp = target->GetPlatform(); 1357 } 1358 if (!platform_sp) { 1359 platform_sp = GetDebugger().GetPlatformList().GetSelectedPlatform(); 1360 } 1361 1362 if (platform_sp) { 1363 const size_t argc = args.GetArgumentCount(); 1364 if (argc > 0) { 1365 Status error; 1366 1367 if (platform_sp->IsConnected()) { 1368 Stream &ostrm = result.GetOutputStream(); 1369 for (auto &entry : args.entries()) { 1370 lldb::pid_t pid; 1371 if (entry.ref.getAsInteger(0, pid)) { 1372 result.AppendErrorWithFormat("invalid process ID argument '%s'", 1373 entry.ref.str().c_str()); 1374 result.SetStatus(eReturnStatusFailed); 1375 break; 1376 } else { 1377 ProcessInstanceInfo proc_info; 1378 if (platform_sp->GetProcessInfo(pid, proc_info)) { 1379 ostrm.Printf("Process information for process %" PRIu64 ":\n", 1380 pid); 1381 proc_info.Dump(ostrm, platform_sp->GetUserIDResolver()); 1382 } else { 1383 ostrm.Printf("error: no process information is available for " 1384 "process %" PRIu64 "\n", 1385 pid); 1386 } 1387 ostrm.EOL(); 1388 } 1389 } 1390 } else { 1391 // Not connected... 1392 result.AppendErrorWithFormat( 1393 "not connected to '%s'", 1394 platform_sp->GetPluginName().GetCString()); 1395 result.SetStatus(eReturnStatusFailed); 1396 } 1397 } else { 1398 // No args 1399 result.AppendError("one or more process id(s) must be specified"); 1400 result.SetStatus(eReturnStatusFailed); 1401 } 1402 } else { 1403 result.AppendError("no platform is currently selected"); 1404 result.SetStatus(eReturnStatusFailed); 1405 } 1406 return result.Succeeded(); 1407 } 1408 }; 1409 1410 static constexpr OptionDefinition g_platform_process_attach_options[] = { 1411 #define LLDB_OPTIONS_platform_process_attach 1412 #include "CommandOptions.inc" 1413 }; 1414 1415 class CommandObjectPlatformProcessAttach : public CommandObjectParsed { 1416 public: 1417 class CommandOptions : public Options { 1418 public: 1419 CommandOptions() : Options() { 1420 // Keep default values of all options in one place: OptionParsingStarting 1421 // () 1422 OptionParsingStarting(nullptr); 1423 } 1424 1425 ~CommandOptions() override = default; 1426 1427 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1428 ExecutionContext *execution_context) override { 1429 Status error; 1430 char short_option = (char)m_getopt_table[option_idx].val; 1431 switch (short_option) { 1432 case 'p': { 1433 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 1434 if (option_arg.getAsInteger(0, pid)) { 1435 error.SetErrorStringWithFormat("invalid process ID '%s'", 1436 option_arg.str().c_str()); 1437 } else { 1438 attach_info.SetProcessID(pid); 1439 } 1440 } break; 1441 1442 case 'P': 1443 attach_info.SetProcessPluginName(option_arg); 1444 break; 1445 1446 case 'n': 1447 attach_info.GetExecutableFile().SetFile(option_arg, 1448 FileSpec::Style::native); 1449 break; 1450 1451 case 'w': 1452 attach_info.SetWaitForLaunch(true); 1453 break; 1454 1455 default: 1456 error.SetErrorStringWithFormat("invalid short option character '%c'", 1457 short_option); 1458 break; 1459 } 1460 return error; 1461 } 1462 1463 void OptionParsingStarting(ExecutionContext *execution_context) override { 1464 attach_info.Clear(); 1465 } 1466 1467 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1468 return llvm::makeArrayRef(g_platform_process_attach_options); 1469 } 1470 1471 bool HandleOptionArgumentCompletion( 1472 CompletionRequest &request, OptionElementVector &opt_element_vector, 1473 int opt_element_index, CommandInterpreter &interpreter) override { 1474 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; 1475 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; 1476 1477 // We are only completing the name option for now... 1478 1479 if (GetDefinitions()[opt_defs_index].short_option == 'n') { 1480 // Are we in the name? 1481 1482 // Look to see if there is a -P argument provided, and if so use that 1483 // plugin, otherwise use the default plugin. 1484 1485 const char *partial_name = nullptr; 1486 partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos); 1487 1488 PlatformSP platform_sp(interpreter.GetPlatform(true)); 1489 if (platform_sp) { 1490 ProcessInstanceInfoList process_infos; 1491 ProcessInstanceInfoMatch match_info; 1492 if (partial_name) { 1493 match_info.GetProcessInfo().GetExecutableFile().SetFile( 1494 partial_name, FileSpec::Style::native); 1495 match_info.SetNameMatchType(NameMatch::StartsWith); 1496 } 1497 platform_sp->FindProcesses(match_info, process_infos); 1498 const uint32_t num_matches = process_infos.GetSize(); 1499 if (num_matches > 0) { 1500 for (uint32_t i = 0; i < num_matches; ++i) { 1501 request.AddCompletion(llvm::StringRef( 1502 process_infos.GetProcessNameAtIndex(i), 1503 process_infos.GetProcessNameLengthAtIndex(i))); 1504 } 1505 } 1506 } 1507 } 1508 1509 return false; 1510 } 1511 1512 // Options table: Required for subclasses of Options. 1513 1514 static OptionDefinition g_option_table[]; 1515 1516 // Instance variables to hold the values for command options. 1517 1518 ProcessAttachInfo attach_info; 1519 }; 1520 1521 CommandObjectPlatformProcessAttach(CommandInterpreter &interpreter) 1522 : CommandObjectParsed(interpreter, "platform process attach", 1523 "Attach to a process.", 1524 "platform process attach <cmd-options>"), 1525 m_options() {} 1526 1527 ~CommandObjectPlatformProcessAttach() override = default; 1528 1529 bool DoExecute(Args &command, CommandReturnObject &result) override { 1530 PlatformSP platform_sp( 1531 GetDebugger().GetPlatformList().GetSelectedPlatform()); 1532 if (platform_sp) { 1533 Status err; 1534 ProcessSP remote_process_sp = platform_sp->Attach( 1535 m_options.attach_info, GetDebugger(), nullptr, err); 1536 if (err.Fail()) { 1537 result.AppendError(err.AsCString()); 1538 result.SetStatus(eReturnStatusFailed); 1539 } else if (!remote_process_sp) { 1540 result.AppendError("could not attach: unknown reason"); 1541 result.SetStatus(eReturnStatusFailed); 1542 } else 1543 result.SetStatus(eReturnStatusSuccessFinishResult); 1544 } else { 1545 result.AppendError("no platform is currently selected"); 1546 result.SetStatus(eReturnStatusFailed); 1547 } 1548 return result.Succeeded(); 1549 } 1550 1551 Options *GetOptions() override { return &m_options; } 1552 1553 protected: 1554 CommandOptions m_options; 1555 }; 1556 1557 class CommandObjectPlatformProcess : public CommandObjectMultiword { 1558 public: 1559 // Constructors and Destructors 1560 CommandObjectPlatformProcess(CommandInterpreter &interpreter) 1561 : CommandObjectMultiword(interpreter, "platform process", 1562 "Commands to query, launch and attach to " 1563 "processes on the current platform.", 1564 "platform process [attach|launch|list] ...") { 1565 LoadSubCommand( 1566 "attach", 1567 CommandObjectSP(new CommandObjectPlatformProcessAttach(interpreter))); 1568 LoadSubCommand( 1569 "launch", 1570 CommandObjectSP(new CommandObjectPlatformProcessLaunch(interpreter))); 1571 LoadSubCommand("info", CommandObjectSP(new CommandObjectPlatformProcessInfo( 1572 interpreter))); 1573 LoadSubCommand("list", CommandObjectSP(new CommandObjectPlatformProcessList( 1574 interpreter))); 1575 } 1576 1577 ~CommandObjectPlatformProcess() override = default; 1578 1579 private: 1580 // For CommandObjectPlatform only 1581 DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess); 1582 }; 1583 1584 // "platform shell" 1585 static constexpr OptionDefinition g_platform_shell_options[] = { 1586 #define LLDB_OPTIONS_platform_shell 1587 #include "CommandOptions.inc" 1588 }; 1589 1590 class CommandObjectPlatformShell : public CommandObjectRaw { 1591 public: 1592 class CommandOptions : public Options { 1593 public: 1594 CommandOptions() : Options() {} 1595 1596 ~CommandOptions() override = default; 1597 1598 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 1599 return llvm::makeArrayRef(g_platform_shell_options); 1600 } 1601 1602 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 1603 ExecutionContext *execution_context) override { 1604 Status error; 1605 1606 const char short_option = (char)GetDefinitions()[option_idx].short_option; 1607 1608 switch (short_option) { 1609 case 't': 1610 uint32_t timeout_sec; 1611 if (option_arg.getAsInteger(10, timeout_sec)) 1612 error.SetErrorStringWithFormat( 1613 "could not convert \"%s\" to a numeric value.", 1614 option_arg.str().c_str()); 1615 else 1616 timeout = std::chrono::seconds(timeout_sec); 1617 break; 1618 default: 1619 error.SetErrorStringWithFormat("invalid short option character '%c'", 1620 short_option); 1621 break; 1622 } 1623 1624 return error; 1625 } 1626 1627 void OptionParsingStarting(ExecutionContext *execution_context) override {} 1628 1629 Timeout<std::micro> timeout = std::chrono::seconds(10); 1630 }; 1631 1632 CommandObjectPlatformShell(CommandInterpreter &interpreter) 1633 : CommandObjectRaw(interpreter, "platform shell", 1634 "Run a shell command on the current platform.", 1635 "platform shell <shell-command>", 0), 1636 m_options() {} 1637 1638 ~CommandObjectPlatformShell() override = default; 1639 1640 Options *GetOptions() override { return &m_options; } 1641 1642 bool DoExecute(llvm::StringRef raw_command_line, 1643 CommandReturnObject &result) override { 1644 ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext(); 1645 m_options.NotifyOptionParsingStarting(&exe_ctx); 1646 1647 1648 // Print out an usage syntax on an empty command line. 1649 if (raw_command_line.empty()) { 1650 result.GetOutputStream().Printf("%s\n", this->GetSyntax().str().c_str()); 1651 return true; 1652 } 1653 1654 OptionsWithRaw args(raw_command_line); 1655 const char *expr = args.GetRawPart().c_str(); 1656 1657 if (args.HasArgs()) 1658 if (!ParseOptions(args.GetArgs(), result)) 1659 return false; 1660 1661 PlatformSP platform_sp( 1662 GetDebugger().GetPlatformList().GetSelectedPlatform()); 1663 Status error; 1664 if (platform_sp) { 1665 FileSpec working_dir{}; 1666 std::string output; 1667 int status = -1; 1668 int signo = -1; 1669 error = (platform_sp->RunShellCommand(expr, working_dir, &status, &signo, 1670 &output, m_options.timeout)); 1671 if (!output.empty()) 1672 result.GetOutputStream().PutCString(output); 1673 if (status > 0) { 1674 if (signo > 0) { 1675 const char *signo_cstr = Host::GetSignalAsCString(signo); 1676 if (signo_cstr) 1677 result.GetOutputStream().Printf( 1678 "error: command returned with status %i and signal %s\n", 1679 status, signo_cstr); 1680 else 1681 result.GetOutputStream().Printf( 1682 "error: command returned with status %i and signal %i\n", 1683 status, signo); 1684 } else 1685 result.GetOutputStream().Printf( 1686 "error: command returned with status %i\n", status); 1687 } 1688 } else { 1689 result.GetOutputStream().Printf( 1690 "error: cannot run remote shell commands without a platform\n"); 1691 error.SetErrorString( 1692 "error: cannot run remote shell commands without a platform"); 1693 } 1694 1695 if (error.Fail()) { 1696 result.AppendError(error.AsCString()); 1697 result.SetStatus(eReturnStatusFailed); 1698 } else { 1699 result.SetStatus(eReturnStatusSuccessFinishResult); 1700 } 1701 return true; 1702 } 1703 1704 CommandOptions m_options; 1705 }; 1706 1707 // "platform install" - install a target to a remote end 1708 class CommandObjectPlatformInstall : public CommandObjectParsed { 1709 public: 1710 CommandObjectPlatformInstall(CommandInterpreter &interpreter) 1711 : CommandObjectParsed( 1712 interpreter, "platform target-install", 1713 "Install a target (bundle or executable file) to the remote end.", 1714 "platform target-install <local-thing> <remote-sandbox>", 0) {} 1715 1716 ~CommandObjectPlatformInstall() override = default; 1717 1718 bool DoExecute(Args &args, CommandReturnObject &result) override { 1719 if (args.GetArgumentCount() != 2) { 1720 result.AppendError("platform target-install takes two arguments"); 1721 result.SetStatus(eReturnStatusFailed); 1722 return false; 1723 } 1724 // TODO: move the bulk of this code over to the platform itself 1725 FileSpec src(args.GetArgumentAtIndex(0)); 1726 FileSystem::Instance().Resolve(src); 1727 FileSpec dst(args.GetArgumentAtIndex(1)); 1728 if (!FileSystem::Instance().Exists(src)) { 1729 result.AppendError("source location does not exist or is not accessible"); 1730 result.SetStatus(eReturnStatusFailed); 1731 return false; 1732 } 1733 PlatformSP platform_sp( 1734 GetDebugger().GetPlatformList().GetSelectedPlatform()); 1735 if (!platform_sp) { 1736 result.AppendError("no platform currently selected"); 1737 result.SetStatus(eReturnStatusFailed); 1738 return false; 1739 } 1740 1741 Status error = platform_sp->Install(src, dst); 1742 if (error.Success()) { 1743 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1744 } else { 1745 result.AppendErrorWithFormat("install failed: %s", error.AsCString()); 1746 result.SetStatus(eReturnStatusFailed); 1747 } 1748 return result.Succeeded(); 1749 } 1750 }; 1751 1752 CommandObjectPlatform::CommandObjectPlatform(CommandInterpreter &interpreter) 1753 : CommandObjectMultiword( 1754 interpreter, "platform", "Commands to manage and create platforms.", 1755 "platform [connect|disconnect|info|list|status|select] ...") { 1756 LoadSubCommand("select", 1757 CommandObjectSP(new CommandObjectPlatformSelect(interpreter))); 1758 LoadSubCommand("list", 1759 CommandObjectSP(new CommandObjectPlatformList(interpreter))); 1760 LoadSubCommand("status", 1761 CommandObjectSP(new CommandObjectPlatformStatus(interpreter))); 1762 LoadSubCommand("connect", CommandObjectSP( 1763 new CommandObjectPlatformConnect(interpreter))); 1764 LoadSubCommand( 1765 "disconnect", 1766 CommandObjectSP(new CommandObjectPlatformDisconnect(interpreter))); 1767 LoadSubCommand("settings", CommandObjectSP(new CommandObjectPlatformSettings( 1768 interpreter))); 1769 LoadSubCommand("mkdir", 1770 CommandObjectSP(new CommandObjectPlatformMkDir(interpreter))); 1771 LoadSubCommand("file", 1772 CommandObjectSP(new CommandObjectPlatformFile(interpreter))); 1773 LoadSubCommand("get-file", CommandObjectSP(new CommandObjectPlatformGetFile( 1774 interpreter))); 1775 LoadSubCommand("get-size", CommandObjectSP(new CommandObjectPlatformGetSize( 1776 interpreter))); 1777 LoadSubCommand("put-file", CommandObjectSP(new CommandObjectPlatformPutFile( 1778 interpreter))); 1779 LoadSubCommand("process", CommandObjectSP( 1780 new CommandObjectPlatformProcess(interpreter))); 1781 LoadSubCommand("shell", 1782 CommandObjectSP(new CommandObjectPlatformShell(interpreter))); 1783 LoadSubCommand( 1784 "target-install", 1785 CommandObjectSP(new CommandObjectPlatformInstall(interpreter))); 1786 } 1787 1788 CommandObjectPlatform::~CommandObjectPlatform() = default; 1789