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