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
PullValuesOptionValueMap120 std::vector<OptionValue> PullValues(const OptionName& name) {
121 auto pair = values.equal_range(name);
122 if (pair.first != pair.second) {
123 std::vector<OptionValue> res;
124 for (auto it = pair.first; it != pair.second; ++it) {
125 res.emplace_back(it->second);
126 }
127 values.erase(name);
128 return res;
129 }
130 return {};
131 }
132 };
133
134 bool ConvertArgsToOptions(const std::vector<std::string>& args,
135 const OptionFormatMap& option_formats, const std::string& help_msg,
136 OptionValueMap* options,
137 std::vector<std::pair<OptionName, OptionValue>>* ordered_options,
138 std::vector<std::string>* non_option_args);
139
GetCommonOptionFormatMap()140 inline const OptionFormatMap& GetCommonOptionFormatMap() {
141 static const OptionFormatMap option_formats = {
142 {"-h", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
143 {"--help", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
144 {"--log", {OptionValueType::STRING, OptionType::SINGLE, AppRunnerType::ALLOWED}},
145 {"--log-to-android-buffer",
146 {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
147 {"--version", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
148 };
149 return option_formats;
150 }
151
152 class Command {
153 public:
Command(const std::string & name,const std::string & short_help_string,const std::string & long_help_string)154 Command(const std::string& name, const std::string& short_help_string,
155 const std::string& long_help_string)
156 : name_(name), short_help_string_(short_help_string), long_help_string_(long_help_string) {}
157
~Command()158 virtual ~Command() {}
159
Name()160 const std::string& Name() const { return name_; }
161
ShortHelpString()162 const std::string& ShortHelpString() const { return short_help_string_; }
163
LongHelpString()164 const std::string LongHelpString() const { return long_help_string_; }
165
Run(const std::vector<std::string> &)166 virtual bool Run(const std::vector<std::string>&) { return false; }
Run(const std::vector<std::string> & args,int * exit_code)167 virtual void Run(const std::vector<std::string>& args, int* exit_code) {
168 *exit_code = Run(args) ? 0 : 1;
169 }
170
171 bool PreprocessOptions(const std::vector<std::string>& args,
172 const OptionFormatMap& option_formats, OptionValueMap* options,
173 std::vector<std::pair<OptionName, OptionValue>>* ordered_options,
174 std::vector<std::string>* non_option_args = nullptr);
175
176 template <typename T>
177 bool GetUintOption(const std::vector<std::string>& args, size_t* pi, T* value, uint64_t min = 0,
178 uint64_t max = std::numeric_limits<T>::max(), bool allow_suffixes = false) {
179 if (!NextArgumentOrError(args, pi)) {
180 return false;
181 }
182 uint64_t tmp_value;
183 if (!android::base::ParseUint(args[*pi], &tmp_value, max, allow_suffixes) || tmp_value < min) {
184 LOG(ERROR) << "Invalid argument for option " << args[*pi - 1] << ": " << args[*pi];
185 return false;
186 }
187 *value = static_cast<T>(tmp_value);
188 return true;
189 }
190
191 bool GetDoubleOption(const std::vector<std::string>& args, size_t* pi, double* value,
192 double min = 0, double max = std::numeric_limits<double>::max());
193
194 protected:
195 bool NextArgumentOrError(const std::vector<std::string>& args, size_t* pi);
196 void ReportUnknownOption(const std::vector<std::string>& args, size_t i);
197
198 private:
199 const std::string name_;
200 const std::string short_help_string_;
201 const std::string long_help_string_;
202
203 DISALLOW_COPY_AND_ASSIGN(Command);
204 };
205
206 void RegisterCommand(const std::string& cmd_name,
207 const std::function<std::unique_ptr<Command>(void)>& callback);
208 void UnRegisterCommand(const std::string& cmd_name);
209 std::unique_ptr<Command> CreateCommandInstance(const std::string& cmd_name);
210 const std::vector<std::string> GetAllCommandNames();
211 bool RunSimpleperfCmd(int argc, char** argv);
212
213 extern bool log_to_android_buffer;
214
215 } // namespace simpleperf
216
217 #endif // SIMPLE_PERF_COMMAND_H_
218