Skip to content

Commit f305651

Browse files
freysteinnfreysteinn
committed
Adds the draft of the XDP scheduler testing tool
This commit contains the XDP scheduling framework. It consists of a testing program called xdq-tester used to test schedulers using the XDP and DEQUEUE hooks. It uses trace files written in Lua that the xdq-tester program uses to check the XDP schedulers for correctness. The FIFO, SPRIO, and WFQ are fully functional in this commit. The SPRIO and WFQ have an API to set the weights from the Lua scripts. This commit's FQ-CoDel contains sparse flow handling and testing. The CoDel part has a bug in how it adds the metadata section in this version. Signed-off-by: Frey Alfredsson <freysteinn@freysteinn.com>
1 parent daefd11 commit f305651

17 files changed

+2926
-0
lines changed

‎xdq-tester/Makefile

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
2+
3+
USER_TARGETS := xdq-tester
4+
BPF_TARGETS := $(patsubst %.c,%,$(wildcard *.bpf.c))
5+
6+
USER_LIBS = -llua -ldl -lm
7+
8+
LIB_DIR = ../lib
9+
10+
include $(LIB_DIR)/common.mk

‎xdq-tester/bpf_local_helpers.h

+116
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2+
3+
#ifndef BPF_LOCAL_HELPERS_H_
4+
#define BPF_LOCAL_HELPERS_H_
5+
6+
#include "bpf_shared_data.h"
7+
8+
#define EEXIST 17 /* File exists */
9+
10+
#define BPF_MAP_TYPE_PIFO_GENERIC 31
11+
#define BPF_MAP_TYPE_PIFO_XDP 32
12+
13+
/*
14+
* bpf_packet_dequeue
15+
*
16+
* Dequeue the packet at the head of the PIFO in *map* and return a pointer
17+
* to the packet (or NULL if the PIFO is empty).
18+
*
19+
* Returns
20+
* On success, a pointer to the packet, or NULL if the PIFO is empty. The
21+
* packet pointer must be freed using *bpf_packet_drop()* or returning
22+
* the packet pointer. The *rank* pointer will be set to the rank of
23+
* the dequeued packet on success, or a negative error code on error.
24+
*/
25+
static long (*bpf_packet_dequeue)(void *ctx, void *map, __u64 flags, __u64 *rank) = (void *) 208;;
26+
static long (*bpf_packet_drop)(void *ctx, void *pkt) = (void *) 209;
27+
28+
struct parsing_context {
29+
void *data; // Start of eth hdr
30+
void *data_end; // End of safe acessible area
31+
void *meta; // Meta data
32+
struct hdr_cursor nh; // Position to parse next
33+
__u32 pkt_len; // Full packet length (headers+data)
34+
};
35+
36+
#pragma GCC diagnostic push
37+
#pragma GCC diagnostic ignored "-Wunused-function"
38+
static __always_inline void *
39+
bpf_map_lookup_or_try_init(void *map, const void *key, const void *init)
40+
{
41+
void *val;
42+
long err;
43+
44+
val = bpf_map_lookup_elem(map, key);
45+
if (val)
46+
return val;
47+
48+
err = bpf_map_update_elem(map, key, init, BPF_NOEXIST);
49+
if (err && err != -EEXIST)
50+
return NULL;
51+
52+
return bpf_map_lookup_elem(map, key);
53+
}
54+
55+
static __always_inline int bpf_max(__u64 left, __u64 right)
56+
{
57+
return right > left ? right : left;
58+
}
59+
60+
61+
/*
62+
* Maps an IPv4 address into an IPv6 address according to RFC 4291 sec 2.5.5.2
63+
*/
64+
static void map_ipv4_to_ipv6(struct in6_addr *ipv6, __be32 ipv4)
65+
{
66+
__builtin_memset(&ipv6->in6_u.u6_addr8[0], 0x00, 10);
67+
__builtin_memset(&ipv6->in6_u.u6_addr8[10], 0xff, 2);
68+
ipv6->in6_u.u6_addr32[3] = ipv4;
69+
}
70+
71+
/*
72+
* Five-tuple helpers
73+
*/
74+
75+
/* This function currently only supports UDP packets */
76+
static __always_inline int parse_packet(struct parsing_context *pctx, struct packet_info *p_info)
77+
{
78+
/* Parse Ethernet and IP/IPv6 headers */
79+
p_info->eth_type = parse_ethhdr(&pctx->nh, pctx->data_end, &p_info->eth);
80+
if (p_info->eth_type == bpf_htons(ETH_P_IP)) {
81+
p_info->ip_type = parse_iphdr(&pctx->nh, pctx->data_end, &p_info->iph);
82+
if (p_info->ip_type < 0)
83+
goto err;
84+
p_info->nt.ipv = 4;
85+
map_ipv4_to_ipv6(&p_info->nt.saddr.ip, p_info->iph->saddr);
86+
map_ipv4_to_ipv6(&p_info->nt.daddr.ip, p_info->iph->daddr);
87+
} else if (p_info->eth_type == bpf_htons(ETH_P_IPV6)) {
88+
p_info->ip_type = parse_ip6hdr(&pctx->nh, pctx->data_end, &p_info->ip6h);
89+
if (p_info->ip_type < 0)
90+
goto err;
91+
p_info->nt.ipv = 6;
92+
p_info->nt.saddr.ip = p_info->ip6h->saddr;
93+
p_info->nt.daddr.ip = p_info->ip6h->daddr;
94+
} else {
95+
goto err;
96+
}
97+
98+
/* Parse UDP header */
99+
if (p_info->ip_type != IPPROTO_UDP)
100+
goto err;
101+
if (parse_udphdr(&pctx->nh, pctx->data_end, &p_info->udph) < 0)
102+
goto err;
103+
104+
p_info->nt.proto = IPPROTO_UDP;
105+
p_info->nt.saddr.port = p_info->udph->source;
106+
p_info->nt.daddr.port = p_info->udph->dest;
107+
108+
return 0;
109+
err:
110+
bpf_printk("Failed to parse UDP packet");
111+
return -1;
112+
}
113+
114+
#pragma GCC diagnostic pop
115+
116+
#endif // BPF_LOCAL_HELPERS_H_

‎xdq-tester/bpf_shared_data.h

+52
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
#ifndef BPF_SHARED_DATA_H_
2+
#define BPF_SHARED_DATA_H_
3+
4+
#include "codel_impl.h"
5+
6+
struct flow_address {
7+
struct in6_addr ip;
8+
__u16 port;
9+
__u16 reserved;
10+
};
11+
12+
struct network_tuple {
13+
struct flow_address saddr;
14+
struct flow_address daddr;
15+
__u16 proto;
16+
__u8 ipv;
17+
__u8 reserved;
18+
};
19+
20+
struct flow_state {
21+
__u32 pkts;
22+
__u32 root_finish_bytes;
23+
__u32 finish_bytes;
24+
__u16 root_weight;
25+
__u16 weight;
26+
__u32 persistent;
27+
__u64 root_priority;
28+
};
29+
30+
struct fq_codel_flow_state {
31+
__u32 pkts;
32+
__u32 finish_bytes;
33+
__u32 total_bytes;
34+
__u32 grace_period;
35+
struct codel_state codel;
36+
};
37+
38+
struct packet_info {
39+
struct ethhdr *eth;
40+
union {
41+
struct iphdr *iph;
42+
struct ipv6hdr *ip6h;
43+
};
44+
union {
45+
struct udphdr *udph;
46+
};
47+
struct network_tuple nt;
48+
int eth_type;
49+
int ip_type;
50+
};
51+
52+
#endif // BPF_SHARED_DATA_H_

‎xdq-tester/codel_impl.h

+155
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
#include <stdbool.h>
2+
3+
#ifndef __CODEL_IMPL_H
4+
#define __CODEL_IMPL_H
5+
6+
#ifndef CODEL_TARGET
7+
#define CODEL_TARGET (10 * 1000 * 1000ULL) /* 10 ms in nanosec */
8+
#endif
9+
10+
#ifndef CODEL_EXCEED_INTERVAL
11+
#define CODEL_EXCEED_INTERVAL (100 * 1000 * 1000ULL) /* 100 ms in ns*/
12+
#endif
13+
14+
/* Codel like dropping scheme, inspired by:
15+
* - RFC: https://queue.acm.org/detail.cfm?id=2209336
16+
* - Code: https://queue.acm.org/appendices/codel.html
17+
* - Kernel: include/net/codel_impl.h
18+
*/
19+
struct codel_state {
20+
/* codel like dropping scheme */
21+
__u64 first_above_time; /* Time when above target (0 if below)*/
22+
__u64 drop_next; /* Time to drop next packet */
23+
__u32 count; /* Packets dropped since going into drop state */
24+
__u32 dropping; /* Equal to 1 if in drop state */
25+
};
26+
27+
/* Table lookup for square-root shifted 16 bit */
28+
static __always_inline __u32 get_sqrt_sh16(__u64 cnt)
29+
{
30+
switch (cnt) {
31+
case 1: return 65536; /* 65536 * sqrt(1) */
32+
case 2: return 92682; /* 65536 * sqrt(2) */
33+
case 3: return 113512; /* 65536 * sqrt(3) */
34+
case 4: return 131072; /* 65536 * sqrt(4) */
35+
case 5: return 146543; /* 65536 * sqrt(5) */
36+
case 6: return 160530; /* 65536 * sqrt(6) */
37+
case 7: return 173392;
38+
case 8: return 185364;
39+
case 9: return 196608;
40+
case 10: return 207243;
41+
case 11: return 217358;
42+
case 12: return 227023;
43+
case 13: return 236293;
44+
case 14: return 245213;
45+
case 15: return 253820;
46+
case 16: return 262144; /* 100 ms / sqrt(16) = 25 ms */
47+
case 17: return 270212;
48+
case 18: return 278046;
49+
case 19: return 285664;
50+
case 20: return 293086;
51+
case 21: return 300324;
52+
case 22: return 307391;
53+
case 23: return 314300;
54+
case 24: return 321060;
55+
case 25: return 327680; /* 100 ms / sqrt(25) = 20 ms */
56+
case 26: return 334169;
57+
case 27: return 340535;
58+
case 28: return 346784;
59+
case 29: return 352922;
60+
case 30: return 358955;
61+
case 31: return 364889;
62+
case 32: return 370728;
63+
case 33: return 376476;
64+
case 34: return 382137;
65+
case 35: return 387716;
66+
case 36: return 393216; /* 100 / sqrt(36) = 16.66 ms */
67+
default:
68+
return 463410; /* 65536*sqrt(50) => 100/sqrt(50) = 14.14 ms */
69+
}
70+
}
71+
72+
static __always_inline __u64 get_next_interval_sqrt(__u64 cnt)
73+
{
74+
__u64 val = ((__u64)CODEL_EXCEED_INTERVAL << 16) / get_sqrt_sh16(cnt);
75+
return val;
76+
}
77+
78+
static __always_inline __u64
79+
codel_control_law(__u64 t, __u64 cnt)
80+
{
81+
return t + get_next_interval_sqrt(cnt);
82+
}
83+
84+
static __always_inline
85+
bool codel_should_drop(struct codel_state *codel, __u64 t_queue_sz, __u64 now)
86+
{
87+
__u64 interval = CODEL_EXCEED_INTERVAL;
88+
89+
if (t_queue_sz < CODEL_TARGET) {
90+
/* went below so we'll stay below for at least interval */
91+
codel->first_above_time = 0;
92+
return false;
93+
}
94+
95+
if (codel->first_above_time == 0) {
96+
/* just went above from below. If we stay above
97+
* for at least interval we'll say it's ok to drop
98+
*/
99+
codel->first_above_time = now + interval;
100+
return false;
101+
} else if (now >= codel->first_above_time) {
102+
return true;
103+
}
104+
return false;
105+
}
106+
107+
static __always_inline
108+
bool codel_drop(struct codel_state *codel, __u64 t_queue_sz, __u64 now)
109+
{
110+
__u64 interval = CODEL_EXCEED_INTERVAL;
111+
112+
/* If horizon have been exceed for a while, inc drop intensity*/
113+
bool drop = codel_should_drop(codel, t_queue_sz, now);
114+
115+
if (codel->dropping) { /* In dropping state */
116+
if (!drop) {
117+
/* time below target - leave dropping state */
118+
codel->dropping = false;
119+
return false;
120+
} else if (now >= codel->drop_next) {
121+
/* It's time for the next drop. Drop the current
122+
* packet. Schedule the next drop
123+
*/
124+
codel->count += 1;
125+
// schedule the next drop.
126+
codel->drop_next =
127+
codel_control_law(codel->drop_next, codel->count);
128+
return true;
129+
}
130+
} else if (drop &&
131+
((now - codel->drop_next < interval) ||
132+
(now - codel->first_above_time >= interval))) {
133+
/* If we get here, then we're not in dropping state.
134+
* Decide whether it's time to enter dropping state.
135+
*/
136+
__u32 count = codel->count;
137+
138+
codel->dropping = true;
139+
140+
/* If we're in a drop cycle, drop rate that controlled queue
141+
* on the last cycle is a good starting point to control it now.
142+
*/
143+
if (now - codel->drop_next < interval)
144+
count = count > 2 ? (count - 2) : 1;
145+
else
146+
count = 1;
147+
148+
codel->count = count;
149+
codel->drop_next = codel_control_law(now, count);
150+
return true;
151+
}
152+
return false;
153+
}
154+
155+
#endif /* __CODEL_IMPL_H */

‎xdq-tester/fifo.lua

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
-- SPDX-License-Identifier: GPL-2.0
2+
-- Copyright (c) 2022 Freysteinn Alfredsson <freysteinn@freysteinn.com>
3+
4+
-- FIFO scheduler
5+
config.bpf.file = "./sched_fifo.bpf.o"
6+
7+
-- Setup flows
8+
packet_flow1 = Udp:new()
9+
packet_flow1.udp.dest = 8080
10+
11+
packet_flow2 = Udp:new()
12+
packet_flow2.udp.dest = 8081
13+
14+
packet_flow3 = Udp:new()
15+
packet_flow3.udp.dest = 8082
16+
17+
18+
-- Test scheduler
19+
enqueue(packet_flow1)
20+
enqueue(packet_flow2)
21+
enqueue(packet_flow3)
22+
23+
dequeue_cmp(packet_flow1)
24+
dequeue_cmp(packet_flow2)
25+
dequeue_cmp(packet_flow3)

0 commit comments

Comments
 (0)