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 #ifndef PROCESS_DATA_PLUGIN_H
17 #define PROCESS_DATA_PLUGIN_H
18 
19 #include <algorithm>
20 #include <dirent.h>
21 #include <fcntl.h>
22 #include <inttypes.h>
23 #include <iomanip>
24 #include <string>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27 #include <unistd.h>
28 #include <unordered_map>
29 #include <utility>
30 
31 #include "logging.h"
32 #include "process_plugin_config.pb.h"
33 #include "process_plugin_result.pb.h"
34 #include "plugin_module_api.h"
35 
36 enum ErrorType {
37     RET_NULL_ADDR,
38     RET_IVALID_PID,
39     RET_TGID_VALUE_NULL,
40     RET_FAIL = -1,
41     RET_SUCC = 0,
42 };
43 
44 class ProcessDataPlugin {
45 public:
46     ProcessDataPlugin();
47     ~ProcessDataPlugin();
48     int Start(const uint8_t* configData, uint32_t configSize);
49     int Report(uint8_t* data, uint32_t dataSize);
50     int ReportOptimize(RandomWriteCtx* randomWrite);
51     int Stop();
52 
53     int64_t GetUserHz();
54 
55     // for UT
SetPath(std::string path)56     void SetPath(std::string path)
57     {
58         path_ = path;
59     };
60 
61 private:
62     template <typename T> bool WriteProcesseList(T& processData);
63 
64     DIR* OpenDestDir(const char* dirPath);
65     int32_t GetValidPid(DIR* dirp);
66     std::vector<int> OpenProcPidFiles(int32_t pid);
67     int32_t ReadProcPidFile(int32_t pid, const char* pFileName);
68 
69     template <typename T> void WriteProcessInfo(T& processData, int32_t pid);
70 
71     template <typename T> void WriteProcess(T& processinfo, const char* pFile, uint32_t fileLen, int32_t pid);
72 
73     template <typename T> void SetProcessInfo(T& processinfo, int key, const char* word);
74 
75     bool BufnCmp(const char* src, int srcLen, const char* key, int keyLen);
76     bool addPidBySort(int32_t pid);
77     int GetProcStatusId(const char* src, int srcLen);
78 
79     template <typename T> bool WriteCpuUsageData(int pid, T& cpuInfo);
80 
81     bool ReadCpuUsage(int pid, uint64_t& cpuTime);
82     uint32_t GetCpuUsageData(const std::string& line, uint64_t& cpuTime);
83     bool ReadBootTime(int pid, uint64_t& bootTime);
84     uint32_t GetBootData(const std::string& line, uint64_t& bootTime);
85 
86     template <typename T> bool WriteThreadData(int pid, T& cpuInfo);
87 
88     bool FindFirstNum(char** p);
89     bool GetValidValue(char* p, uint64_t& num);
90     bool FindFirstSpace(char** p);
91 
92     template <typename T> bool GetDiskioData(std::string& line, T& diskioInfo);
93 
94     template <typename T> bool WriteDiskioData(int pid, T& processinfo);
95 
96     template <typename T> bool WritePssData(int pid, T& processinfo);
97 
98     ProcessConfig protoConfig_;
99     std::unique_ptr<uint8_t[]> buffer_;
100     std::vector<int32_t> pids_;
101     std::string path_;
102     int32_t err_;
103     std::unordered_map<int, uint64_t> cpuTime_ = {};
104     std::unordered_map<int, uint64_t> bootTime_ = {};
105 };
106 
107 #endif
108