理解Android eBPF

字数统计: 3.5k阅读时长: 16 min

 2021/11/26

Android从9.0版本开始全面支持eBPF(extended Berkeley Packet Filters), 其主要用在流量统计上, 也可以用来监控CPU/IO/内存等模块的状态.简单来说, eBPF可以与内核的kprobe/tracepoints/skfilter等模块相结合, 将eBPF的函数hook到内核事件从而监控相应的系统状态.

Android为eBPF提供了许多封装的库, 并提供了eBPF加载器bpfloader:

bpfloader: 位于/system/bpf/bpfloader, 系统启动时负责加载位于/system/etc/bpf 中的eBPF目标文件
libbpf_android: 位于/system/bpf/libbpf_android提供创建bpf容器/加载bpf目标文件的接口
libbpf: 位于/external/bcc, 封装了bpf的系统调用, 提供如attach/dettach程序的接口
libnetdbpf: 位于/system/netd/libnetdbpf, 实现了netd流量统计功能的函数

目前在Android(Q)上有两处eBPF的代码: 一个是/system/netd/bpf_progs/netd.c, 主要是用于流量统计；一个是/system/bpfprogs/time_in_state.c用于监控CPU运行频率以及上下文切换的耗时.

接下来我们就从三个部分来深入理解下Android是如何利用eBPF的:

eBPF程序与目标文件格式
Android eBPF加载与执行流程
Android如何基于eBPF实现流量统计

有关BPF的介绍可以参考之前的文章BPF与eBPF

eBPF程序与目标文件的格式

在Android中, 一个eBPF的c程序格式通常如下, 总的说来分为三个部分:

通过DEFINE_BPF_MAP定义BPF数据容器的类型以及访问接口
声明代码段, 比如SEC("cgroupsock/inet/create")
声明BPF段的证书类型, 一般是GPL或者跟GPL兼容的证书类型（如果要使用内核的某些辅助函数，如bpf_trace_printk的话一定要使用GPL证书，否则无正常加载）

看内核代码, 对于大部分的BPF容器类型可以是GPL的, 也可以是其他证书, 但对于stackmap.c则要求只能是GPL的.但如果要使用某些函数，如bpf_perf_event_read/bpf_trace_printk则要求使用GPL，否则会验证不过，无法加载，具体可以参考bpf_trace.c, 有关辅助函数可以参考bpf-helpers


#include <bpf_helpers.h>

/* Define one or more maps in the maps section, for example
 * define a map of type array int -> uint32_t, with 10 entries
 */
DEFINE_BPF_MAP(name_of_my_map, ARRAY, int, uint32_t, 10);

/* this will also define type-safe accessors:
 *   value * bpf_name_of_my_map_lookup_elem(&key);
 *   int bpf_name_of_my_map_update_elem(&key, &value, flags);
 *   int bpf_name_of_my_map_delete_elem(&key);
 * as such it is heavily suggested to use lowercase *_map names.
 * Also note that due to compiler deficiencies you cannot use a type
 * of 'struct foo' but must instead use just 'foo'.  As such structs
 * must not be defined as 'struct foo {}' and must instead be
 * 'typedef struct {} foo'.
 */

SEC("PROGTYPE/PROGNAME")
int PROGFUNC(..args..) {
   <body-of-code
    ... read or write to MY_MAPNAME
    ... do other things
   >
}

char _license[] SEC("license") = "GPL"; // or other license

代码中PROGFUNC定义了一个函数, 编译后会生成一个PROGTYPE/PROGNAME的段(section), 其中PROGTYPE是eBPF代码类型, (对Android来说)必须是下表中的名字:

事件类型	BPF代码类型	说明
kprobe	BPF_PROG_TYPE_KPROBE	将ePBF函数hook到kprope上以探测内核事件, PROGNAME必须是内核中被kprobe监控的函数名
tracepoint	BPF_PROG_TYPE_TRACEPOINT	将eBPF函数hook到tracepoint事件上, PROGNAME必须是`SUBSYSTEM/EVENT`的格式, 例如用于监控上下文切换的段可以写成`SEC(tracepoint/sched/sched_switch`, 具体可以参考/sys/kernel/debug/tracing/events`下面各个系统事件名
skfilter	BPF_PROG_TYPE_SOCKET_FILTER	将eBPF函数当作一个netfilter模块执行, 参考内核代码`xt_bpf.c`
schedcls	BPF_PROG_TYPE_SCHED_CLS	将eBPF函数当作一个网络数据包的分类器(classifier), 参考内核代码`cls_bpf.c`
cgroupskb/cgroupsock	BPF_PROG_TYPE_CGROUP_SKB/BPF_PROG_TYPE_CGROUP_SOCK	每当指定的cgroup上有数据传输(SKB); 创建`AF_INET/AF_INET6`的socket(SOCK)时就执行eBPF函数 ,参考`bpf-cgroup.h` /`bpf/cgroup.c`

每个eBPF c语言程序都会通过LLVM编译成ELF(Executable-Link Format目标文件, 我们可以通过linux中的readelf/objdump工具来查看ELF文件. 比如利用readelf -S netd.o查看netd.o的段头信息, 从这里可以看到netd.c中定义的各个段:

netd.o sections

Android中eBPF加载流程

在系统启动阶段, Android会把位于/system/etc/bpf/的eBPF目标文件通过bpfloader这个服务加载到内核:



service bpfloader /system/bin/bpfloader
    class main
    capabilities SYS_ADMIN
    # Set RLIMIT_MEMLOCK to 64MB for bpfloader
    # Actually only 8MB is needed, but since bpfloader runs as root, it shares
    # the global rlimit. Once bpfloader is running as its own user in the
    # future, it will have dedicated rlimit to itself and this can be 8MB.
    rlimit memlock 67108864 67108864
    oneshot

进入BpfLoader.cpp看下main函数, 实际是调用loadAllElfObjects加载各个ELF文件: 读取/system/etc/bpf/下面所有.o结束的文件, 然后加载到内核.


#define BPF_PROG_PATH "/system/etc/bpf/"

void loadAllElfObjects(void) {
    DIR* dir;
    struct dirent* ent;

    if ((dir = opendir(BPF_PROG_PATH)) != NULL) {
	while ((ent = readdir(dir)) != NULL) {
	    string s = ent->d_name;
	    if (!EndsWith(s, ".o")) continue;

	    string progPath = BPF_PROG_PATH + s;

	    int ret = android::bpf::loadProg(progPath.c_str());
	    ALOGI("Attempted load object: %s, ret: %s", progPath.c_str(), std::strerror(-ret));
	}
	closedir(dir);
    }
}

函数loadProg根据eBPF目标文件中的段创建容器类型, 并加载代码到内核:

首先检查是否存在证书的段(section)
readCodeSections:读取ELF文件中段信息, 生成代码段CodeSection的列表
createMaps: 根据ELF目标文件中的maps段信息创建对应的容器对象
applyMapRelo: 看代码应该是对BPF中的指令进行重定位(如何进行重定位?)
loadCodeSections: 加载目标文件到内核, 并将加载后的fd固定到特定的路径


int loadProg(const char* elfPath) {
    vector<char> license;
    vector<codeSection> cs;
    vector<int> mapFds;
    int ret;

    ifstream elfFile(elfPath, ios::in | ios::binary);
    if (!elfFile.is_open()) return -1;

    ret = readSectionByName("license", elfFile, license);
    if (ret) {
       ALOGE("Couldn't find license in %s\n", elfPath);
       return ret;
    } else {
		ALOGD("Loading ELF object %s with license %s\n", elfPath, (char*)license.data());
    }

    ret = readCodeSections(elfFile, cs);
    if (ret) {
       ALOGE("Couldn't read all code sections in %s\n", elfPath);
       return ret;
    }

    /* Just for future debugging */
    if (0) dumpAllCs(cs);

    ret = createMaps(elfPath, elfFile, mapFds);
    if (ret) {
       ALOGE("Failed to create maps: (ret=%d) in %s\n", ret, elfPath);
       return ret;
    }

    for (int i = 0; i < (int)mapFds.size(); i++)
       ALOGD("map_fd found at %d is %d in %s\n", i, mapFds[i], elfPath);

    applyMapRelo(elfFile, mapFds, cs);

    ret = loadCodeSections(elfPath, cs, string(license.data()));
    if (ret) ALOGE("Failed to load programs, loadCodeSections ret=%d\n", ret);

    return ret;
}

下面就分别来看下其中的几个关键步骤.

生成代码段,创建map

函数readCodeSections读取ELF目标文件中的段头信息, 获取到每个BPF段的代码类型, 常见的有BPF_PROG_TYPE_KPROBE, BPF_PROG_TYPE_SOCKET_FILTER等(见上述表中的说明). 接着查看该段是否需要进行重定位.


static int readCodeSections(ifstream& elfFile, vector<codeSection>& cs) {
    vector<Elf64_Shdr> shTable;
    int entries, ret = 0;

    ret = readSectionHeadersAll(elfFile, shTable);
    if (ret) return ret;
    entries = shTable.size();

    for (int i = 0; i < entries; i++) {
       string name;
       codeSection cs_temp;
       cs_temp.type = BPF_PROG_TYPE_UNSPEC;

       ret = getSymName(elfFile, shTable[i].sh_name, name);
       if (ret) return ret;

       enum bpf_prog_type ptype = getSectionType(name);
       if (ptype != BPF_PROG_TYPE_UNSPEC) {
           deslash(name);
           cs_temp.type = ptype;
           cs_temp.name = name;

           ret = readSectionByIdx(elfFile, i, cs_temp.data);
           if (ret) return ret;
           ALOGD("Loaded code section %d (%s)\n", i, name.c_str());
       }

       /* Check for rel section */
       if (cs_temp.data.size() > 0 && i < entries) {
           ret = getSymName(elfFile, shTable[i + 1].sh_name, name);
           if (ret) return ret;

           if (isRelSection(cs_temp, name)) {
               ret = readSectionByIdx(elfFile, i + 1, cs_temp.rel_data);
               if (ret) return ret;
               ALOGD("Loaded relo section %d (%s)\n", i, name.c_str());
           }
       }

       if (cs_temp.data.size() > 0) {
           cs.push_back(cs_temp);
           ALOGD("Adding section %d to cs list\n", i);
       }
    }
    return 0;
}

接着根据CodeSection列表创建内核的map对象(用于保存内核事件结果, 常见的有arraymap, hashmap等几种类型):


static int createMaps(const char* elfPath, ifstream& elfFile, vector<int>& mapFds) {
    int ret, fd;
    vector<char> mdData;
    vector<struct bpf_map_def> md;
    vector<string> mapNames;
    string fname = pathToFilename(string(elfPath), true);

    ret = readSectionByName("maps", elfFile, mdData);
    if (ret) return ret;
    md.resize(mdData.size() / sizeof(struct bpf_map_def));
    memcpy(md.data(), mdData.data(), mdData.size());

    ret = getMapNames(elfFile, mapNames);
    if (ret) return ret;

    mapFds.resize(mapNames.size());

    for (int i = 0; i < (int)mapNames.size(); i++) {
       // Format of pin location is /sys/fs/bpf/map_<filename>_<mapname>
       string mapPinLoc;
       bool reuse = false;

       mapPinLoc = string(BPF_FS_PATH) + "map_" + fname + "_" + string(mapNames[i]);
       if (access(mapPinLoc.c_str(), F_OK) == 0) {
           fd = bpf_obj_get(mapPinLoc.c_str());
           ALOGD("bpf_create_map reusing map %s, ret: %d\n", mapNames[i].c_str(), fd);
           reuse = true;
       } else {
           fd = bpf_create_map(md[i].type, mapNames[i].c_str(), md[i].key_size, md[i].value_size,
                               md[i].max_entries, md[i].map_flags);
           ALOGD("bpf_create_map name %s, ret: %d\n", mapNames[i].c_str(), fd);
       }
       ...

       if (!reuse) {
           ret = bpf_obj_pin(fd, mapPinLoc.c_str());
           if (ret < 0) return ret;
       }

       mapFds[i] = fd;
    }

    return ret;
}

为了避免map对象在bpfloader服务退出之后被销毁, 最后都会通过bpf_obj_pin把这些对象固定到/sys/fs/bpf文件节点.

加载代码到内核

要监听到内核事件, eBPF的ELF目标文件首先需要加载到内核, 然后在内核发生对应事件后触发对应的eBPF代码逻辑(内核的bpf虚拟机在执行代码之前会对目标文件代码进行校验, 以确保代码没有死循环等逻辑错误).

bpf_prog_load: 加载bpf程序到内核
bpf_obj_pin: 将bpf程序固定到/sys/fs/bpf文件节点, 确保服务退出后, bpf程序依然可以正常执行


static int loadCodeSections(const char* elfPath, vector<codeSection>& cs, const string& license) {
    int ret, fd, kvers;

    if ((kvers = getMachineKvers()) < 0) return -1;

    string fname = pathToFilename(string(elfPath), true);

    for (int i = 0; i < (int)cs.size(); i++) {
       string progPinLoc;
       bool reuse = false;

       // Format of pin location is
       // /sys/fs/bpf/prog_<filename>_<mapname>
       progPinLoc = string(BPF_FS_PATH) + "prog_" + fname + "_" + cs[i].name;
       if (access(progPinLoc.c_str(), F_OK) == 0) {
           fd = bpf_obj_get(progPinLoc.c_str());
           ALOGD("New bpf prog load reusing prog %s, ret: %d\n", cs[i].name.c_str(), fd);
           reuse = true;
       } else {
           vector<char> log_buf(BPF_LOAD_LOG_SZ, 0);

           fd = bpf_prog_load(cs[i].type, cs[i].name.c_str(), (struct bpf_insn*)cs[i].data.data(), cs[i].data.size(), license.c_str(), kvers, 0, log_buf.data(), log_buf.size());
           ALOGD("New bpf core prog_load for %s (%s) returned: %d\n", elfPath, cs[i].name.c_str(),fd);

           if (fd <= 0)
               ALOGE("bpf_prog_load: log_buf contents: %s\n", (char *)log_buf.data());
       }
       
       ...

       if (!reuse) {
           ret = bpf_obj_pin(fd, progPinLoc.c_str());
           if (ret < 0) return ret;
       }

       cs[i].prog_fd = fd;
    }

    return 0;
}

到这一步, eBPF完成了初始化, 目标文件也load到了内核, 此时只要内核有相应事件发生, 都会把结果保存到对应的map对象中. 用户进程只需要通过bpf的系统调用BPF_MAP_LOOKUP_ELEM等指令获取map对象中的数据.

Android如何使用eBPF统计流量

Android系统支持多种粒度的流量统计, 比如统计每个网卡的流量, 每个用户使用的流量, 有关Android流量统计的细节可以参考之前的博文Android是如何实现流量统计的. 这里我们主要看下如何基于eBPF来实现对网卡以及每个用户的流量统计.

Android中有一个netd进程负责网络管理, 流量统计等功能, 在启动的时候会初始化一个TrafficController的类, 这个类就是负责流量统计功能的, 其在初始化的时候会创建几个BpfMap(实际是一个key-value的容器模板)对象, 用于保存不同流量统计的结果:



Status TrafficController::initMaps() {
    std::lock_guard guard(mMutex);
    ...
    RETURN_IF_NOT_OK(mAppUidStatsMap.init(APP_UID_STATS_MAP_PATH));
    RETURN_IF_NOT_OK(changeOwnerAndMode(APP_UID_STATS_MAP_PATH, AID_NET_BW_STATS, "AppUidStatsMap", false));

    RETURN_IF_NOT_OK(mStatsMapA.init(STATS_MAP_A_PATH));
    RETURN_IF_NOT_OK(changeOwnerAndMode(STATS_MAP_A_PATH, AID_NET_BW_STATS, "StatsMapA", false));

    RETURN_IF_NOT_OK(mStatsMapB.init(STATS_MAP_B_PATH));
    RETURN_IF_NOT_OK(changeOwnerAndMode(STATS_MAP_B_PATH, AID_NET_BW_STATS, "StatsMapB", false));

    RETURN_IF_NOT_OK(mIfaceIndexNameMap.init(IFACE_INDEX_NAME_MAP_PATH);
    RETURN_IF_NOT_OK(changeOwnerAndMode(IFACE_INDEX_NAME_MAP_PATH, AID_NET_BW_STATS,"IfaceIndexNameMap", false));

    RETURN_IF_NOT_OK(mIfaceStatsMap.init(IFACE_STATS_MAP_PATH));
    RETURN_IF_NOT_OK(changeOwnerAndMode(IFACE_STATS_MAP_PATH, AID_NET_BW_STATS, "IfaceStatsMap",false));
       ...
    return netdutils::status::ok;
}

查看BpfMap模板(在BpfMap.h中定义)中的init函数可以知道, mAppUidStatsMap.init/mIfaceStatsMap.init实际是获取到固定在/sys/fs/bpf目录下的各个map对象节点文件描述符, 然后就可以通过该描述符来操作对应的map对象了.


netdutils::Status BpfMap<Key, Value>::init(const char* path) {
    mMapFd = base::unique_fd(mapRetrieve(path, 0));
    if (mMapFd == -1) {
       reset();
       return netdutils::statusFromErrno(
               errno,
               base::StringPrintf("pinned map not accessible or does not exist: (%s)\n", path));
    }
    return netdutils::status::ok;
}

对于cgroupskb类型的bpf程序, 还需要通过BPF_PROG_ATTACH命令把固定到/sys/fs/bpf的代码附着到对应的cgroup上(这样我们就可以监控特定cgroup上的进程的网络状态了):


static Status initPrograms() {
    std::string cg2_path;

    if (!CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &cg2_path)) {
       int ret = errno;
       ALOGE("Failed to find cgroup v2 root");
       return statusFromErrno(ret, "Failed to find cgroup v2 root");
    }

    unique_fd cg_fd(open(cg2_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC));
    if (cg_fd == -1) {
       int ret = errno;
       ALOGE("Failed to open the cgroup directory: %s", strerror(ret));
       return statusFromErrno(ret, "Open the cgroup directory failed");
    }
    RETURN_IF_NOT_OK(attachProgramToCgroup(BPF_EGRESS_PROG_PATH, cg_fd, BPF_CGROUP_INET_EGRESS));
    RETURN_IF_NOT_OK(attachProgramToCgroup(BPF_INGRESS_PROG_PATH, cg_fd, BPF_CGROUP_INET_INGRESS));

    // For the devices that support cgroup socket filter, the socket filter
    // should be loaded successfully by bpfloader. So we attach the filter to
    // cgroup if the program is pinned properly.
    // TODO: delete the if statement once all devices should support cgroup
    // socket filter (ie. the minimum kernel version required is 4.14).
    if (!access(CGROUP_SOCKET_PROG_PATH, F_OK)) {
         RETURN_IF_NOT_OK(
	        attachProgramToCgroup(CGROUP_SOCKET_PROG_PATH, cg_fd, BPF_CGROUP_INET_SOCK_CREATE));
    }
    return netdutils::status::ok;
}

cgroup是linux管理系统资源的资源分配与隔离方案, 在同一个cgroup的进程共享同样的CPU, 内存以及网络资源.

Android提供了一个libnetdbpf库封装了获取系统UID以及网卡的流量统计接口，提供给框架层使用, 比如想要获取某个UID的流量，可以使用bpfGetUidStats这个接口获取:


int bpfGetUidStatsInternal(uid_t uid, Stats* stats,
                           const BpfMap<uint32_t, StatsValue>& appUidStatsMap) {
    auto statsEntry = appUidStatsMap.readValue(uid);
    if (isOk(statsEntry)) {
        stats->rxPackets = statsEntry.value().rxPackets;
        stats->txPackets = statsEntry.value().txPackets;
        stats->rxBytes = statsEntry.value().rxBytes;
        stats->txBytes = statsEntry.value().txBytes;
    }
    return statsEntry.status().code() == ENOENT ? 0 : -statsEntry.status().code();
}

int bpfGetUidStats(uid_t uid, Stats* stats) {
    BpfMap<uint32_t, StatsValue> appUidStatsMap(
        mapRetrieve(APP_UID_STATS_MAP_PATH, BPF_OPEN_FLAGS));

    if (!appUidStatsMap.isValid()) {
        int ret = -errno;
        ALOGE("Opening appUidStatsMap(%s) failed: %s", APP_UID_STATS_MAP_PATH, strerror(errno));
        return ret;
    }
    return bpfGetUidStatsInternal(uid, stats, appUidStatsMap);
}

更多的实现细节可以参考BpfNetworkStats.cpp``, BpfMap.h以及TrafficController.cpp.

总结

这篇文章主要将了Android中eBPF程序的格式, 以及如何加载eBPF程序, 最后阐述了Android上如何利用eBPF来实现流量统计的功能. 对eBPF的逻辑与流程理清楚后, 在Android上开发自己的eBPF功能也就不是什么难事了.

参考文献

原文作者：Jason Wang

更新日期：2023-02-08, 14:26:58

Next Post

感悟2021
Previous Post

什么是GARP

CATALOG

1. eBPF程序与目标文件的格式
2. Android中eBPF加载流程
1. 2.1. 生成代码段,创建map
2. 2.2. 加载代码到内核
3. Android如何使用eBPF统计流量
4. 总结
5. 参考文献