LLDB mainline
CommandObjectPlatform.cpp
Go to the documentation of this file.
1//===-- CommandObjectPlatform.cpp -----------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
12#include "lldb/Core/Debugger.h"
13#include "lldb/Core/Module.h"
25#include "lldb/Target/Process.h"
26#include "lldb/Utility/Args.h"
28#include "lldb/Utility/State.h"
29
30#include "llvm/ADT/SmallString.h"
31
32using namespace lldb;
33using namespace lldb_private;
34
35static mode_t ParsePermissionString(const char *) = delete;
36
37static mode_t ParsePermissionString(llvm::StringRef permissions) {
38 if (permissions.size() != 9)
39 return (mode_t)(-1);
40 bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w,
41 world_x;
42
43 user_r = (permissions[0] == 'r');
44 user_w = (permissions[1] == 'w');
45 user_x = (permissions[2] == 'x');
46
47 group_r = (permissions[3] == 'r');
48 group_w = (permissions[4] == 'w');
49 group_x = (permissions[5] == 'x');
50
51 world_r = (permissions[6] == 'r');
52 world_w = (permissions[7] == 'w');
53 world_x = (permissions[8] == 'x');
54
55 mode_t user, group, world;
56 user = (user_r ? 4 : 0) | (user_w ? 2 : 0) | (user_x ? 1 : 0);
57 group = (group_r ? 4 : 0) | (group_w ? 2 : 0) | (group_x ? 1 : 0);
58 world = (world_r ? 4 : 0) | (world_w ? 2 : 0) | (world_x ? 1 : 0);
59
60 return user | group | world;
61}
62
63#define LLDB_OPTIONS_permissions
64#include "CommandOptions.inc"
65
67public:
68 OptionPermissions() = default;
69
70 ~OptionPermissions() override = default;
71
73 SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
74 ExecutionContext *execution_context) override {
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 llvm_unreachable("Unimplemented option");
123 }
124
125 return error;
126 }
127
128 void OptionParsingStarting(ExecutionContext *execution_context) override {
129 m_permissions = 0;
130 }
131
132 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
133 return llvm::ArrayRef(g_permissions_options);
134 }
135
136 // Instance variables to hold the values for command options.
137
139
140private:
143};
144
145// "platform select <platform-name>"
147public:
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),
154 false) // Don't include the "--platform" option by passing false
155 {
159 }
160
161 ~CommandObjectPlatformSelect() override = default;
162
163 void HandleCompletion(CompletionRequest &request) override {
165 GetCommandInterpreter(), request, nullptr);
166 }
167
168 Options *GetOptions() override { return &m_option_group; }
169
170protected:
171 void DoExecute(Args &args, CommandReturnObject &result) override {
172 if (args.GetArgumentCount() == 1) {
173 const char *platform_name = args.GetArgumentAtIndex(0);
174 if (platform_name && platform_name[0]) {
175 const bool select = true;
176 m_platform_options.SetPlatformName(platform_name);
178 ArchSpec platform_arch;
180 m_interpreter, ArchSpec(), select, error, platform_arch));
181 if (platform_sp) {
183
184 platform_sp->GetStatus(result.GetOutputStream());
186 } else {
187 result.AppendError(error.AsCString());
188 }
189 } else {
190 result.AppendError("invalid platform name");
191 }
192 } else {
193 result.AppendError(
194 "platform create takes a platform name as an argument\n");
195 }
196 }
197
200};
201
202// "platform list"
204public:
206 : CommandObjectParsed(interpreter, "platform list",
207 "List all platforms that are available.", nullptr,
208 0) {}
209
210 ~CommandObjectPlatformList() override = default;
211
212protected:
213 void DoExecute(Args &args, CommandReturnObject &result) override {
214 Stream &ostrm = result.GetOutputStream();
215 ostrm.Printf("Available platforms:\n");
216
217 PlatformSP host_platform_sp(Platform::GetHostPlatform());
218 ostrm.Format("{0}: {1}\n", host_platform_sp->GetPluginName(),
219 host_platform_sp->GetDescription());
220
221 uint32_t idx;
222 for (idx = 0; true; ++idx) {
223 llvm::StringRef plugin_name =
225 if (plugin_name.empty())
226 break;
227 llvm::StringRef plugin_desc =
229 ostrm.Format("{0}: {1}\n", plugin_name, plugin_desc);
230 }
231
232 if (idx == 0) {
233 result.AppendError("no platforms are available\n");
234 } else
236 }
237};
238
239// "platform status"
241public:
243 : CommandObjectParsed(interpreter, "platform status",
244 "Display status for the current platform.", nullptr,
245 0) {}
246
247 ~CommandObjectPlatformStatus() override = default;
248
249protected:
250 void DoExecute(Args &args, CommandReturnObject &result) override {
251 Stream &ostrm = result.GetOutputStream();
252
253 Target *target = GetDebugger().GetSelectedTarget().get();
254 PlatformSP platform_sp;
255 if (target) {
256 platform_sp = target->GetPlatform();
257 }
258 if (!platform_sp) {
260 }
261 if (platform_sp) {
262 platform_sp->GetStatus(ostrm);
264 } else {
265 result.AppendError("no platform is currently selected\n");
266 }
267 }
268};
269
270// "platform connect <connect-url>"
272public:
275 interpreter, "platform connect",
276 "Select the current platform by providing a connection URL.",
277 "platform connect <connect-url>", 0) {
279 }
280
281 ~CommandObjectPlatformConnect() override = default;
282
283protected:
284 void DoExecute(Args &args, CommandReturnObject &result) override {
285 Stream &ostrm = result.GetOutputStream();
286
287 PlatformSP platform_sp(
288 GetDebugger().GetPlatformList().GetSelectedPlatform());
289 if (platform_sp) {
290 Status error(platform_sp->ConnectRemote(args));
291 if (error.Success()) {
292 platform_sp->GetStatus(ostrm);
294
295 platform_sp->ConnectToWaitingProcesses(GetDebugger(), error);
296 if (error.Fail()) {
297 result.AppendError(error.AsCString());
298 }
299 } else {
300 result.AppendErrorWithFormat("%s\n", error.AsCString());
301 }
302 } else {
303 result.AppendError("no platform is currently selected\n");
304 }
305 }
306
307 Options *GetOptions() override {
308 PlatformSP platform_sp(
309 GetDebugger().GetPlatformList().GetSelectedPlatform());
310 OptionGroupOptions *m_platform_options = nullptr;
311 if (platform_sp) {
312 m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
313 if (m_platform_options != nullptr && !m_platform_options->m_did_finalize)
314 m_platform_options->Finalize();
315 }
316 return m_platform_options;
317 }
318};
319
320// "platform disconnect"
322public:
324 : CommandObjectParsed(interpreter, "platform disconnect",
325 "Disconnect from the current platform.",
326 "platform disconnect", 0) {}
327
329
330protected:
331 void DoExecute(Args &args, CommandReturnObject &result) override {
332 PlatformSP platform_sp(
333 GetDebugger().GetPlatformList().GetSelectedPlatform());
334 if (platform_sp) {
335 if (args.GetArgumentCount() == 0) {
337
338 if (platform_sp->IsConnected()) {
339 // Cache the instance name if there is one since we are about to
340 // disconnect and the name might go with it.
341 const char *hostname_cstr = platform_sp->GetHostname();
342 std::string hostname;
343 if (hostname_cstr)
344 hostname.assign(hostname_cstr);
345
346 error = platform_sp->DisconnectRemote();
347 if (error.Success()) {
348 Stream &ostrm = result.GetOutputStream();
349 if (hostname.empty())
350 ostrm.Format("Disconnected from \"{0}\"\n",
351 platform_sp->GetPluginName());
352 else
353 ostrm.Printf("Disconnected from \"%s\"\n", hostname.c_str());
355 } else {
356 result.AppendErrorWithFormat("%s", error.AsCString());
357 }
358 } else {
359 // Not connected...
360 result.AppendErrorWithFormatv("not connected to '{0}'",
361 platform_sp->GetPluginName());
362 }
363 } else {
364 // Bad args
365 result.AppendError(
366 "\"platform disconnect\" doesn't take any arguments");
367 }
368 } else {
369 result.AppendError("no platform is currently selected");
370 }
371 }
372};
373
374// "platform settings"
376public:
378 : CommandObjectParsed(interpreter, "platform settings",
379 "Set settings for the current target's platform.",
380 "platform settings", 0),
381 m_option_working_dir(LLDB_OPT_SET_1, false, "working-dir", 'w',
383 "The working directory for the platform.") {
385 }
386
387 ~CommandObjectPlatformSettings() override = default;
388
389protected:
390 void DoExecute(Args &args, CommandReturnObject &result) override {
391 PlatformSP platform_sp(
392 GetDebugger().GetPlatformList().GetSelectedPlatform());
393 if (platform_sp) {
395 platform_sp->SetWorkingDirectory(
397 } else {
398 result.AppendError("no platform is currently selected");
399 }
400 }
401
402 Options *GetOptions() override {
403 if (!m_options.DidFinalize())
405 return &m_options;
406 }
407
410};
411
412// "platform mkdir"
414public:
416 : CommandObjectParsed(interpreter, "platform mkdir",
417 "Make a new directory on the remote end.", nullptr,
418 0) {
420 }
421
422 ~CommandObjectPlatformMkDir() override = default;
423
424 void DoExecute(Args &args, CommandReturnObject &result) override {
425 PlatformSP platform_sp(
426 GetDebugger().GetPlatformList().GetSelectedPlatform());
427 if (platform_sp) {
428 std::string cmd_line;
429 args.GetCommandString(cmd_line);
430 uint32_t mode;
431 const OptionPermissions *options_permissions =
433 if (options_permissions)
434 mode = options_permissions->m_permissions;
435 else
436 mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX |
437 lldb::eFilePermissionsWorldRX;
438 Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode);
439 if (error.Success()) {
441 } else {
442 result.AppendError(error.AsCString());
443 }
444 } else {
445 result.AppendError("no platform currently selected\n");
446 }
447 }
448
449 Options *GetOptions() override {
450 if (!m_options.DidFinalize()) {
453 }
454 return &m_options;
455 }
456
459};
460
461// "platform fopen"
463public:
465 : CommandObjectParsed(interpreter, "platform file open",
466 "Open a file on the remote end.", nullptr, 0) {
468 }
469
470 ~CommandObjectPlatformFOpen() override = default;
471
472 void DoExecute(Args &args, CommandReturnObject &result) override {
473 PlatformSP platform_sp(
474 GetDebugger().GetPlatformList().GetSelectedPlatform());
475 if (platform_sp) {
477 std::string cmd_line;
478 args.GetCommandString(cmd_line);
479 mode_t perms;
480 const OptionPermissions *options_permissions =
482 if (options_permissions)
483 perms = options_permissions->m_permissions;
484 else
485 perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW |
486 lldb::eFilePermissionsWorldRead;
487 lldb::user_id_t fd = platform_sp->OpenFile(
488 FileSpec(cmd_line),
490 perms, error);
491 if (error.Success()) {
492 result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n", fd);
494 } else {
495 result.AppendError(error.AsCString());
496 }
497 } else {
498 result.AppendError("no platform currently selected\n");
499 }
500 }
501
502 Options *GetOptions() override {
503 if (!m_options.DidFinalize()) {
506 }
507 return &m_options;
508 }
509
512};
513
514// "platform fclose"
516public:
518 : CommandObjectParsed(interpreter, "platform file close",
519 "Close a file on the remote end.", nullptr, 0) {
521 }
522
523 ~CommandObjectPlatformFClose() override = default;
524
525 void DoExecute(Args &args, CommandReturnObject &result) override {
526 PlatformSP platform_sp(
527 GetDebugger().GetPlatformList().GetSelectedPlatform());
528 if (platform_sp) {
529 std::string cmd_line;
530 args.GetCommandString(cmd_line);
532 if (!llvm::to_integer(cmd_line, fd)) {
533 result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.\n",
534 cmd_line);
535 return;
536 }
538 bool success = platform_sp->CloseFile(fd, error);
539 if (success) {
540 result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd);
542 } else {
543 result.AppendError(error.AsCString());
544 }
545 } else {
546 result.AppendError("no platform currently selected\n");
547 }
548 }
549};
550
551// "platform fread"
552
553#define LLDB_OPTIONS_platform_fread
554#include "CommandOptions.inc"
555
557public:
559 : CommandObjectParsed(interpreter, "platform file read",
560 "Read data from a file on the remote end.", nullptr,
561 0) {
563 }
564
565 ~CommandObjectPlatformFRead() override = default;
566
567 void DoExecute(Args &args, CommandReturnObject &result) override {
568 PlatformSP platform_sp(
569 GetDebugger().GetPlatformList().GetSelectedPlatform());
570 if (platform_sp) {
571 std::string cmd_line;
572 args.GetCommandString(cmd_line);
574 if (!llvm::to_integer(cmd_line, fd)) {
575 result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.\n",
576 cmd_line);
577 return;
578 }
579 std::string buffer(m_options.m_count, 0);
581 uint64_t retcode = platform_sp->ReadFile(
582 fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
583 if (retcode != UINT64_MAX) {
584 result.AppendMessageWithFormat("Return = %" PRIu64 "\n", retcode);
585 result.AppendMessageWithFormat("Data = \"%s\"\n", buffer.c_str());
587 } else {
588 result.AppendError(error.AsCString());
589 }
590 } else {
591 result.AppendError("no platform currently selected\n");
592 }
593 }
594
595 Options *GetOptions() override { return &m_options; }
596
597protected:
598 class CommandOptions : public Options {
599 public:
600 CommandOptions() = default;
601
602 ~CommandOptions() override = default;
603
604 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
605 ExecutionContext *execution_context) override {
607 char short_option = (char)m_getopt_table[option_idx].val;
608
609 switch (short_option) {
610 case 'o':
611 if (option_arg.getAsInteger(0, m_offset))
612 error.SetErrorStringWithFormat("invalid offset: '%s'",
613 option_arg.str().c_str());
614 break;
615 case 'c':
616 if (option_arg.getAsInteger(0, m_count))
617 error.SetErrorStringWithFormat("invalid offset: '%s'",
618 option_arg.str().c_str());
619 break;
620 default:
621 llvm_unreachable("Unimplemented option");
622 }
623
624 return error;
625 }
626
627 void OptionParsingStarting(ExecutionContext *execution_context) override {
628 m_offset = 0;
629 m_count = 1;
630 }
631
632 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
633 return llvm::ArrayRef(g_platform_fread_options);
634 }
635
636 // Instance variables to hold the values for command options.
637
638 uint32_t m_offset;
639 uint32_t m_count;
640 };
641
643};
644
645// "platform fwrite"
646
647#define LLDB_OPTIONS_platform_fwrite
648#include "CommandOptions.inc"
649
651public:
653 : CommandObjectParsed(interpreter, "platform file write",
654 "Write data to a file on the remote end.", nullptr,
655 0) {
657 }
658
659 ~CommandObjectPlatformFWrite() override = default;
660
661 void DoExecute(Args &args, CommandReturnObject &result) override {
662 PlatformSP platform_sp(
663 GetDebugger().GetPlatformList().GetSelectedPlatform());
664 if (platform_sp) {
665 std::string cmd_line;
666 args.GetCommandString(cmd_line);
669 if (!llvm::to_integer(cmd_line, fd)) {
670 result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.",
671 cmd_line);
672 return;
673 }
674 uint64_t retcode =
675 platform_sp->WriteFile(fd, m_options.m_offset, &m_options.m_data[0],
676 m_options.m_data.size(), error);
677 if (retcode != UINT64_MAX) {
678 result.AppendMessageWithFormat("Return = %" PRIu64 "\n", retcode);
680 } else {
681 result.AppendError(error.AsCString());
682 }
683 } else {
684 result.AppendError("no platform currently selected\n");
685 }
686 }
687
688 Options *GetOptions() override { return &m_options; }
689
690protected:
691 class CommandOptions : public Options {
692 public:
693 CommandOptions() = default;
694
695 ~CommandOptions() override = default;
696
697 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
698 ExecutionContext *execution_context) override {
700 char short_option = (char)m_getopt_table[option_idx].val;
701
702 switch (short_option) {
703 case 'o':
704 if (option_arg.getAsInteger(0, m_offset))
705 error.SetErrorStringWithFormat("invalid offset: '%s'",
706 option_arg.str().c_str());
707 break;
708 case 'd':
709 m_data.assign(std::string(option_arg));
710 break;
711 default:
712 llvm_unreachable("Unimplemented option");
713 }
714
715 return error;
716 }
717
718 void OptionParsingStarting(ExecutionContext *execution_context) override {
719 m_offset = 0;
720 m_data.clear();
721 }
722
723 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
724 return llvm::ArrayRef(g_platform_fwrite_options);
725 }
726
727 // Instance variables to hold the values for command options.
728
729 uint32_t m_offset;
730 std::string m_data;
731 };
732
734};
735
737public:
738 // Constructors and Destructors
741 interpreter, "platform file",
742 "Commands to access files on the current platform.",
743 "platform file [open|close|read|write] ...") {
745 "open", CommandObjectSP(new CommandObjectPlatformFOpen(interpreter)));
747 "close", CommandObjectSP(new CommandObjectPlatformFClose(interpreter)));
749 "read", CommandObjectSP(new CommandObjectPlatformFRead(interpreter)));
751 "write", CommandObjectSP(new CommandObjectPlatformFWrite(interpreter)));
752 }
753
754 ~CommandObjectPlatformFile() override = default;
755
756private:
757 // For CommandObjectPlatform only
761};
762
763// "platform get-file remote-file-path host-file-path"
765public:
768 interpreter, "platform get-file",
769 "Transfer a file from the remote end to the local host.",
770 "platform get-file <remote-file-spec> <local-file-spec>", 0) {
772 R"(Examples:
773
774(lldb) platform get-file /the/remote/file/path /the/local/file/path
775
776 Transfer a file from the remote end with file path /the/remote/file/path to the local host.)");
777
778 CommandArgumentEntry arg1, arg2;
779 CommandArgumentData file_arg_remote, file_arg_host;
780
781 // Define the first (and only) variant of this arg.
782 file_arg_remote.arg_type = eArgTypeRemoteFilename;
783 file_arg_remote.arg_repetition = eArgRepeatPlain;
784 // There is only one variant this argument could be; put it into the
785 // argument entry.
786 arg1.push_back(file_arg_remote);
787
788 // Define the second (and only) variant of this arg.
789 file_arg_host.arg_type = eArgTypeFilename;
790 file_arg_host.arg_repetition = eArgRepeatPlain;
791 // There is only one variant this argument could be; put it into the
792 // argument entry.
793 arg2.push_back(file_arg_host);
794
795 // Push the data for the first and the second arguments into the
796 // m_arguments vector.
797 m_arguments.push_back(arg1);
798 m_arguments.push_back(arg2);
799 }
801 ~CommandObjectPlatformGetFile() override = default;
802
803 void
805 OptionElementVector &opt_element_vector) override {
806 if (request.GetCursorIndex() == 0)
809 nullptr);
810 else if (request.GetCursorIndex() == 1)
813 }
814
815 void DoExecute(Args &args, CommandReturnObject &result) override {
816 // If the number of arguments is incorrect, issue an error message.
817 if (args.GetArgumentCount() != 2) {
818 result.AppendError("required arguments missing; specify both the "
819 "source and destination file paths");
820 return;
821 }
822
823 PlatformSP platform_sp(
824 GetDebugger().GetPlatformList().GetSelectedPlatform());
825 if (platform_sp) {
826 const char *remote_file_path = args.GetArgumentAtIndex(0);
827 const char *local_file_path = args.GetArgumentAtIndex(1);
828 Status error = platform_sp->GetFile(FileSpec(remote_file_path),
829 FileSpec(local_file_path));
830 if (error.Success()) {
832 "successfully get-file from %s (remote) to %s (host)\n",
833 remote_file_path, local_file_path);
835 } else {
836 result.AppendMessageWithFormat("get-file failed: %s\n",
837 error.AsCString());
838 }
839 } else {
840 result.AppendError("no platform currently selected\n");
841 }
842 }
843};
844
845// "platform get-size remote-file-path"
847public:
849 : CommandObjectParsed(interpreter, "platform get-size",
850 "Get the file size from the remote end.",
851 "platform get-size <remote-file-spec>", 0) {
853 R"(Examples:
854
855(lldb) platform get-size /the/remote/file/path
856
857 Get the file size from the remote end with path /the/remote/file/path.)");
861
862 ~CommandObjectPlatformGetSize() override = default;
863
864 void DoExecute(Args &args, CommandReturnObject &result) override {
865 // If the number of arguments is incorrect, issue an error message.
866 if (args.GetArgumentCount() != 1) {
867 result.AppendError("required argument missing; specify the source file "
868 "path as the only argument");
869 return;
870 }
871
872 PlatformSP platform_sp(
873 GetDebugger().GetPlatformList().GetSelectedPlatform());
874 if (platform_sp) {
875 std::string remote_file_path(args.GetArgumentAtIndex(0));
876 user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path));
877 if (size != UINT64_MAX) {
878 result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64
879 "\n",
880 remote_file_path.c_str(), size);
882 } else {
884 "Error getting file size of %s (remote)\n",
885 remote_file_path.c_str());
886 }
887 } else {
888 result.AppendError("no platform currently selected\n");
889 }
890 }
891};
892
893// "platform get-permissions remote-file-path"
895public:
897 : CommandObjectParsed(interpreter, "platform get-permissions",
898 "Get the file permission bits from the remote end.",
899 "platform get-permissions <remote-file-spec>", 0) {
901 R"(Examples:
902
903(lldb) platform get-permissions /the/remote/file/path
904
905 Get the file permissions from the remote end with path /the/remote/file/path.)");
909
910 ~CommandObjectPlatformGetPermissions() override = default;
911
912 void DoExecute(Args &args, CommandReturnObject &result) override {
913 // If the number of arguments is incorrect, issue an error message.
914 if (args.GetArgumentCount() != 1) {
915 result.AppendError("required argument missing; specify the source file "
916 "path as the only argument");
917 return;
918 }
919
920 PlatformSP platform_sp(
921 GetDebugger().GetPlatformList().GetSelectedPlatform());
922 if (platform_sp) {
923 std::string remote_file_path(args.GetArgumentAtIndex(0));
924 uint32_t permissions;
925 Status error = platform_sp->GetFilePermissions(FileSpec(remote_file_path),
926 permissions);
927 if (error.Success()) {
929 "File permissions of %s (remote): 0o%04" PRIo32 "\n",
930 remote_file_path.c_str(), permissions);
932 } else
933 result.AppendError(error.AsCString());
934 } else {
935 result.AppendError("no platform currently selected\n");
936 }
937 }
938};
939
940// "platform file-exists remote-file-path"
942public:
944 : CommandObjectParsed(interpreter, "platform file-exists",
945 "Check if the file exists on the remote end.",
946 "platform file-exists <remote-file-spec>", 0) {
948 R"(Examples:
949
950(lldb) platform file-exists /the/remote/file/path
951
952 Check if /the/remote/file/path exists on the remote end.)");
956
957 ~CommandObjectPlatformFileExists() override = default;
958
959 void DoExecute(Args &args, CommandReturnObject &result) override {
960 // If the number of arguments is incorrect, issue an error message.
961 if (args.GetArgumentCount() != 1) {
962 result.AppendError("required argument missing; specify the source file "
963 "path as the only argument");
964 return;
965 }
966
967 PlatformSP platform_sp(
968 GetDebugger().GetPlatformList().GetSelectedPlatform());
969 if (platform_sp) {
970 std::string remote_file_path(args.GetArgumentAtIndex(0));
971 bool exists = platform_sp->GetFileExists(FileSpec(remote_file_path));
973 "File %s (remote) %s\n",
974 remote_file_path.c_str(), exists ? "exists" : "does not exist");
976 } else {
977 result.AppendError("no platform currently selected\n");
978 }
979 }
980};
981
982// "platform put-file"
984public:
987 interpreter, "platform put-file",
988 "Transfer a file from this system to the remote end.",
989 "platform put-file <source> [<destination>]", 0) {
991 R"(Examples:
992
993(lldb) platform put-file /source/foo.txt /destination/bar.txt
994
995(lldb) platform put-file /source/foo.txt
996
997 Relative source file paths are resolved against lldb's local working directory.
999 Omitting the destination places the file in the platform working directory.)");
1002 m_arguments.push_back({source_arg});
1003 m_arguments.push_back({path_arg});
1004 }
1005
1006 ~CommandObjectPlatformPutFile() override = default;
1007
1008 void
1010 OptionElementVector &opt_element_vector) override {
1011 if (request.GetCursorIndex() == 0)
1014 else if (request.GetCursorIndex() == 1)
1017 nullptr);
1018 }
1019
1020 void DoExecute(Args &args, CommandReturnObject &result) override {
1021 const char *src = args.GetArgumentAtIndex(0);
1022 const char *dst = args.GetArgumentAtIndex(1);
1023
1024 FileSpec src_fs(src);
1025 FileSystem::Instance().Resolve(src_fs);
1026 FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString());
1027
1028 PlatformSP platform_sp(
1029 GetDebugger().GetPlatformList().GetSelectedPlatform());
1030 if (platform_sp) {
1031 Status error(platform_sp->PutFile(src_fs, dst_fs));
1032 if (error.Success()) {
1034 } else {
1035 result.AppendError(error.AsCString());
1036 }
1037 } else {
1038 result.AppendError("no platform currently selected\n");
1039 }
1040 }
1041};
1042
1043// "platform process launch"
1045public:
1047 : CommandObjectParsed(interpreter, "platform process launch",
1048 "Launch a new process on a remote platform.",
1049 "platform process launch program",
1050 eCommandRequiresTarget | eCommandTryTargetAPILock),
1051 m_class_options("scripted process", true, 'C', 'k', 'v', 0) {
1057 }
1058
1059 void
1061 OptionElementVector &opt_element_vector) override {
1062 // I didn't make a type for RemoteRunArgs, but since we're going to run
1063 // this on the remote system we should use the remote completer.
1066 nullptr);
1067 }
1068
1070
1071 Options *GetOptions() override { return &m_all_options; }
1072
1073protected:
1074 void DoExecute(Args &args, CommandReturnObject &result) override {
1075 Target *target = GetDebugger().GetSelectedTarget().get();
1076 PlatformSP platform_sp;
1077 if (target) {
1078 platform_sp = target->GetPlatform();
1079 }
1080 if (!platform_sp) {
1082 }
1083
1084 if (platform_sp) {
1085 Status error;
1086 const size_t argc = args.GetArgumentCount();
1087 Target *target = m_exe_ctx.GetTargetPtr();
1088 Module *exe_module = target->GetExecutableModulePointer();
1089 if (exe_module) {
1091 llvm::SmallString<128> exe_path;
1093 if (!exe_path.empty())
1096 }
1097
1098 if (!m_class_options.GetName().empty()) {
1099 m_options.launch_info.SetProcessPluginName("ScriptedProcess");
1100 ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
1104 }
1105
1106 if (argc > 0) {
1108 // We already have an executable file, so we will use this and all
1109 // arguments to this function are extra arguments
1111 } else {
1112 // We don't have any file yet, so the first argument is our
1113 // executable, and the rest are program arguments
1114 const bool first_arg_is_executable = true;
1115 m_options.launch_info.SetArguments(args, first_arg_is_executable);
1116 }
1117 }
1118
1120 Debugger &debugger = GetDebugger();
1121
1122 if (argc == 0) {
1123 // If no arguments were given to the command, use target.run-args.
1124 Args target_run_args;
1125 target->GetRunArguments(target_run_args);
1127 }
1128
1129 ProcessSP process_sp(platform_sp->DebugProcess(
1130 m_options.launch_info, debugger, *target, error));
1131
1132 if (!process_sp && error.Success()) {
1133 result.AppendError("failed to launch or debug process");
1134 return;
1135 } else if (!error.Success()) {
1136 result.AppendError(error.AsCString());
1137 return;
1138 }
1139
1140 const bool synchronous_execution =
1142 auto launch_info = m_options.launch_info;
1143 bool rebroadcast_first_stop =
1144 !synchronous_execution &&
1145 launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
1146
1147 EventSP first_stop_event_sp;
1148 StateType state = process_sp->WaitForProcessToStop(
1149 std::nullopt, &first_stop_event_sp, rebroadcast_first_stop,
1150 launch_info.GetHijackListener());
1151 process_sp->RestoreProcessEvents();
1152
1153 if (rebroadcast_first_stop) {
1154 assert(first_stop_event_sp);
1155 process_sp->BroadcastEvent(first_stop_event_sp);
1156 return;
1157 }
1158
1159 switch (state) {
1160 case eStateStopped: {
1161 if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
1162 break;
1163 if (synchronous_execution) {
1164 // Now we have handled the stop-from-attach, and we are just
1165 // switching to a synchronous resume. So we should switch to the
1166 // SyncResume hijacker.
1167 process_sp->ResumeSynchronous(&result.GetOutputStream());
1168 } else {
1169 error = process_sp->Resume();
1170 if (!error.Success()) {
1171 result.AppendErrorWithFormat(
1172 "process resume at entry point failed: %s",
1173 error.AsCString());
1174 }
1175 }
1176 } break;
1177 default:
1178 result.AppendErrorWithFormat(
1179 "initial process state wasn't stopped: %s",
1180 StateAsCString(state));
1181 break;
1182 }
1183
1184 if (process_sp && process_sp->IsAlive()) {
1186 return;
1187 }
1188 } else {
1189 result.AppendError("'platform process launch' uses the current target "
1190 "file and arguments, or the executable and its "
1191 "arguments can be specified in this command");
1192 return;
1193 }
1194 } else {
1195 result.AppendError("no platform is selected\n");
1196 }
1197 }
1198
1202};
1203
1204// "platform process list"
1205
1207#define LLDB_OPTIONS_platform_process_list
1208#include "CommandOptions.inc"
1209
1211public:
1213 : CommandObjectParsed(interpreter, "platform process list",
1214 "List processes on a remote platform by name, pid, "
1215 "or many other matching attributes.",
1216 "platform process list", 0) {}
1217
1219
1220 Options *GetOptions() override { return &m_options; }
1221
1222protected:
1223 void DoExecute(Args &args, CommandReturnObject &result) override {
1224 Target *target = GetDebugger().GetSelectedTarget().get();
1225 PlatformSP platform_sp;
1226 if (target) {
1227 platform_sp = target->GetPlatform();
1228 }
1229 if (!platform_sp) {
1231 }
1232
1233 if (platform_sp) {
1234 Status error;
1235 if (platform_sp) {
1236 Stream &ostrm = result.GetOutputStream();
1237
1239 if (pid != LLDB_INVALID_PROCESS_ID) {
1240 ProcessInstanceInfo proc_info;
1241 if (platform_sp->GetProcessInfo(pid, proc_info)) {
1244 proc_info.DumpAsTableRow(ostrm, platform_sp->GetUserIDResolver(),
1247 } else {
1248 result.AppendErrorWithFormat(
1249 "no process found with pid = %" PRIu64 "\n", pid);
1250 }
1251 } else {
1252 ProcessInstanceInfoList proc_infos;
1253 const uint32_t matches =
1254 platform_sp->FindProcesses(m_options.match_info, proc_infos);
1255 const char *match_desc = nullptr;
1256 const char *match_name =
1258 if (match_name && match_name[0]) {
1260 case NameMatch::Ignore:
1261 break;
1262 case NameMatch::Equals:
1263 match_desc = "matched";
1264 break;
1265 case NameMatch::Contains:
1266 match_desc = "contained";
1267 break;
1268 case NameMatch::StartsWith:
1269 match_desc = "started with";
1270 break;
1271 case NameMatch::EndsWith:
1272 match_desc = "ended with";
1273 break;
1274 case NameMatch::RegularExpression:
1275 match_desc = "matched the regular expression";
1276 break;
1277 }
1278 }
1279
1280 if (matches == 0) {
1281 if (match_desc)
1283 "no processes were found that {0} \"{1}\" on the \"{2}\" "
1284 "platform\n",
1285 match_desc, match_name, platform_sp->GetName());
1286 else
1288 "no processes were found on the \"{0}\" platform\n",
1289 platform_sp->GetName());
1290 } else {
1292 "{0} matching process{1} found on \"{2}\"", matches,
1293 matches > 1 ? "es were" : " was", platform_sp->GetName());
1294 if (match_desc)
1295 result.AppendMessageWithFormat(" whose name %s \"%s\"",
1296 match_desc, match_name);
1297 result.AppendMessageWithFormat("\n");
1300 for (uint32_t i = 0; i < matches; ++i) {
1301 proc_infos[i].DumpAsTableRow(
1302 ostrm, platform_sp->GetUserIDResolver(), m_options.show_args,
1304 }
1305 }
1306 }
1307 }
1308 } else {
1309 result.AppendError("no platform is selected\n");
1310 }
1311 }
1312
1313 class CommandOptions : public Options {
1314 public:
1315 CommandOptions() = default;
1316
1317 ~CommandOptions() override = default;
1318
1319 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1320 ExecutionContext *execution_context) override {
1321 Status error;
1322 const int short_option = m_getopt_table[option_idx].val;
1323 bool success = false;
1324
1325 uint32_t id = LLDB_INVALID_PROCESS_ID;
1326 success = !option_arg.getAsInteger(0, id);
1327 switch (short_option) {
1328 case 'p': {
1330 if (!success)
1331 error.SetErrorStringWithFormat("invalid process ID string: '%s'",
1332 option_arg.str().c_str());
1333 break;
1334 }
1335 case 'P':
1337 if (!success)
1338 error.SetErrorStringWithFormat(
1339 "invalid parent process ID string: '%s'",
1340 option_arg.str().c_str());
1341 break;
1342
1343 case 'u':
1345 if (!success)
1346 error.SetErrorStringWithFormat("invalid user ID string: '%s'",
1347 option_arg.str().c_str());
1348 break;
1349
1350 case 'U':
1352 : UINT32_MAX);
1353 if (!success)
1354 error.SetErrorStringWithFormat(
1355 "invalid effective user ID string: '%s'",
1356 option_arg.str().c_str());
1357 break;
1358
1359 case 'g':
1361 if (!success)
1362 error.SetErrorStringWithFormat("invalid group ID string: '%s'",
1363 option_arg.str().c_str());
1364 break;
1365
1366 case 'G':
1368 : UINT32_MAX);
1369 if (!success)
1370 error.SetErrorStringWithFormat(
1371 "invalid effective group ID string: '%s'",
1372 option_arg.str().c_str());
1373 break;
1374
1375 case 'a': {
1376 TargetSP target_sp =
1377 execution_context ? execution_context->GetTargetSP() : TargetSP();
1378 DebuggerSP debugger_sp =
1379 target_sp ? target_sp->GetDebugger().shared_from_this()
1380 : DebuggerSP();
1381 PlatformSP platform_sp =
1382 debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform()
1383 : PlatformSP();
1385 Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
1386 } break;
1387
1388 case 'n':
1390 option_arg, FileSpec::Style::native);
1391 match_info.SetNameMatchType(NameMatch::Equals);
1392 break;
1393
1394 case 'e':
1396 option_arg, FileSpec::Style::native);
1397 match_info.SetNameMatchType(NameMatch::EndsWith);
1398 break;
1399
1400 case 's':
1402 option_arg, FileSpec::Style::native);
1403 match_info.SetNameMatchType(NameMatch::StartsWith);
1404 break;
1405
1406 case 'c':
1408 option_arg, FileSpec::Style::native);
1409 match_info.SetNameMatchType(NameMatch::Contains);
1410 break;
1411
1412 case 'r':
1414 option_arg, FileSpec::Style::native);
1415 match_info.SetNameMatchType(NameMatch::RegularExpression);
1416 break;
1417
1418 case 'A':
1419 show_args = true;
1420 break;
1421
1422 case 'v':
1423 verbose = true;
1424 break;
1425
1426 case 'x':
1428 break;
1429
1430 default:
1431 llvm_unreachable("Unimplemented option");
1432 }
1433
1434 return error;
1435 }
1436
1437 void OptionParsingStarting(ExecutionContext *execution_context) override {
1438 match_info.Clear();
1439 show_args = false;
1440 verbose = false;
1441 }
1442
1443 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1444 return llvm::ArrayRef(g_platform_process_list_options);
1445 }
1446
1447 // Instance variables to hold the values for command options.
1448
1450 bool show_args = false;
1451 bool verbose = false;
1452 };
1453
1455};
1456
1457// "platform process info"
1459public:
1462 interpreter, "platform process info",
1463 "Get detailed information for one or more process by process ID.",
1464 "platform process info <pid> [<pid> <pid> ...]", 0) {
1466 }
1467
1469
1470protected:
1471 void DoExecute(Args &args, CommandReturnObject &result) override {
1472 Target *target = GetDebugger().GetSelectedTarget().get();
1473 PlatformSP platform_sp;
1474 if (target) {
1475 platform_sp = target->GetPlatform();
1476 }
1477 if (!platform_sp) {
1479 }
1480
1481 if (platform_sp) {
1482 const size_t argc = args.GetArgumentCount();
1483 if (argc > 0) {
1484 Status error;
1485
1486 if (platform_sp->IsConnected()) {
1487 Stream &ostrm = result.GetOutputStream();
1488 for (auto &entry : args.entries()) {
1489 lldb::pid_t pid;
1490 if (entry.ref().getAsInteger(0, pid)) {
1491 result.AppendErrorWithFormat("invalid process ID argument '%s'",
1492 entry.ref().str().c_str());
1493 break;
1494 } else {
1495 ProcessInstanceInfo proc_info;
1496 if (platform_sp->GetProcessInfo(pid, proc_info)) {
1497 ostrm.Printf("Process information for process %" PRIu64 ":\n",
1498 pid);
1499 proc_info.Dump(ostrm, platform_sp->GetUserIDResolver());
1500 } else {
1501 ostrm.Printf("error: no process information is available for "
1502 "process %" PRIu64 "\n",
1503 pid);
1504 }
1505 ostrm.EOL();
1506 }
1507 }
1508 } else {
1509 // Not connected...
1510 result.AppendErrorWithFormatv("not connected to '{0}'",
1511 platform_sp->GetPluginName());
1512 }
1513 } else {
1514 // No args
1515 result.AppendError("one or more process id(s) must be specified");
1516 }
1517 } else {
1518 result.AppendError("no platform is currently selected");
1519 }
1520 }
1521};
1522
1523#define LLDB_OPTIONS_platform_process_attach
1524#include "CommandOptions.inc"
1525
1527public:
1529 : CommandObjectParsed(interpreter, "platform process attach",
1530 "Attach to a process.",
1531 "platform process attach <cmd-options>"),
1532 m_class_options("scripted process", true, 'C', 'k', 'v', 0) {
1537 }
1538
1540
1541 void DoExecute(Args &command, CommandReturnObject &result) override {
1542 PlatformSP platform_sp(
1543 GetDebugger().GetPlatformList().GetSelectedPlatform());
1544 if (platform_sp) {
1545
1546 if (!m_class_options.GetName().empty()) {
1547 m_options.attach_info.SetProcessPluginName("ScriptedProcess");
1548 ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
1551 }
1552
1553 Status err;
1554 ProcessSP remote_process_sp = platform_sp->Attach(
1555 m_options.attach_info, GetDebugger(), nullptr, err);
1556 if (err.Fail()) {
1557 result.AppendError(err.AsCString());
1558 } else if (!remote_process_sp) {
1559 result.AppendError("could not attach: unknown reason");
1560 } else
1562 } else {
1563 result.AppendError("no platform is currently selected");
1564 }
1565 }
1566
1567 Options *GetOptions() override { return &m_all_options; }
1568
1569protected:
1573};
1574
1576public:
1577 // Constructors and Destructors
1579 : CommandObjectMultiword(interpreter, "platform process",
1580 "Commands to query, launch and attach to "
1581 "processes on the current platform.",
1582 "platform process [attach|launch|list] ...") {
1584 "attach",
1587 "launch",
1590 interpreter)));
1592 interpreter)));
1593 }
1594
1595 ~CommandObjectPlatformProcess() override = default;
1596
1597private:
1598 // For CommandObjectPlatform only
1602};
1603
1604// "platform shell"
1605#define LLDB_OPTIONS_platform_shell
1606#include "CommandOptions.inc"
1607
1609public:
1610 class CommandOptions : public Options {
1611 public:
1612 CommandOptions() = default;
1613
1614 ~CommandOptions() override = default;
1615
1616 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1617 return llvm::ArrayRef(g_platform_shell_options);
1618 }
1619
1620 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1621 ExecutionContext *execution_context) override {
1622 Status error;
1623
1624 const char short_option = (char)GetDefinitions()[option_idx].short_option;
1625
1626 switch (short_option) {
1627 case 'h':
1628 m_use_host_platform = true;
1629 break;
1630 case 't':
1631 uint32_t timeout_sec;
1632 if (option_arg.getAsInteger(10, timeout_sec))
1633 error.SetErrorStringWithFormat(
1634 "could not convert \"%s\" to a numeric value.",
1635 option_arg.str().c_str());
1636 else
1637 m_timeout = std::chrono::seconds(timeout_sec);
1638 break;
1639 case 's': {
1640 if (option_arg.empty()) {
1641 error.SetErrorStringWithFormat(
1642 "missing shell interpreter path for option -i|--interpreter.");
1643 return error;
1644 }
1645
1646 m_shell_interpreter = option_arg.str();
1647 break;
1648 }
1649 default:
1650 llvm_unreachable("Unimplemented option");
1651 }
1652
1653 return error;
1654 }
1655
1656 void OptionParsingStarting(ExecutionContext *execution_context) override {
1657 m_timeout.reset();
1658 m_use_host_platform = false;
1659 m_shell_interpreter.clear();
1660 }
1661
1662 Timeout<std::micro> m_timeout = std::chrono::seconds(10);
1665 };
1666
1668 : CommandObjectRaw(interpreter, "platform shell",
1669 "Run a shell command on the current platform.",
1670 "platform shell <shell-command>", 0) {
1672 }
1673
1674 ~CommandObjectPlatformShell() override = default;
1675
1676 Options *GetOptions() override { return &m_options; }
1677
1678 void DoExecute(llvm::StringRef raw_command_line,
1679 CommandReturnObject &result) override {
1682
1683 // Print out an usage syntax on an empty command line.
1684 if (raw_command_line.empty()) {
1685 result.GetOutputStream().Printf("%s\n", this->GetSyntax().str().c_str());
1686 return;
1687 }
1688
1689 const bool is_alias = !raw_command_line.contains("platform");
1690 OptionsWithRaw args(raw_command_line);
1691
1692 if (args.HasArgs())
1693 if (!ParseOptions(args.GetArgs(), result))
1694 return;
1695
1696 if (args.GetRawPart().empty()) {
1697 result.GetOutputStream().Printf("%s <shell-command>\n",
1698 is_alias ? "shell" : "platform shell");
1699 return;
1700 }
1701
1702 llvm::StringRef cmd = args.GetRawPart();
1703
1704 PlatformSP platform_sp(
1707 : GetDebugger().GetPlatformList().GetSelectedPlatform());
1708 Status error;
1709 if (platform_sp) {
1710 FileSpec working_dir{};
1711 std::string output;
1712 int status = -1;
1713 int signo = -1;
1714 error = (platform_sp->RunShellCommand(m_options.m_shell_interpreter, cmd,
1715 working_dir, &status, &signo,
1716 &output, m_options.m_timeout));
1717 if (!output.empty())
1718 result.GetOutputStream().PutCString(output);
1719 if (status > 0) {
1720 if (signo > 0) {
1721 const char *signo_cstr = Host::GetSignalAsCString(signo);
1722 if (signo_cstr)
1723 result.GetOutputStream().Printf(
1724 "error: command returned with status %i and signal %s\n",
1725 status, signo_cstr);
1726 else
1727 result.GetOutputStream().Printf(
1728 "error: command returned with status %i and signal %i\n",
1729 status, signo);
1730 } else
1731 result.GetOutputStream().Printf(
1732 "error: command returned with status %i\n", status);
1733 }
1734 } else {
1735 result.GetOutputStream().Printf(
1736 "error: cannot run remote shell commands without a platform\n");
1737 error.SetErrorString(
1738 "error: cannot run remote shell commands without a platform");
1739 }
1740
1741 if (error.Fail()) {
1742 result.AppendError(error.AsCString());
1743 } else {
1745 }
1746 }
1747
1749};
1750
1751// "platform install" - install a target to a remote end
1753public:
1756 interpreter, "platform target-install",
1757 "Install a target (bundle or executable file) to the remote end.",
1758 "platform target-install <local-thing> <remote-sandbox>", 0) {
1761 m_arguments.push_back({local_arg});
1762 m_arguments.push_back({remote_arg});
1763 }
1764
1765 ~CommandObjectPlatformInstall() override = default;
1766
1767 void
1769 OptionElementVector &opt_element_vector) override {
1770 if (request.GetCursorIndex())
1771 return;
1774 }
1775
1776 void DoExecute(Args &args, CommandReturnObject &result) override {
1777 if (args.GetArgumentCount() != 2) {
1778 result.AppendError("platform target-install takes two arguments");
1779 return;
1780 }
1781 // TODO: move the bulk of this code over to the platform itself
1782 FileSpec src(args.GetArgumentAtIndex(0));
1784 FileSpec dst(args.GetArgumentAtIndex(1));
1785 if (!FileSystem::Instance().Exists(src)) {
1786 result.AppendError("source location does not exist or is not accessible");
1787 return;
1788 }
1789 PlatformSP platform_sp(
1790 GetDebugger().GetPlatformList().GetSelectedPlatform());
1791 if (!platform_sp) {
1792 result.AppendError("no platform currently selected");
1793 return;
1794 }
1795
1796 Status error = platform_sp->Install(src, dst);
1797 if (error.Success()) {
1799 } else {
1800 result.AppendErrorWithFormat("install failed: %s", error.AsCString());
1801 }
1802 }
1803};
1804
1807 interpreter, "platform", "Commands to manage and create platforms.",
1808 "platform [connect|disconnect|info|list|status|select] ...") {
1809 LoadSubCommand("select",
1811 LoadSubCommand("list",
1812 CommandObjectSP(new CommandObjectPlatformList(interpreter)));
1813 LoadSubCommand("status",
1816 new CommandObjectPlatformConnect(interpreter)));
1818 "disconnect",
1821 interpreter)));
1822 LoadSubCommand("mkdir",
1824 LoadSubCommand("file",
1825 CommandObjectSP(new CommandObjectPlatformFile(interpreter)));
1826 LoadSubCommand("file-exists",
1829 interpreter)));
1830 LoadSubCommand("get-permissions",
1833 interpreter)));
1835 interpreter)));
1837 new CommandObjectPlatformProcess(interpreter)));
1838 LoadSubCommand("shell",
1841 "target-install",
1843}
1844
static mode_t ParsePermissionString(const char *)=delete
static PosixPlatformCommandOptionValidator posix_validator
static llvm::raw_ostream & error(Stream &strm)
~CommandObjectPlatformConnect() override=default
CommandObjectPlatformConnect(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformDisconnect() override=default
CommandObjectPlatformDisconnect(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformFClose(CommandInterpreter &interpreter)
~CommandObjectPlatformFClose() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformFOpen() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformFOpen(CommandInterpreter &interpreter)
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
CommandObjectPlatformFRead(CommandInterpreter &interpreter)
~CommandObjectPlatformFRead() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandObjectPlatformFWrite() override=default
CommandObjectPlatformFWrite(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformFileExists(CommandInterpreter &interpreter)
~CommandObjectPlatformFileExists() override=default
CommandObjectPlatformFile(CommandInterpreter &interpreter)
const CommandObjectPlatformFile & operator=(const CommandObjectPlatformFile &)=delete
CommandObjectPlatformFile(const CommandObjectPlatformFile &)=delete
~CommandObjectPlatformFile() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformGetFile() override=default
CommandObjectPlatformGetFile(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectPlatformGetPermissions() override=default
CommandObjectPlatformGetPermissions(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformGetSize(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformGetSize() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectPlatformInstall() override=default
CommandObjectPlatformInstall(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformList(CommandInterpreter &interpreter)
~CommandObjectPlatformList() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformMkDir(CommandInterpreter &interpreter)
~CommandObjectPlatformMkDir() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectPlatformProcessAttach(CommandInterpreter &interpreter)
~CommandObjectPlatformProcessAttach() override=default
OptionGroupPythonClassWithDict m_class_options
~CommandObjectPlatformProcessInfo() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformProcessInfo(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformProcessLaunch() override=default
OptionGroupPythonClassWithDict m_class_options
CommandObjectPlatformProcessLaunch(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandObjectPlatformProcessList() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformProcessList(CommandInterpreter &interpreter)
const CommandObjectPlatformProcess & operator=(const CommandObjectPlatformProcess &)=delete
CommandObjectPlatformProcess(const CommandObjectPlatformProcess &)=delete
~CommandObjectPlatformProcess() override=default
CommandObjectPlatformProcess(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectPlatformPutFile(CommandInterpreter &interpreter)
~CommandObjectPlatformPutFile() override=default
~CommandObjectPlatformSelect() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
void HandleCompletion(CompletionRequest &request) override
This default version handles calling option argument completions and then calls HandleArgumentComplet...
CommandObjectPlatformSelect(CommandInterpreter &interpreter)
CommandObjectPlatformSettings(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectPlatformSettings() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void DoExecute(llvm::StringRef raw_command_line, CommandReturnObject &result) override
~CommandObjectPlatformShell() override=default
CommandObjectPlatformShell(CommandInterpreter &interpreter)
~CommandObjectPlatformStatus() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectPlatformStatus(CommandInterpreter &interpreter)
const OptionPermissions & operator=(const OptionPermissions &)=delete
void OptionParsingStarting(ExecutionContext *execution_context) override
OptionPermissions()=default
lldb_private::Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
~OptionPermissions() override=default
OptionPermissions(const OptionPermissions &)=delete
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
An architecture specification class.
Definition: ArchSpec.h:31
A command line argument class.
Definition: Args.h:33
void AppendArguments(const Args &rhs)
Definition: Args.cpp:297
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:116
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:322
llvm::ArrayRef< ArgEntry > entries() const
Definition: Args.h:128
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:263
bool GetCommandString(std::string &command) const
Definition: Args.cpp:211
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
static void PlatformPluginNames(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher)
ExecutionContext GetExecutionContext() const
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
CommandObjectPlatform(CommandInterpreter &interpreter)
std::vector< CommandArgumentData > CommandArgumentEntry
virtual void SetHelpLong(llvm::StringRef str)
void AddSimpleArgumentList(lldb::CommandArgumentType arg_type, ArgumentRepetitionType repetition_type=eArgRepeatPlain)
ExecutionContext m_exe_ctx
std::vector< CommandArgumentEntry > m_arguments
CommandInterpreter & GetCommandInterpreter()
CommandInterpreter & m_interpreter
bool ParseOptions(Args &args, CommandReturnObject &result)
virtual llvm::StringRef GetSyntax()
void AppendErrorWithFormatv(const char *format, Args &&... args)
void void AppendError(llvm::StringRef in_string)
void SetStatus(lldb::ReturnStatus status)
void void AppendMessageWithFormatv(const char *format, Args &&... args)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
"lldb/Utility/ArgCompletionRequest.h"
A class to manage flag bits.
Definition: Debugger.h:79
lldb::TargetSP GetSelectedTarget()
Definition: Debugger.h:193
CommandInterpreter & GetCommandInterpreter()
Definition: Debugger.h:176
PlatformList & GetPlatformList()
Definition: Debugger.h:208
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
A file utility class.
Definition: FileSpec.h:56
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
@ eOpenOptionReadWrite
Definition: File.h:53
@ eOpenOptionCanCreate
Definition: File.h:56
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
static const char * GetSignalAsCString(int signo)
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
const ArchSpec & GetArchitecture() const
Get const accessor for the module architecture.
Definition: Module.cpp:1035
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:452
OptionValueFileSpec & GetOptionValue()
const OptionGroup * GetGroupWithOption(char short_opt)
Definition: Options.cpp:763
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:755
void SetPlatformName(const char *platform_name)
lldb::PlatformSP CreatePlatformWithOptions(CommandInterpreter &interpreter, const ArchSpec &arch, bool make_selected, Status &error, ArchSpec &platform_arch) const
const StructuredData::DictionarySP GetStructuredData()
A pair of an option list with a 'raw' string as a suffix.
Definition: Args.h:315
bool HasArgs() const
Returns true if there are any arguments before the raw suffix.
Definition: Args.h:326
Args & GetArgs()
Returns the list of arguments.
Definition: Args.h:331
const std::string & GetRawPart() const
Returns the raw suffix part of the parsed string.
Definition: Args.h:364
A command line option parsing protocol class.
Definition: Options.h:58
void NotifyOptionParsingStarting(ExecutionContext *execution_context)
Definition: Options.cpp:33
std::vector< Option > m_getopt_table
Definition: Options.h:198
lldb::PlatformSP GetSelectedPlatform()
Select the active platform.
Definition: Platform.h:1060
void SetSelectedPlatform(const lldb::PlatformSP &platform_sp)
Definition: Platform.h:1068
static ArchSpec GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple)
Augments the triple either with information from platform or the host system (if platform is null).
Definition: Platform.cpp:261
static lldb::PlatformSP GetHostPlatform()
Get the native host platform plug-in.
Definition: Platform.cpp:134
static llvm::StringRef GetPlatformPluginDescriptionAtIndex(uint32_t idx)
static llvm::StringRef GetPlatformPluginNameAtIndex(uint32_t idx)
void SetProcessPluginName(llvm::StringRef plugin)
Definition: Process.h:160
void SetGroupID(uint32_t gid)
Definition: ProcessInfo.h:59
const char * GetName() const
Definition: ProcessInfo.cpp:45
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
void SetScriptedMetadata(lldb::ScriptedMetadataSP metadata_sp)
Definition: ProcessInfo.h:96
void SetArguments(const Args &args, bool first_arg_is_executable)
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:42
void SetUserID(uint32_t uid)
Definition: ProcessInfo.h:57
ArchSpec & GetArchitecture()
Definition: ProcessInfo.h:61
void SetNameMatchType(NameMatch name_match_type)
Definition: ProcessInfo.h:306
ProcessInstanceInfo & GetProcessInfo()
Definition: ProcessInfo.h:296
void SetEffectiveGroupID(uint32_t gid)
Definition: ProcessInfo.h:170
static void DumpTableHeader(Stream &s, bool show_args, bool verbose)
void Dump(Stream &s, UserIDResolver &resolver) const
void DumpAsTableRow(Stream &s, UserIDResolver &resolver, bool show_args, bool verbose) const
void SetParentProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:174
void SetEffectiveUserID(uint32_t uid)
Definition: ProcessInfo.h:168
void SetProcessPluginName(llvm::StringRef plugin)
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
void Format(const char *format, Args &&... args)
Definition: Stream.h:353
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
Definition: Target.cpp:4780
bool GetRunArguments(Args &args) const
Definition: Target.cpp:4367
Module * GetExecutableModulePointer()
Definition: Target.cpp:1436
lldb::PlatformSP GetPlatform()
Definition: Target.h:1433
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:111
#define UINT64_MAX
Definition: lldb-defines.h:23
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:112
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
#define UINT32_MAX
Definition: lldb-defines.h:19
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:89
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::vector< OptionArgElement > OptionElementVector
Definition: Options.h:43
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
std::vector< ProcessInstanceInfo > ProcessInstanceInfoList
Definition: Host.h:32
Definition: SBAddress.h:15
@ eRemoteDiskDirectoryCompletion
@ eDiskFileCompletion
@ eRemoteDiskFileCompletion
std::shared_ptr< lldb_private::ScriptedMetadata > ScriptedMetadataSP
Definition: lldb-forward.h:399
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:325
std::shared_ptr< lldb_private::Platform > PlatformSP
Definition: lldb-forward.h:380
StateType
Process and Thread States.
@ eStateStopped
Process or thread is stopped and can be examined.
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
std::shared_ptr< lldb_private::Debugger > DebuggerSP
Definition: lldb-forward.h:331
std::shared_ptr< lldb_private::Event > EventSP
Definition: lldb-forward.h:337
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
uint64_t pid_t
Definition: lldb-types.h:81
@ eArgTypeFilename
@ eArgTypeRemotePath
@ eArgTypeRemoteFilename
@ eArgTypeConnectURL
@ eArgTypePlatform
@ eArgTypeUnsignedInteger
uint64_t user_id_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
Used to build individual command argument lists.
Definition: CommandObject.h:93