1
2 /*
3 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
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 #include <ctime>
18 #include <net/if.h>
19 #include <thread>
20 #include <vector>
21
22 #include <gtest/gtest.h>
23 #include <sys/resource.h>
24 #include <unistd.h>
25
26 #ifdef GTEST_API_
27 #define private public
28 #define protected public
29 #endif
30
31 #include "bpf_loader.h"
32 #include "bpf_mapper.h"
33 #include "bpf_path.h"
34 #include "bpf_stats.h"
35
36 namespace OHOS {
37 namespace NetManagerStandard {
38 static constexpr uint32_t TEST_UID1 = 10010;
39 static constexpr uint32_t TEST_UID2 = 10100;
40 static constexpr uint32_t TEST_UID_IF1 = 11001;
41 static constexpr uint32_t TEST_UID_IF2 = 11002;
42 static constexpr uint32_t TEST_BYTES0 = 11;
43 static constexpr const char *TEST_IFACE_NAME_WLAN0 = "wlan0";
44 static constexpr const char *TEST_IFACE_NAME_LO = "lo";
45 static constexpr const char *TEST_IFACE_NAME_DUMMY0 = "dummy0";
46 static constexpr const char *BFP_NAME_NETSYS_PATH = "/system/etc/bpf/netsys.o";
47 static constexpr const char *TEST_BFP_NAME_NETSYS_PATH = "/data/netsys.o";
48
49 using namespace testing::ext;
50
51 class NetsysBpfStatsTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54
55 static void TearDownTestCase();
56
57 void SetUp();
58
59 void TearDown();
60
61 protected:
62 NetsysBpfStatsTest() = default;
63 };
SetUpTestCase()64 void NetsysBpfStatsTest::SetUpTestCase() {}
65
TearDownTestCase()66 void NetsysBpfStatsTest::TearDownTestCase() {}
67
SetUp()68 void NetsysBpfStatsTest::SetUp() {}
69
TearDown()70 void NetsysBpfStatsTest::TearDown() {}
71
72 HWTEST_F(NetsysBpfStatsTest, GetTotalStats, TestSize.Level1)
73 {
74 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
75 uint64_t stats = 0;
76 bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_BYTES);
77 EXPECT_GE(stats, 0);
78 bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_PACKETS);
79 EXPECT_GE(stats, 0);
80 bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_BYTES);
81 EXPECT_GE(stats, 0);
82 bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_PACKETS);
83 EXPECT_GE(stats, 0);
84 }
85
86 HWTEST_F(NetsysBpfStatsTest, GetUidStats, TestSize.Level1)
87 {
88 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
89 uint64_t stats = 0;
90
91 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID1);
92 EXPECT_GE(stats, 0);
93 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID1);
94 EXPECT_GE(stats, 0);
95 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID1);
96 EXPECT_GE(stats, 0);
97 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID1);
98 EXPECT_GE(stats, 0);
99
100 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID2);
101 EXPECT_GE(stats, 0);
102 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID2);
103 EXPECT_GE(stats, 0);
104 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID2);
105 EXPECT_GE(stats, 0);
106 bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID2);
107 EXPECT_GE(stats, 0);
108 }
109
110 HWTEST_F(NetsysBpfStatsTest, GetIfaceStats, TestSize.Level1)
111 {
112 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
113 uint64_t stats = 0;
114 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_WLAN0);
115 EXPECT_GE(stats, 0);
116 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_WLAN0);
117 EXPECT_GE(stats, 0);
118 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_WLAN0);
119 EXPECT_GE(stats, 0);
120 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_WLAN0);
121 EXPECT_GE(stats, 0);
122
123 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_LO);
124 EXPECT_GE(stats, 0);
125 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_LO);
126 EXPECT_GE(stats, 0);
127 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_LO);
128 EXPECT_GE(stats, 0);
129 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_LO);
130 EXPECT_GE(stats, 0);
131
132 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_DUMMY0);
133 EXPECT_GE(stats, 0);
134 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_DUMMY0);
135 EXPECT_GE(stats, 0);
136 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_DUMMY0);
137 EXPECT_GE(stats, 0);
138 bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_DUMMY0);
139 EXPECT_GE(stats, 0);
140 }
141
142 HWTEST_F(NetsysBpfStatsTest, GetAllStatsInfo, TestSize.Level1)
143 {
144 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
145 std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
146 bpfStats->GetAllStatsInfo(stats);
147 EXPECT_GE(stats.size(), 0);
148 }
149
150 HWTEST_F(NetsysBpfStatsTest, LoadElf, TestSize.Level1)
151 {
152 auto ret = OHOS::NetManagerStandard::LoadElf(TEST_BFP_NAME_NETSYS_PATH);
153 EXPECT_GE(ret, NETSYS_SUCCESS);
154
155 ret = OHOS::NetManagerStandard::LoadElf(BFP_NAME_NETSYS_PATH);
156 EXPECT_EQ(ret, NETSYS_SUCCESS);
157 }
158
159 HWTEST_F(NetsysBpfStatsTest, LoadAndUidStats, TestSize.Level1)
160 {
161 BpfMapper<app_uid_stats_key, app_uid_stats_value> appUidStatsMap(APP_UID_STATS_MAP_PATH, BPF_ANY);
162 EXPECT_TRUE(appUidStatsMap.IsValid());
163 app_uid_stats_value value;
164 value.rxBytes = TEST_BYTES0;
165 value.rxPackets = TEST_BYTES0;
166 value.txBytes = TEST_BYTES0;
167 value.txPackets = TEST_BYTES0;
168 auto ret = appUidStatsMap.Write(TEST_UID1, value, BPF_ANY);
169 EXPECT_EQ(ret, NETSYS_SUCCESS);
170
171 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
172 uint64_t stats = 0;
173 EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID1), NETSYS_SUCCESS);
174 EXPECT_EQ(stats, TEST_BYTES0);
175 EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID1), NETSYS_SUCCESS);
176 EXPECT_EQ(stats, TEST_BYTES0);
177 EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID1), NETSYS_SUCCESS);
178 EXPECT_EQ(stats, TEST_BYTES0);
179 EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID1), NETSYS_SUCCESS);
180 EXPECT_EQ(stats, TEST_BYTES0);
181
182 ret = appUidStatsMap.Delete(TEST_UID1);
183 EXPECT_EQ(ret, NETSYS_SUCCESS);
184
185 std::vector<app_uid_stats_key> keys;
186 keys.emplace_back(TEST_UID1);
187 keys.emplace_back(TEST_UID2);
188 ret = appUidStatsMap.Clear(keys);
189 EXPECT_EQ(ret, NETMANAGER_ERROR);
190 }
191
192 HWTEST_F(NetsysBpfStatsTest, LoadAndIfaceStats, TestSize.Level1)
193 {
194 BpfMapper<iface_stats_key, iface_stats_value> ifaceStatsMap(IFACE_STATS_MAP_PATH, BPF_ANY);
195 EXPECT_TRUE(ifaceStatsMap.IsValid());
196
197 auto ifIndex = if_nametoindex(TEST_IFACE_NAME_WLAN0);
198
199 auto keys = ifaceStatsMap.GetAllKeys();
200 auto r = ifaceStatsMap.Clear(keys);
201 EXPECT_EQ(r, NETSYS_SUCCESS);
202
203 iface_stats_value ifaceStats = {0};
204 ifaceStats.rxBytes = TEST_BYTES0;
205 ifaceStats.rxPackets = TEST_BYTES0;
206 ifaceStats.txBytes = TEST_BYTES0;
207 ifaceStats.txPackets = TEST_BYTES0;
208 auto ret = ifaceStatsMap.Write(ifIndex, ifaceStats, BPF_ANY);
209 EXPECT_EQ(ret, NETSYS_SUCCESS);
210
211 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
212 uint64_t stats = 0;
213 EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
214 EXPECT_EQ(stats, TEST_BYTES0);
215 EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
216 EXPECT_EQ(stats, TEST_BYTES0);
217 EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
218 EXPECT_EQ(stats, TEST_BYTES0);
219 EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
220 EXPECT_EQ(stats, TEST_BYTES0);
221
222 stats = 0;
223 EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_BYTES), NETSYS_SUCCESS);
224 EXPECT_EQ(stats, TEST_BYTES0);
225 EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_PACKETS), NETSYS_SUCCESS);
226 EXPECT_EQ(stats, TEST_BYTES0);
227 EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_BYTES), NETSYS_SUCCESS);
228 EXPECT_EQ(stats, TEST_BYTES0);
229 EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_PACKETS), NETSYS_SUCCESS);
230 EXPECT_EQ(stats, TEST_BYTES0);
231
232 ret = ifaceStatsMap.Delete(ifIndex);
233 EXPECT_EQ(ret, NETSYS_SUCCESS);
234 }
235
236 HWTEST_F(NetsysBpfStatsTest, LoadAndUidIfaceStats, TestSize.Level1)
237 {
238 BpfMapper<app_uid_if_stats_key, app_uid_if_stats_value> uidIfaceStatsMap(APP_UID_IF_STATS_MAP_PATH, BPF_ANY);
239 EXPECT_TRUE(uidIfaceStatsMap.IsValid());
240
241 app_uid_if_stats_value value = {0};
242 value.rxBytes = TEST_BYTES0;
243 value.rxPackets = TEST_BYTES0;
244 value.txBytes = TEST_BYTES0;
245 value.txPackets = TEST_BYTES0;
246 app_uid_if_stats_key key1 = {0};
247 key1.ifIndex = TEST_UID_IF1;
248 key1.uId = TEST_UID1;
249 auto ret = uidIfaceStatsMap.Write(key1, value, BPF_ANY);
250 EXPECT_EQ(ret, NETSYS_SUCCESS);
251
252 app_uid_if_stats_key key2 = {0};
253 key2.ifIndex = TEST_UID_IF2;
254 key2.uId = TEST_UID2;
255 ret = uidIfaceStatsMap.Write(key2, value, BPF_ANY);
256 EXPECT_EQ(ret, NETSYS_SUCCESS);
257
258 std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
259 std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
260 EXPECT_EQ(bpfStats->GetAllStatsInfo(stats), NETSYS_SUCCESS);
261 }
262
263 HWTEST_F(NetsysBpfStatsTest, UnloadElf, TestSize.Level1)
264 {
265 auto ret = OHOS::NetManagerStandard::UnloadElf(BFP_NAME_NETSYS_PATH);
266 EXPECT_EQ(ret, NETSYS_SUCCESS);
267
268 ret = OHOS::NetManagerStandard::UnloadElf(TEST_BFP_NAME_NETSYS_PATH);
269 EXPECT_GE(ret, NETSYS_SUCCESS);
270 }
271 } // namespace NetManagerStandard
272 } // namespace OHOS
273