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