Deploying to gh-pages from @ eunomia-bpf/bpf-developer-tutorial@d962bc4781 🚀

14-tcpstates/bits.bpf.h

@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
+#ifndef __BITS_BPF_H
+#define __BITS_BPF_H
+
+#define READ_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define WRITE_ONCE(x, val) ((*(volatile typeof(x) *)&(x)) = val)
+
+static __always_inline u64 log2(u32 v)
+{
+	u32 shift, r;
+
+	r = (v > 0xFFFF) << 4; v >>= r;
+	shift = (v > 0xFF) << 3; v >>= shift; r |= shift;
+	shift = (v > 0xF) << 2; v >>= shift; r |= shift;
+	shift = (v > 0x3) << 1; v >>= shift; r |= shift;
+	r |= (v >> 1);
+
+	return r;
+}
+
+static __always_inline u64 log2l(u64 v)
+{
+	u32 hi = v >> 32;
+
+	if (hi)
+		return log2(hi) + 32;
+	else
+		return log2(v);
+}
+
+#endif /* __BITS_BPF_H */

14-tcpstates/index.html

@@ -154,97 +154,97 @@
 #include <bpf/bpf_core_read.h>
 #include "tcpstates.h"
 
-#define MAX_ENTRIES	10240
-#define AF_INET		2
-#define AF_INET6	10
+#define MAX_ENTRIES 10240
+#define AF_INET     2
+#define AF_INET6    10
 
 const volatile bool filter_by_sport = false;
 const volatile bool filter_by_dport = false;
 const volatile short target_family = 0;
 
 struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__uint(max_entries, MAX_ENTRIES);
-	__type(key, __u16);
-	__type(value, __u16);
+    __uint(type, BPF_MAP_TYPE_HASH);
+    __uint(max_entries, MAX_ENTRIES);
+    __type(key, __u16);
+    __type(value, __u16);
 } sports SEC(".maps");
 
 struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__uint(max_entries, MAX_ENTRIES);
-	__type(key, __u16);
-	__type(value, __u16);
+    __uint(type, BPF_MAP_TYPE_HASH);
+    __uint(max_entries, MAX_ENTRIES);
+    __type(key, __u16);
+    __type(value, __u16);
 } dports SEC(".maps");
 
 struct {
-	__uint(type, BPF_MAP_TYPE_HASH);
-	__uint(max_entries, MAX_ENTRIES);
-	__type(key, struct sock *);
-	__type(value, __u64);
+    __uint(type, BPF_MAP_TYPE_HASH);
+    __uint(max_entries, MAX_ENTRIES);
+    __type(key, struct sock *);
+    __type(value, __u64);
 } timestamps SEC(".maps");
 
 struct {
-	__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
-	__uint(key_size, sizeof(__u32));
-	__uint(value_size, sizeof(__u32));
+    __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
+    __uint(key_size, sizeof(__u32));
+    __uint(value_size, sizeof(__u32));
 } events SEC(".maps");
 
 SEC("tracepoint/sock/inet_sock_set_state")
 int handle_set_state(struct trace_event_raw_inet_sock_set_state *ctx)
 {
-	struct sock *sk = (struct sock *)ctx->skaddr;
-	__u16 family = ctx->family;
-	__u16 sport = ctx->sport;
-	__u16 dport = ctx->dport;
-	__u64 *tsp, delta_us, ts;
-	struct event event = {};
+    struct sock *sk = (struct sock *)ctx->skaddr;
+    __u16 family = ctx->family;
+    __u16 sport = ctx->sport;
+    __u16 dport = ctx->dport;
+    __u64 *tsp, delta_us, ts;
+    struct event event = {};
 
-	if (ctx->protocol != IPPROTO_TCP)
-		return 0;
+    if (ctx->protocol != IPPROTO_TCP)
+        return 0;
 
-	if (target_family && target_family != family)
-		return 0;
+    if (target_family && target_family != family)
+        return 0;
 
-	if (filter_by_sport && !bpf_map_lookup_elem(&sports, &sport))
-		return 0;
+    if (filter_by_sport && !bpf_map_lookup_elem(&sports, &sport))
+        return 0;
 
-	if (filter_by_dport && !bpf_map_lookup_elem(&dports, &dport))
-		return 0;
+    if (filter_by_dport && !bpf_map_lookup_elem(&dports, &dport))
+        return 0;
 
-	tsp = bpf_map_lookup_elem(&timestamps, &sk);
-	ts = bpf_ktime_get_ns();
-	if (!tsp)
-		delta_us = 0;
-	else
-		delta_us = (ts - *tsp) / 1000;
+    tsp = bpf_map_lookup_elem(&timestamps, &sk);
+    ts = bpf_ktime_get_ns();
+    if (!tsp)
+        delta_us = 0;
+    else
+        delta_us = (ts - *tsp) / 1000;
 
-	event.skaddr = (__u64)sk;
-	event.ts_us = ts / 1000;
-	event.delta_us = delta_us;
-	event.pid = bpf_get_current_pid_tgid() >> 32;
-	event.oldstate = ctx->oldstate;
-	event.newstate = ctx->newstate;
-	event.family = family;
-	event.sport = sport;
-	event.dport = dport;
-	bpf_get_current_comm(&event.task, sizeof(event.task));
+    event.skaddr = (__u64)sk;
+    event.ts_us = ts / 1000;
+    event.delta_us = delta_us;
+    event.pid = bpf_get_current_pid_tgid() >> 32;
+    event.oldstate = ctx->oldstate;
+    event.newstate = ctx->newstate;
+    event.family = family;
+    event.sport = sport;
+    event.dport = dport;
+    bpf_get_current_comm(&event.task, sizeof(event.task));
 
-	if (family == AF_INET) {
-		bpf_probe_read_kernel(&event.saddr, sizeof(event.saddr), &sk->__sk_common.skc_rcv_saddr);
-		bpf_probe_read_kernel(&event.daddr, sizeof(event.daddr), &sk->__sk_common.skc_daddr);
-	} else { /* family == AF_INET6 */
-		bpf_probe_read_kernel(&event.saddr, sizeof(event.saddr), &sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32);
-		bpf_probe_read_kernel(&event.daddr, sizeof(event.daddr), &sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32);
-	}
+    if (family == AF_INET) {
+        bpf_probe_read_kernel(&event.saddr, sizeof(event.saddr), &sk->__sk_common.skc_rcv_saddr);
+        bpf_probe_read_kernel(&event.daddr, sizeof(event.daddr), &sk->__sk_common.skc_daddr);
+    } else { /* family == AF_INET6 */
+        bpf_probe_read_kernel(&event.saddr, sizeof(event.saddr), &sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32);
+        bpf_probe_read_kernel(&event.daddr, sizeof(event.daddr), &sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32);
+    }
 
-	bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, sizeof(event));
+    bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, sizeof(event));
 
-	if (ctx->newstate == TCP_CLOSE)
-		bpf_map_delete_elem(&timestamps, &sk);
-	else
-		bpf_map_update_elem(&timestamps, &sk, &ts, BPF_ANY);
+    if (ctx->newstate == TCP_CLOSE)
+        bpf_map_delete_elem(&timestamps, &sk);
+    else
+        bpf_map_update_elem(&timestamps, &sk, &ts, BPF_ANY);
 
-	return 0;
+    return 0;
 }
 
 char LICENSE[] SEC("license") = "Dual BSD/GPL";

14-tcpstates/maps.bpf.h

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
+// Copyright (c) 2020 Anton Protopopov
+#ifndef __MAPS_BPF_H
+#define __MAPS_BPF_H
+
+#include <bpf/bpf_helpers.h>
+#include <asm-generic/errno.h>
+
+static __always_inline void *
+bpf_map_lookup_or_try_init(void *map, const void *key, const void *init)
+{
+	void *val;
+	long err;
+
+	val = bpf_map_lookup_elem(map, key);
+	if (val)
+		return val;
+
+	err = bpf_map_update_elem(map, key, init, BPF_NOEXIST);
+	if (err && err != -EEXIST)
+		return 0;
+
+	return bpf_map_lookup_elem(map, key);
+}
+
+#endif /* __MAPS_BPF_H */

14-tcpstates/tcprtt.bpf.c

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2021 Wenbo Zhang
+#include <vmlinux.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_core_read.h>
+#include <bpf/bpf_tracing.h>
+#include <bpf/bpf_endian.h>
+#include "tcprtt.h"
+#include "bits.bpf.h"
+#include "maps.bpf.h"
+
+char LICENSE[] SEC("license") = "Dual BSD/GPL";
+
+const volatile bool targ_laddr_hist = false;
+const volatile bool targ_raddr_hist = false;
+const volatile bool targ_show_ext = false;
+const volatile __u16 targ_sport = 0;
+const volatile __u16 targ_dport = 0;
+const volatile __u32 targ_saddr = 0;
+const volatile __u32 targ_daddr = 0;
+const volatile bool targ_ms = false;
+
+#define MAX_ENTRIES	10240
+
+/// @sample {"interval": 1000, "type" : "log2_hist"}
+struct {
+	__uint(type, BPF_MAP_TYPE_HASH);
+	__uint(max_entries, MAX_ENTRIES);
+	__type(key, u64);
+	__type(value, struct hist);
+} hists SEC(".maps");
+
+static struct hist zero;
+
+SEC("fentry/tcp_rcv_established")
+int BPF_PROG(tcp_rcv, struct sock *sk)
+{
+	const struct inet_sock *inet = (struct inet_sock *)(sk);
+	struct tcp_sock *ts;
+	struct hist *histp;
+	u64 key, slot;
+	u32 srtt;
+
+	if (targ_sport && targ_sport != inet->inet_sport)
+		return 0;
+	if (targ_dport && targ_dport != sk->__sk_common.skc_dport)
+		return 0;
+	if (targ_saddr && targ_saddr != inet->inet_saddr)
+		return 0;
+	if (targ_daddr && targ_daddr != sk->__sk_common.skc_daddr)
+		return 0;
+
+	if (targ_laddr_hist)
+		key = inet->inet_saddr;
+	else if (targ_raddr_hist)
+		key = inet->sk.__sk_common.skc_daddr;
+	else
+		key = 0;
+	histp = bpf_map_lookup_or_try_init(&hists, &key, &zero);
+	if (!histp)
+		return 0;
+	ts = (struct tcp_sock *)(sk);
+	srtt = BPF_CORE_READ(ts, srtt_us) >> 3;
+	if (targ_ms)
+		srtt /= 1000U;
+	slot = log2l(srtt);
+	if (slot >= MAX_SLOTS)
+		slot = MAX_SLOTS - 1;
+	__sync_fetch_and_add(&histp->slots[slot], 1);
+	if (targ_show_ext) {
+		__sync_fetch_and_add(&histp->latency, srtt);
+		__sync_fetch_and_add(&histp->cnt, 1);
+	}
+	return 0;
+}

14-tcpstates/tcprtt.h

@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
+#ifndef __TCPRTT_H
+#define __TCPRTT_H
+
+#define MAX_SLOTS	27
+
+struct hist {
+	unsigned long long latency;
+	unsigned long long cnt;
+	unsigned int slots[MAX_SLOTS];
+};
+
+#endif /* __TCPRTT_H */