libbpf/BpfNetworkStatsTest.cpp

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include <fcntl.h>
#include <inttypes.h>
#include <linux/inet_diag.h>
#include <linux/sock_diag.h>
#include <net/if.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include <gtest/gtest.h>

#include <android-base/stringprintf.h>
#include <android-base/strings.h>

#include <netdutils/MockSyscalls.h>
#include "bpf/BpfNetworkStats.h"
#include "bpf/BpfUtils.h"

using namespace android::bpf;

using ::testing::_;
using ::testing::ByMove;
using ::testing::Invoke;
using ::testing::Return;
using ::testing::StrictMock;
using ::testing::Test;

namespace android {
namespace bpf {

using base::unique_fd;
using netdutils::status::ok;

constexpr int TEST_MAP_SIZE = 10;
constexpr uid_t TEST_UID1 = 10086;
constexpr uid_t TEST_UID2 = 12345;
constexpr uint32_t TEST_TAG = 42;
constexpr int TEST_COUNTERSET0 = 0;
constexpr int TEST_COUNTERSET1 = 1;
constexpr const int COUNTERSETS_LIMIT = 2;
constexpr uint64_t TEST_BYTES0 = 1000;
constexpr uint64_t TEST_BYTES1 = 2000;
constexpr uint64_t TEST_PACKET0 = 100;
constexpr uint64_t TEST_PACKET1 = 200;
constexpr const char* IFACE_NAME = "lo";
constexpr uint32_t UNKNOWN_IFACE = 0;

class BpfNetworkStatsHelperTest : public testing::Test {
  protected:
    BpfNetworkStatsHelperTest() {}
    unique_fd mFakeCookieTagMap;
    unique_fd mFakeUidStatsMap;
    unique_fd mFakeTagStatsMap;
    unique_fd mFakeIfaceIndexNameMap;

    void SetUp() {
        mFakeCookieTagMap = unique_fd(createMap(BPF_MAP_TYPE_HASH, sizeof(uint64_t),
                                                sizeof(struct UidTag), TEST_MAP_SIZE, 0));
        ASSERT_LE(0, mFakeCookieTagMap);

        mFakeUidStatsMap = unique_fd(createMap(BPF_MAP_TYPE_HASH, sizeof(struct StatsKey),
                                               sizeof(struct StatsValue), TEST_MAP_SIZE, 0));
        ASSERT_LE(0, mFakeUidStatsMap);

        mFakeTagStatsMap = unique_fd(createMap(BPF_MAP_TYPE_HASH, sizeof(struct StatsKey),
                                               sizeof(struct StatsValue), TEST_MAP_SIZE, 0));
        ASSERT_LE(0, mFakeTagStatsMap);

        mFakeIfaceIndexNameMap =
            unique_fd(createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t), IFNAMSIZ, TEST_MAP_SIZE, 0));
        ASSERT_LE(0, mFakeIfaceIndexNameMap);
    }

    void TearDown() {
        mFakeCookieTagMap.reset();
        mFakeUidStatsMap.reset();
        mFakeTagStatsMap.reset();
    }

    void expectUidTag(uint64_t cookie, uid_t uid, uint32_t tag) {
        struct UidTag tagResult;
        EXPECT_EQ(0, findMapEntry(mFakeCookieTagMap, &cookie, &tagResult));
        EXPECT_EQ(uid, tagResult.uid);
        EXPECT_EQ(tag, tagResult.tag);
    }

    void populateFakeStats(uid_t uid, uint32_t tag, uint32_t ifaceIndex, uint32_t counterSet,
                           StatsValue* value, const base::unique_fd& map_fd) {
        StatsKey key = {
            .uid = (uint32_t)uid, .tag = tag, .counterSet = counterSet, .ifaceIndex = ifaceIndex};
        EXPECT_EQ(0, writeToMapEntry(map_fd, &key, value, BPF_ANY));
    }

    uint32_t updateIfaceMap(const char* ifaceName) {
        int ifaceIndex = if_nametoindex(ifaceName);
        EXPECT_LT(0, ifaceIndex);
        char iface[IFNAMSIZ];
        strlcpy(iface, ifaceName, IFNAMSIZ);
        EXPECT_EQ(0, writeToMapEntry(mFakeIfaceIndexNameMap, &ifaceIndex, iface, BPF_ANY));
        return ifaceIndex;
    }
};

// TEST to verify the behavior of bpf map when cocurrent deletion happens when
// iterating the same map.
TEST_F(BpfNetworkStatsHelperTest, TestIterateMapWithDeletion) {
    for (int i = 0; i < 5; i++) {
        uint64_t cookie = i + 1;
        struct UidTag tag = {.uid = TEST_UID1, .tag = TEST_TAG};
        EXPECT_EQ(0, writeToMapEntry(mFakeCookieTagMap, &cookie, &tag, BPF_ANY));
    }
    uint64_t curCookie = 0;
    uint64_t nextCookie = 0;
    struct UidTag tagResult;
    EXPECT_EQ(0, getNextMapKey(mFakeCookieTagMap, &curCookie, &nextCookie));
    uint64_t headOfMap = nextCookie;
    curCookie = nextCookie;
    // Find the second entry in the map, then immediately delete it.
    EXPECT_EQ(0, getNextMapKey(mFakeCookieTagMap, &curCookie, &nextCookie));
    EXPECT_EQ(0, deleteMapEntry(mFakeCookieTagMap, &nextCookie));
    // Find the entry that is now immediately after headOfMap, then delete that.
    EXPECT_EQ(0, getNextMapKey(mFakeCookieTagMap, &curCookie, &nextCookie));
    EXPECT_EQ(0, deleteMapEntry(mFakeCookieTagMap, &nextCookie));
    // Attempting to read an entry that has been deleted fails with ENOENT.
    curCookie = nextCookie;
    EXPECT_EQ(-1, findMapEntry(mFakeCookieTagMap, &curCookie, &tagResult));
    EXPECT_EQ(ENOENT, errno);
    // Finding the entry after our deleted entry restarts iteration from the beginning of the map.
    EXPECT_EQ(0, getNextMapKey(mFakeCookieTagMap, &curCookie, &nextCookie));
    EXPECT_EQ(headOfMap, nextCookie);
}

TEST_F(BpfNetworkStatsHelperTest, TestGetUidStatsTotal) {
    uint32_t ifaceIndex = updateIfaceMap(IFACE_NAME);
    StatsValue value1 = {.rxBytes = TEST_BYTES0,
                         .rxPackets = TEST_PACKET0,
                         .txBytes = TEST_BYTES1,
                         .txPackets = TEST_PACKET1,};
    populateFakeStats(TEST_UID1, 0, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID1, 0, ifaceIndex, TEST_COUNTERSET1, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID2, 0, ifaceIndex, TEST_COUNTERSET1, &value1, mFakeUidStatsMap);
    Stats result1 = {};
    ASSERT_EQ(0, bpfGetUidStatsInternal(TEST_UID1, &result1, mFakeUidStatsMap));
    ASSERT_EQ(TEST_PACKET0 * 2, result1.rxPackets);
    ASSERT_EQ(TEST_BYTES0 * 2, result1.rxBytes);
    ASSERT_EQ(TEST_PACKET1 * 2, result1.txPackets);
    ASSERT_EQ(TEST_BYTES1 * 2, result1.txBytes);
    Stats result2 = {};
    ASSERT_EQ(0, bpfGetUidStatsInternal(TEST_UID2, &result2, mFakeUidStatsMap));
    ASSERT_EQ(TEST_PACKET0, result2.rxPackets);
    ASSERT_EQ(TEST_BYTES0, result2.rxBytes);
    ASSERT_EQ(TEST_PACKET1, result2.txPackets);
    ASSERT_EQ(TEST_BYTES1, result2.txBytes);
    std::vector<stats_line> lines;
    std::vector<std::string> ifaces;
    ASSERT_EQ(0, parseBpfUidStatsDetail(&lines, ifaces, TEST_UID1, mFakeUidStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)2, lines.size());
    lines.clear();
    ASSERT_EQ(0, parseBpfUidStatsDetail(&lines, ifaces, TEST_UID2, mFakeUidStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)1, lines.size());
}

TEST_F(BpfNetworkStatsHelperTest, TestGetIfaceStatsInternal) {
    const char* fakeFilePath = "/data/local/tmp/testIface.txt";
    std::ofstream fakeProcFile(fakeFilePath);
    ASSERT_TRUE(fakeProcFile.is_open());
    fakeProcFile << "Inter-|   Receive                                                |  Transmit  "
                    "                                            \n";
    fakeProcFile << " face |bytes    packets errs drop fifo frame compressed multicast|bytes    "
                    "packets errs drop fifo colls carrier compressed\n";
    fakeProcFile << "    lo:    8308     116    0    0    0     0          0         0     8308    "
                    " 116    0    0    0     0       0          0\n";
    fakeProcFile << "rmnet0: 1507570    2205    0    0    0     0          0         0   489339    "
                    "2237    0    0    0     0       0          0\n";
    fakeProcFile << "  ifb0:   52454     151    0  151    0     0          0         0        0    "
                    "   0    0    0    0     0       0          0\n";
    fakeProcFile << "  ifb1:   52454     151    0  151    0     0          0         0        0    "
                    "   0    0    0    0     0       0          0\n";
    fakeProcFile << "  sit0:       0       0    0    0    0     0          0         0        0    "
                    "   0  148    0    0     0       0          0\n";
    fakeProcFile << "ip6tnl0:       0       0    0    0    0     0          0         0        0   "
                    "    0  151  151    0     0       0          0\n";
    fakeProcFile.close();
    const char* iface = "lo";
    Stats result1 = {};
    ASSERT_EQ(0, bpfGetIfaceStatsInternal(iface, &result1, fakeFilePath));
    EXPECT_EQ(116UL, result1.rxPackets);
    EXPECT_EQ(8308UL, result1.rxBytes);
    EXPECT_EQ(116UL, result1.txPackets);
    EXPECT_EQ(8308UL, result1.txBytes);
    Stats result2 = {};
    const char* iface2 = "rmnet0";
    EXPECT_EQ(0, bpfGetIfaceStatsInternal(iface2, &result2, fakeFilePath));
    EXPECT_EQ(2205UL, result2.rxPackets);
    EXPECT_EQ(1507570UL, result2.rxBytes);
    EXPECT_EQ(2237UL, result2.txPackets);
    EXPECT_EQ(489339UL, result2.txBytes);
}

TEST_F(BpfNetworkStatsHelperTest, TestGetStatsDetail) {
    uint32_t ifaceIndex = updateIfaceMap(IFACE_NAME);
    StatsValue value1 = {.rxBytes = TEST_BYTES0,
                         .rxPackets = TEST_PACKET0,
                         .txBytes = TEST_BYTES1,
                         .txPackets = TEST_PACKET1,};
    populateFakeStats(TEST_UID1, TEST_TAG, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeTagStatsMap);
    populateFakeStats(TEST_UID1, TEST_TAG, ifaceIndex + 1, TEST_COUNTERSET0, &value1,
                      mFakeTagStatsMap);
    populateFakeStats(TEST_UID1, TEST_TAG + 1, ifaceIndex, TEST_COUNTERSET0, &value1,
                      mFakeTagStatsMap);
    populateFakeStats(TEST_UID2, TEST_TAG, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeTagStatsMap);
    std::vector<stats_line> lines;
    std::vector<std::string> ifaces;
    ASSERT_EQ(0, parseBpfTagStatsDetail(&lines, ifaces, TAG_ALL, UID_ALL, mFakeTagStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)3, lines.size());
    lines.clear();
    ASSERT_EQ(0, parseBpfTagStatsDetail(&lines, ifaces, TAG_ALL, TEST_UID1, mFakeTagStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)2, lines.size());
    lines.clear();
    ASSERT_EQ(0, parseBpfTagStatsDetail(&lines, ifaces, TEST_TAG, TEST_UID1, mFakeTagStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)1, lines.size());
    lines.clear();
    ifaces.push_back(std::string(IFACE_NAME));
    ASSERT_EQ(0, parseBpfTagStatsDetail(&lines, ifaces, TEST_TAG, TEST_UID1, mFakeTagStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)1, lines.size());
}

TEST_F(BpfNetworkStatsHelperTest, TestGetStatsWithSkippedIface) {
    uint32_t ifaceIndex = updateIfaceMap(IFACE_NAME);
    StatsValue value1 = {.rxBytes = TEST_BYTES0,
                         .rxPackets = TEST_PACKET0,
                         .txBytes = TEST_BYTES1,
                         .txPackets = TEST_PACKET1,};
    populateFakeStats(0, 0, 0, COUNTERSETS_LIMIT, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID1, 0, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID1, 0, ifaceIndex + 1, TEST_COUNTERSET0, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID1, 0, ifaceIndex, TEST_COUNTERSET1, &value1, mFakeUidStatsMap);
    populateFakeStats(TEST_UID2, 0, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeUidStatsMap);
    std::vector<stats_line> lines;
    std::vector<std::string> ifaces;
    ASSERT_EQ(0,
              parseBpfUidStatsDetail(&lines, ifaces, -1, mFakeUidStatsMap, mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)3, lines.size());
    lines.clear();
    ASSERT_EQ(0, parseBpfUidStatsDetail(&lines, ifaces, TEST_UID1, mFakeUidStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)2, lines.size());
    lines.clear();
    ASSERT_EQ(0, parseBpfUidStatsDetail(&lines, ifaces, TEST_UID2, mFakeUidStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)1, lines.size());
    lines.clear();
    ifaces.push_back(std::string(IFACE_NAME));
    ASSERT_EQ(0, parseBpfUidStatsDetail(&lines, ifaces, TEST_UID1, mFakeUidStatsMap,
                                        mFakeIfaceIndexNameMap));
    ASSERT_EQ((unsigned long)2, lines.size());
}

TEST_F(BpfNetworkStatsHelperTest, TestUnkownIfaceError) {
    StatsValue value1 = {.rxBytes = TEST_BYTES0 * 20,
                         .rxPackets = TEST_PACKET0,
                         .txBytes = TEST_BYTES1 * 20,
                         .txPackets = TEST_PACKET1,};
    uint32_t ifaceIndex = UNKNOWN_IFACE;
    populateFakeStats(TEST_UID1, 0, ifaceIndex, TEST_COUNTERSET0, &value1, mFakeUidStatsMap);
    StatsKey curKey = {.uid = TEST_UID1,
                       .tag = 0,
                       .ifaceIndex = ifaceIndex,
                       .counterSet = TEST_COUNTERSET0};
    char ifname[IFNAMSIZ];
    uint64_t unknownIfaceBytesTotal = 0;
    ASSERT_EQ(-ENODEV, getIfaceNameFromMap(mFakeIfaceIndexNameMap, mFakeUidStatsMap, ifname, curKey,
                                     &unknownIfaceBytesTotal));
    ASSERT_LE((TEST_BYTES0 * 20 + TEST_BYTES1 * 20), unknownIfaceBytesTotal);
}

}  // namespace bpf
}  // namespace android