1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef SIMPLE_PERF_COMMAND_H_
18 #define SIMPLE_PERF_COMMAND_H_
19
20 #include <functional>
21 #include <limits>
22 #include <map>
23 #include <memory>
24 #include <optional>
25 #include <string>
26 #include <unordered_map>
27 #include <vector>
28
29 #include <android-base/logging.h>
30 #include <android-base/macros.h>
31 #include <android-base/parseint.h>
32
33 namespace simpleperf {
34
35 using OptionName = std::string;
36
37 enum class OptionType {
38 SINGLE, // this option has a single value (use the last one in the arg list)
39 MULTIPLE, // this option can have multiple values (keep all values appeared in the arg list)
40 ORDERED, // keep the order of this option in the arg list
41 };
42
43 enum class OptionValueType {
44 NONE, // No value is needed
45 STRING,
46 OPT_STRING, // optional string
47 UINT,
48 DOUBLE,
49 };
50
51 // Whether an option is allowed to pass through simpleperf_app_runner.
52 enum class AppRunnerType {
53 NOT_ALLOWED,
54 ALLOWED,
55 CHECK_FD,
56 CHECK_PATH,
57 };
58
59 struct OptionFormat {
60 OptionValueType value_type;
61 OptionType type;
62 AppRunnerType app_runner_type = AppRunnerType::NOT_ALLOWED;
63 };
64
65 using OptionFormatMap = std::unordered_map<OptionName, OptionFormat>;
66
67 union OptionValue {
68 const std::string* str_value;
69 uint64_t uint_value;
70 double double_value;
71 };
72
73 struct OptionValueMap {
74 std::multimap<OptionName, OptionValue> values;
75
PullBoolValueOptionValueMap76 bool PullBoolValue(const OptionName& name) { return PullValue(name).has_value(); }
77
78 template <typename T>
79 bool PullUintValue(const OptionName& name, T* value, uint64_t min = 0,
80 uint64_t max = std::numeric_limits<T>::max()) {
81 if (auto option_value = PullValue(name); option_value) {
82 if (option_value->uint_value < min || option_value->uint_value > max) {
83 LOG(ERROR) << "invalid " << name << ": " << option_value->uint_value;
84 return false;
85 }
86 *value = option_value->uint_value;
87 }
88 return true;
89 }
90
91 bool PullDoubleValue(const OptionName& name, double* value,
92 double min = std::numeric_limits<double>::lowest(),
93 double max = std::numeric_limits<double>::max()) {
94 if (auto option_value = PullValue(name); option_value) {
95 if (option_value->double_value < min || option_value->double_value > max) {
96 LOG(ERROR) << "invalid " << name << ": " << option_value->double_value;
97 return false;
98 }
99 *value = option_value->double_value;
100 }
101 return true;
102 }
103
PullStringValueOptionValueMap104 void PullStringValue(const OptionName& name, std::string* value) {
105 if (auto option_value = PullValue(name); option_value) {
106 CHECK(option_value->str_value != nullptr);
107 *value = *option_value->str_value;
108 }
109 }
110
PullValueOptionValueMap111 std::optional<OptionValue> PullValue(const OptionName& name) {
112 std::optional<OptionValue> res;
113 if (auto it = values.find(name); it != values.end()) {
114 res.emplace(it->second);
115 values.erase(it);
116 }
117 return res;
118 }
119
PullStringValuesOptionValueMap120 std::vector<std::string> PullStringValues(const OptionName& name) {
121 std::vector<std::string> res;
122 for (const auto& value : PullValues(name)) {
123 res.emplace_back(*value.str_value);
124 }
125 return res;
126 }
127
PullValuesOptionValueMap128 std::vector<OptionValue> PullValues(const OptionName& name) {
129 auto pair = values.equal_range(name);
130 if (pair.first != pair.second) {
131 std::vector<OptionValue> res;
132 for (auto it = pair.first; it != pair.second; ++it) {
133 res.emplace_back(it->second);
134 }
135 values.erase(name);
136 return res;
137 }
138 return {};
139 }
140 };
141
142 bool ConvertArgsToOptions(const std::vector<std::string>& args,
143 const OptionFormatMap& option_formats, const std::string& help_msg,
144 OptionValueMap* options,
145 std::vector<std::pair<OptionName, OptionValue>>* ordered_options,
146 std::vector<std::string>* non_option_args);
147
GetCommonOptionFormatMap()148 inline const OptionFormatMap& GetCommonOptionFormatMap() {
149 static const OptionFormatMap option_formats = {
150 {"-h", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
151 {"--help", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
152 {"--log", {OptionValueType::STRING, OptionType::SINGLE, AppRunnerType::ALLOWED}},
153 {"--log-to-android-buffer",
154 {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
155 {"--version", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
156 };
157 return option_formats;
158 }
159
160 class Command {
161 public:
Command(const std::string & name,const std::string & short_help_string,const std::string & long_help_string)162 Command(const std::string& name, const std::string& short_help_string,
163 const std::string& long_help_string)
164 : name_(name), short_help_string_(short_help_string), long_help_string_(long_help_string) {}
165
~Command()166 virtual ~Command() {}
167
Name()168 const std::string& Name() const { return name_; }
169
ShortHelpString()170 const std::string& ShortHelpString() const { return short_help_string_; }
171
LongHelpString()172 virtual std::string LongHelpString() const { return long_help_string_; }
173
Run(const std::vector<std::string> &)174 virtual bool Run(const std::vector<std::string>&) { return false; }
Run(const std::vector<std::string> & args,int * exit_code)175 virtual void Run(const std::vector<std::string>& args, int* exit_code) {
176 *exit_code = Run(args) ? 0 : 1;
177 }
178
179 bool PreprocessOptions(const std::vector<std::string>& args,
180 const OptionFormatMap& option_formats, OptionValueMap* options,
181 std::vector<std::pair<OptionName, OptionValue>>* ordered_options,
182 std::vector<std::string>* non_option_args = nullptr);
183
184 template <typename T>
185 bool GetUintOption(const std::vector<std::string>& args, size_t* pi, T* value, uint64_t min = 0,
186 uint64_t max = std::numeric_limits<T>::max(), bool allow_suffixes = false) {
187 if (!NextArgumentOrError(args, pi)) {
188 return false;
189 }
190 uint64_t tmp_value;
191 if (!android::base::ParseUint(args[*pi], &tmp_value, max, allow_suffixes) || tmp_value < min) {
192 LOG(ERROR) << "Invalid argument for option " << args[*pi - 1] << ": " << args[*pi];
193 return false;
194 }
195 *value = static_cast<T>(tmp_value);
196 return true;
197 }
198
199 bool GetDoubleOption(const std::vector<std::string>& args, size_t* pi, double* value,
200 double min = 0, double max = std::numeric_limits<double>::max());
201
202 protected:
203 bool NextArgumentOrError(const std::vector<std::string>& args, size_t* pi);
204 void ReportUnknownOption(const std::vector<std::string>& args, size_t i);
205
206 const std::string name_;
207 const std::string short_help_string_;
208 const std::string long_help_string_;
209
210 DISALLOW_COPY_AND_ASSIGN(Command);
211 };
212
213 void RegisterCommand(const std::string& cmd_name,
214 const std::function<std::unique_ptr<Command>(void)>& callback);
215 void RegisterBootRecordCommand();
216 void RegisterDumpRecordCommand();
217 void RegisterHelpCommand();
218 void RegisterInjectCommand();
219 void RegisterListCommand();
220 void RegisterKmemCommand();
221 void RegisterMergeCommand();
222 void RegisterRecordCommand();
223 void RegisterReportCommand();
224 void RegisterReportSampleCommand();
225 void RegisterStatCommand();
226 void RegisterDebugUnwindCommand();
227 void RegisterTraceSchedCommand();
228 void RegisterAPICommands();
229 void RegisterMonitorCommand();
230 void RegisterAllCommands();
231 void UnRegisterCommand(const std::string& cmd_name);
232
233 std::unique_ptr<Command> CreateCommandInstance(const std::string& cmd_name);
234 const std::vector<std::string> GetAllCommandNames();
235 bool RunSimpleperfCmd(int argc, char** argv);
236
237 extern bool log_to_android_buffer;
238
239 } // namespace simpleperf
240
241 #endif // SIMPLE_PERF_COMMAND_H_
242