1 /*
2  * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "parse_plugin_config.h"
17 
18 #include "cpu_plugin_config_standard.pb.h"
19 #include "gpu_plugin_config_standard.pb.h"
20 #include "diskio_plugin_config_standard.pb.h"
21 #include "hidump_plugin_config_standard.pb.h"
22 #include "hiebpf_plugin_config_standard.pb.h"
23 #include "hilog_plugin_config_standard.pb.h"
24 #include "hiperf_plugin_config_standard.pb.h"
25 #include "hisysevent_plugin_config_standard.pb.h"
26 #include "memory_plugin_common_standard.pb.h"
27 #include "memory_plugin_config_standard.pb.h"
28 #include "native_hook_config_standard.pb.h"
29 #include "network_plugin_config_standard.pb.h"
30 #include "process_plugin_config_standard.pb.h"
31 #include "trace_plugin_config_standard.pb.h"
32 #include "xpower_plugin_config_standard.pb.h"
33 #include "ffrt_profiler_config_standard.pb.h"
34 #include "network_profiler_config_standard.pb.h"
35 
36 namespace {
37 constexpr int REMAINDER = 2;
38 }
39 
ParsePluginConfig()40 ParsePluginConfig::ParsePluginConfig()
41 {
42     parser_.AllowUnknownField(true);
43 }
44 
GetInstance()45 ParsePluginConfig& ParsePluginConfig::GetInstance()
46 {
47     static ParsePluginConfig parsePluginConfig;
48     return parsePluginConfig;
49 }
50 
GetPluginsConfig(std::string& content)51 std::string ParsePluginConfig::GetPluginsConfig(std::string& content)
52 {
53     std::string pluginConfig = "";
54     std::string pluginName = "";
55     size_t beginPos = 0;
56     size_t endPos = 0;
57     for (int i = 0; content.size() > 0; i++) {
58         // 先获取pluginName，再获取configData
59         std::string destStr = (i % REMAINDER) ? "config_data" : "plugin_name";
60         beginPos = content.find(destStr);
61         if (beginPos == std::string::npos) {
62             break;
63         }
64         pluginConfig += content.substr(0, beginPos);
65         content = content.substr(beginPos + destStr.size(), content.size());
66         destStr = (i % REMAINDER) ? "{" : "\"";
67         beginPos = content.find(destStr);
68         if (beginPos == std::string::npos) {
69             break;
70         }
71         content = content.substr(beginPos + 1, content.size());
72         destStr = (i % REMAINDER) ? "}" : "\"";
73         endPos = content.find(destStr);
74         if (endPos == std::string::npos) {
75             break;
76         }
77         std::string contentStr = content.substr(0, endPos);
78         if (i % REMAINDER == 0) { // set plugin-name
79             pluginName = contentStr;
80 
81             if (pluginName == "") {
82                 return "";
83             }
84             pluginConfig += "name: \"" + pluginName + "\"";
85         } else { // save config_data
86             pluginConfigMap.insert({pluginName, contentStr});
87             pluginConfig += "config_data: \"\"";
88         }
89 
90         content = content.substr(endPos + 1, content.size());
91     }
92 
93     pluginConfig += content;
94     return pluginConfig;
95 }
96 
SetSerializePluginsConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)97 bool ParsePluginConfig::SetSerializePluginsConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
98 {
99     bool ret = false;
100     if (pluginConfigMap.count(pluginName) == 0) {
101         printf("unknown plugin: %s\n", pluginName.c_str());
102         return ret;
103     }
104 
105     // 将pluginConfigMap中保存的configData序列化后写入pluginConfig
106     if (pluginName == "cpu-plugin") {
107         ret = SetSerializeCpuConfig(pluginName, pluginConfig);
108     } else if (pluginName == "diskio-plugin") {
109         ret = SetSerializeDiskioConfig(pluginName, pluginConfig);
110     } else if (pluginName == "ftrace-plugin") {
111         ret = SetSerializeFtraceConfig(pluginName, pluginConfig);
112     } else if (pluginName == "hidump-plugin") {
113         ret = SetSerializeHidumpConfig(pluginName, pluginConfig);
114     } else if (pluginName == "hiebpf-plugin") {
115         ret = SetSerializeHiebpfConfig(pluginName, pluginConfig);
116     } else if (pluginName == "hilog-plugin") {
117         ret = SetSerializeHilogConfig(pluginName, pluginConfig);
118     } else if (pluginName == "memory-plugin") {
119         ret = SetSerializeMemoryConfig(pluginName, pluginConfig);
120     } else if (pluginName == "nativehook") {
121         ret = SetSerializeHookConfig(pluginName, pluginConfig);
122     } else if (pluginName == "network-plugin") {
123         ret = SetSerializeNetworkConfig(pluginName, pluginConfig);
124     } else if (pluginName == "process-plugin") {
125         ret = SetSerializeProcessConfig(pluginName, pluginConfig);
126     } else if (pluginName == "hiperf-plugin") {
127         ret = SetSerializeHiperfConfig(pluginName, pluginConfig);
128     } else if (pluginName == "hisysevent-plugin") {
129         ret = SetSerializeHisyseventConfig(pluginName, pluginConfig);
130     } else if (pluginName == "xpower-plugin") {
131         ret = SetSerializeXpowerConfig(pluginName, pluginConfig);
132     } else if (pluginName == "gpu-plugin") {
133         ret = SetSerializeGpuConfig(pluginName, pluginConfig);
134     } else if (pluginName == "ffrt-profiler") {
135         ret = SetSerializeFfrtProfilerConfig(pluginName, pluginConfig);
136     } else if (pluginName == "network-profiler") {
137         ret = SetSerializeNetworkProfilerConfig(pluginName, pluginConfig);
138     } else {
139         printf("unsupport plugin: %s\n", pluginName.c_str());
140     }
141 
142     return ret;
143 }
144 
SetSerializeCpuConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)145 bool ParsePluginConfig::SetSerializeCpuConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
146 {
147     std::string configData = pluginConfigMap[pluginName];
148     auto cpuConfigNolite = std::make_unique<ForStandard::CpuConfig>();
149     if (!parser_.ParseFromString(configData, cpuConfigNolite.get())) {
150         printf("cpu parse failed!\n");
151         return false;
152     }
153 
154     std::vector<uint8_t> configDataVec(cpuConfigNolite->ByteSizeLong());
155     if (cpuConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
156         printf("cpu serialize failed!\n");
157         return false;
158     }
159     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
160     return true;
161 }
162 
SetSerializeDiskioConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)163 bool ParsePluginConfig::SetSerializeDiskioConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
164 {
165     std::string configData = pluginConfigMap[pluginName];
166     auto diskioConfigNolite = std::make_unique<ForStandard::DiskioConfig>();
167     if (!parser_.ParseFromString(configData, diskioConfigNolite.get())) {
168         printf("diskio parse failed!\n");
169         return false;
170     }
171 
172     std::vector<uint8_t> configDataVec(diskioConfigNolite->ByteSizeLong());
173     if (diskioConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
174         printf("diskio serialize failed!\n");
175         return false;
176     }
177     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
178     return true;
179 }
180 
SetSerializeFtraceConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)181 bool ParsePluginConfig::SetSerializeFtraceConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
182 {
183     std::string configData = pluginConfigMap[pluginName];
184     auto ftraceConfigNolite = std::make_unique<ForStandard::TracePluginConfig>();
185     if (!parser_.ParseFromString(configData, ftraceConfigNolite.get())) {
186         printf("ftrace parse failed!\n");
187         return false;
188     }
189 
190     std::vector<uint8_t> configNoLiteDataVec(ftraceConfigNolite->ByteSizeLong());
191     if (ftraceConfigNolite->SerializeToArray(configNoLiteDataVec.data(), configNoLiteDataVec.size()) <= 0) {
192         printf("ftrace serialize failed!\n");
193         return false;
194     }
195 
196     pluginConfig.set_config_data(static_cast<const void*>(configNoLiteDataVec.data()), configNoLiteDataVec.size());
197     return true;
198 }
199 
SetSerializeHidumpConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)200 bool ParsePluginConfig::SetSerializeHidumpConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
201 {
202     std::string configData = pluginConfigMap[pluginName];
203     auto hidumpConfigNolite = std::make_unique<ForStandard::HidumpConfig>();
204     if (!parser_.ParseFromString(configData, hidumpConfigNolite.get())) {
205         printf("hidump parse failed!\n");
206         return false;
207     }
208 
209     std::vector<uint8_t> configDataVec(hidumpConfigNolite->ByteSizeLong());
210     if (hidumpConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
211         printf("hidump serialize failed!\n");
212         return false;
213     }
214     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
215     return true;
216 }
217 
SetSerializeHiebpfConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)218 bool ParsePluginConfig::SetSerializeHiebpfConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
219 {
220     auto iter = pluginConfigMap.find(pluginName);
221     if (iter == pluginConfigMap.end()) {
222         printf("find %s failed\n", pluginName.c_str());
223         return false;
224     }
225     auto hiebpfConfigNolite = std::make_unique<ForStandard::HiebpfConfig>();
226     if (hiebpfConfigNolite == nullptr) {
227         printf("hiebpfConfigNolite is nullptr\n");
228         return false;
229     }
230     if (!parser_.ParseFromString(iter->second, hiebpfConfigNolite.get())) {
231         printf("hiebpf config parse failed!\n");
232         return false;
233     }
234     std::vector<uint8_t> config(hiebpfConfigNolite->ByteSizeLong());
235     if (hiebpfConfigNolite->SerializeToArray(config.data(), config.size()) <= 0) {
236         printf("hiebpf serialize failed!\n");
237         return false;
238     }
239     pluginConfig.set_config_data(static_cast<const void*>(config.data()), config.size());
240     return true;
241 }
242 
SetSerializeHilogConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)243 bool ParsePluginConfig::SetSerializeHilogConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
244 {
245     std::string configData = pluginConfigMap[pluginName];
246     auto hilogConfigNolite = std::make_unique<ForStandard::HilogConfig>();
247     if (!parser_.ParseFromString(configData, hilogConfigNolite.get())) {
248         printf("hilog parse failed!\n");
249         return false;
250     }
251 
252     std::vector<uint8_t> configDataVec(hilogConfigNolite->ByteSizeLong());
253     if (hilogConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
254         printf("hilog serialize failed!\n");
255         return false;
256     }
257     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
258     return true;
259 }
260 
SetSerializeMemoryConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)261 bool ParsePluginConfig::SetSerializeMemoryConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
262 {
263     std::string configData = pluginConfigMap[pluginName];
264     auto memoryConfigNolite = std::make_unique<ForStandard::MemoryConfig>();
265     if (!parser_.ParseFromString(configData, memoryConfigNolite.get())) {
266         printf("memory parse failed!\n");
267         return false;
268     }
269 
270     std::vector<uint8_t> configDataVec(memoryConfigNolite->ByteSizeLong());
271     if (memoryConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
272         printf("memory serialize failed!\n");
273         return false;
274     }
275     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
276     return true;
277 }
278 
SetSerializeHookConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)279 bool ParsePluginConfig::SetSerializeHookConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
280 {
281     std::string configData = pluginConfigMap[pluginName];
282     auto hookConfigNolite = std::make_unique<ForStandard::NativeHookConfig>();
283     if (!parser_.ParseFromString(configData, hookConfigNolite.get())) {
284         printf("nativedaemon parse failed!\n");
285         return false;
286     }
287 
288     std::vector<uint8_t> configDataVec(hookConfigNolite->ByteSizeLong());
289     if (hookConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
290         printf("nativedaemon serialize failed!\n");
291         return false;
292     }
293     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
294     return true;
295 }
296 
SetSerializeNetworkConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)297 bool ParsePluginConfig::SetSerializeNetworkConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
298 {
299     std::string configData = pluginConfigMap[pluginName];
300     auto networkConfigNolite = std::make_unique<ForStandard::NetworkConfig>();
301     if (!parser_.ParseFromString(configData, networkConfigNolite.get())) {
302         printf("network parse failed!\n");
303         return false;
304     }
305 
306     std::vector<uint8_t> configDataVec(networkConfigNolite->ByteSizeLong());
307     if (networkConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
308         printf("network serialize failed!\n");
309         return false;
310     }
311     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
312     return true;
313 }
314 
SetSerializeProcessConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)315 bool ParsePluginConfig::SetSerializeProcessConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
316 {
317     std::string configData = pluginConfigMap[pluginName];
318     auto processConfigNolite = std::make_unique<ForStandard::ProcessConfig>();
319     if (!parser_.ParseFromString(configData, processConfigNolite.get())) {
320         printf("process parse failed!\n");
321         return false;
322     }
323 
324     std::vector<uint8_t> configDataVec(processConfigNolite->ByteSizeLong());
325     if (processConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
326         printf("process serialize failed!\n");
327         return false;
328     }
329     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
330     return true;
331 }
332 
SetSerializeHiperfConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)333 bool ParsePluginConfig::SetSerializeHiperfConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
334 {
335     std::string configData = pluginConfigMap[pluginName];
336     auto hiperfConfigNolite = std::make_unique<ForStandard::HiperfPluginConfig>();
337     if (!parser_.ParseFromString(configData, hiperfConfigNolite.get())) {
338         printf("hiperf config parse failed!\n");
339         return false;
340     }
341 
342     std::vector<uint8_t> configDataVec(hiperfConfigNolite->ByteSizeLong());
343     if (hiperfConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
344         printf("hiperf config failed!\n");
345         return false;
346     }
347     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
348     return true;
349 }
350 
SetSerializeHisyseventConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)351 bool ParsePluginConfig::SetSerializeHisyseventConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
352 {
353     std::string configData = pluginConfigMap[pluginName];
354     auto hisyseventConfigNolite = std::make_unique<ForStandard::HisyseventConfig>();
355     if (!parser_.ParseFromString(configData, hisyseventConfigNolite.get())) {
356         printf("NODE hisysevent parse failed!\n");
357         return false;
358     }
359 
360     std::vector<uint8_t> configDataVec(hisyseventConfigNolite->ByteSizeLong());
361     if (hisyseventConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
362         printf("NODE hisysevent serialize failed!\n");
363         return false;
364     }
365     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
366     return true;
367 }
368 
SetSerializeXpowerConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)369 bool ParsePluginConfig::SetSerializeXpowerConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
370 {
371     std::string configData = pluginConfigMap[pluginName];
372     auto xpowerConfigNolite = std::make_unique<ForStandard::XpowerConfig>();
373     if (!parser_.ParseFromString(configData, xpowerConfigNolite.get())) {
374         return false;
375     }
376 
377     std::vector<uint8_t> configDataVec(xpowerConfigNolite->ByteSizeLong());
378     if (xpowerConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
379         return false;
380     }
381     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
382     return true;
383 }
384 
SetSerializeGpuConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)385 bool ParsePluginConfig::SetSerializeGpuConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)
386 {
387     std::string configData = pluginConfigMap[pluginName];
388     auto gpuConfigNolite = std::make_unique<ForStandard::GpuConfig>();
389     if (!parser_.ParseFromString(configData, gpuConfigNolite.get())) {
390         return false;
391     }
392 
393     std::vector<uint8_t> configDataVec(gpuConfigNolite->ByteSizeLong());
394     if (gpuConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
395         return false;
396     }
397     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
398     return true;
399 }
400 
SetSerializeFfrtProfilerConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)401 bool ParsePluginConfig::SetSerializeFfrtProfilerConfig(const std::string& pluginName,
402     ProfilerPluginConfig& pluginConfig)
403 {
404     std::string configData = pluginConfigMap[pluginName];
405     auto ffrtConfigNolite = std::make_unique<ForStandard::FfrtProfilerConfig>();
406     if (!parser_.ParseFromString(configData, ffrtConfigNolite.get())) {
407         return false;
408     }
409 
410     std::vector<uint8_t> configDataVec(ffrtConfigNolite->ByteSizeLong());
411     if (ffrtConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
412         return false;
413     }
414     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
415     return true;
416 }
417 
SetSerializeNetworkProfilerConfig(const std::string& pluginName, ProfilerPluginConfig& pluginConfig)418 bool ParsePluginConfig::SetSerializeNetworkProfilerConfig(const std::string& pluginName,
419     ProfilerPluginConfig& pluginConfig)
420 {
421     std::string configData = pluginConfigMap[pluginName];
422     auto networkConfigNolite = std::make_unique<ForStandard::NetworkProfilerConfig>();
423     if (!parser_.ParseFromString(configData, networkConfigNolite.get())) {
424         return false;
425     }
426 
427     std::vector<uint8_t> configDataVec(networkConfigNolite->ByteSizeLong());
428     if (networkConfigNolite->SerializeToArray(configDataVec.data(), configDataVec.size()) <= 0) {
429         return false;
430     }
431     pluginConfig.set_config_data(static_cast<const void*>(configDataVec.data()), configDataVec.size());
432     return true;
433 }
434