| /* |
| * Copyright (c) Facebook, Inc. |
| * Licensed under the Apache License, Version 2.0 (the "License") |
| * |
| * Usage: |
| * ./SkLocalStorageIterator |
| * |
| * BPF socket local storage map iterator supported is added in 5.9. |
| * But since it takes locks during iterating, it may have performance |
| * implication if in parallel some other bpf program or user space |
| * is doing map update/delete for sockets in the same bucket. The issue |
| * is fixed in 5.10 with the following patch which uses rcu lock instead: |
| * https://lore.kernel.org/bpf/20200916224645.720172-1-yhs@fb.com |
| * |
| * This example shows how to dump local storage data from all sockets |
| * associated with one socket local storage map. |
| * An example output likes below: |
| * family prot val |
| * 2 17 20 |
| * 2 17 10 |
| */ |
| |
| #include <unistd.h> |
| #include <fstream> |
| #include <iostream> |
| #include <string> |
| #include <net/if.h> |
| |
| #include "bcc_version.h" |
| #include "BPF.h" |
| |
| const std::string BPF_PROGRAM = R"( |
| |
| #include <linux/bpf.h> |
| #include <linux/seq_file.h> |
| #include <net/sock.h> |
| |
| /* the structure is defined in .c file, so explicitly define |
| * the structure here. |
| */ |
| struct bpf_iter__bpf_sk_storage_map { |
| union { |
| struct bpf_iter_meta *meta; |
| }; |
| union { |
| struct bpf_map *map; |
| }; |
| union { |
| struct sock *sk; |
| }; |
| union { |
| void *value; |
| }; |
| }; |
| |
| BPF_SK_STORAGE(sk_data_map, __u64); |
| |
| struct info_t { |
| __u32 family; |
| __u32 protocol; |
| __u64 val; |
| }; |
| |
| BPF_ITER(bpf_sk_storage_map) { |
| struct seq_file *seq = ctx->meta->seq; |
| struct sock *sk = ctx->sk; |
| __u64 *val = ctx->value; |
| struct info_t info = {}; |
| |
| if (sk == (void *)0 || val == (void *)0) |
| return 0; |
| |
| info.family = sk->sk_family; |
| info.protocol = sk->sk_protocol; |
| info.val = *val; |
| bpf_seq_write(seq, &info, sizeof(info)); |
| |
| return 0; |
| } |
| )"; |
| |
| struct info_t { |
| unsigned family; |
| unsigned protocol; |
| unsigned long long val; |
| }; |
| |
| int main() { |
| ebpf::BPF bpf; |
| auto res = bpf.init(BPF_PROGRAM); |
| if (!res.ok()) { |
| std::cerr << res.msg() << std::endl; |
| return 1; |
| } |
| |
| // create two sockets |
| int sockfd1 = socket(AF_INET, SOCK_DGRAM, 0); |
| if (sockfd1 < 0) { |
| std::cerr << "socket1 create failure: " << sockfd1 << std::endl; |
| return 1; |
| } |
| |
| int sockfd2 = socket(AF_INET, SOCK_DGRAM, 0); |
| if (sockfd2 < 0) { |
| std::cerr << "socket2 create failure: " << sockfd2 << std::endl; |
| close(sockfd1); |
| return 1; |
| } |
| |
| unsigned long long v1 = 10, v2 = 20; |
| auto sk_table = bpf.get_sk_storage_table<unsigned long long>("sk_data_map"); |
| |
| res = sk_table.update_value(sockfd1, v1); |
| if (!res.ok()) { |
| std::cerr << "sk_data_map sockfd1 update failure: " << res.msg() << std::endl; |
| close(sockfd2); |
| close(sockfd1); |
| return 1; |
| } |
| |
| res = sk_table.update_value(sockfd2, v2); |
| if (!res.ok()) { |
| std::cerr << "sk_data_map sockfd2 update failure: " << res.msg() << std::endl; |
| close(sockfd2); |
| close(sockfd1); |
| return 1; |
| } |
| |
| int prog_fd; |
| res = bpf.load_func("bpf_iter__bpf_sk_storage_map", BPF_PROG_TYPE_TRACING, prog_fd); |
| if (!res.ok()) { |
| std::cerr << res.msg() << std::endl; |
| return 1; |
| } |
| |
| union bpf_iter_link_info link_info = {}; |
| link_info.map.map_fd = sk_table.get_fd(); |
| int link_fd = bcc_iter_attach(prog_fd, &link_info, sizeof(union bpf_iter_link_info)); |
| if (link_fd < 0) { |
| std::cerr << "bcc_iter_attach failed: " << link_fd << std::endl; |
| close(sockfd2); |
| close(sockfd1); |
| return 1; |
| } |
| |
| int iter_fd = bcc_iter_create(link_fd); |
| if (iter_fd < 0) { |
| std::cerr << "bcc_iter_create failed: " << iter_fd << std::endl; |
| close(link_fd); |
| close(sockfd2); |
| close(sockfd1); |
| return 1; |
| } |
| |
| // Header. |
| printf("family\tprot\tval\n"); |
| |
| struct info_t info[20]; |
| int len, leftover = 0, info_size = 20 * sizeof(struct info_t); |
| while ((len = read(iter_fd, (char *)info + leftover, info_size - leftover))) { |
| if (len < 0) { |
| if (len == -EAGAIN) |
| continue; |
| std::cerr << "read failed: " << len << std::endl; |
| break; |
| } |
| |
| int num_info = len / sizeof(struct info_t); |
| for (int i = 0; i < num_info; i++) { |
| printf("%d\t%d\t%lld\n", info[i].family, info[i].protocol, info[i].val); |
| } |
| |
| leftover = len % sizeof(struct info_t); |
| if (num_info > 0) |
| memcpy(info, (void *)&info[num_info], leftover); |
| } |
| |
| close(iter_fd); |
| close(link_fd); |
| close(sockfd2); |
| close(sockfd1); |
| return 0; |
| } |