test_select_reuseport_kern.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2018 Facebook */
  3
  4#include <linux/in.h>
  5#include <linux/ip.h>
  6#include <linux/ipv6.h>
  7#include <linux/tcp.h>
  8#include <linux/udp.h>
  9#include <linux/bpf.h>
 10#include <linux/types.h>
 11#include <linux/if_ether.h>
 12
 13#include <bpf/bpf_endian.h>
 14#include <bpf/bpf_helpers.h>
 15#include "test_select_reuseport_common.h"
 16
 17#ifndef offsetof
 18#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 19#endif
 20
 21struct {
 22	__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
 23	__uint(max_entries, 1);
 24	__type(key, __u32);
 25	__type(value, __u32);
 26} outer_map SEC(".maps");
 27
 28struct {
 29	__uint(type, BPF_MAP_TYPE_ARRAY);
 30	__uint(max_entries, NR_RESULTS);
 31	__type(key, __u32);
 32	__type(value, __u32);
 33} result_map SEC(".maps");
 34
 35struct {
 36	__uint(type, BPF_MAP_TYPE_ARRAY);
 37	__uint(max_entries, 1);
 38	__type(key, __u32);
 39	__type(value, int);
 40} tmp_index_ovr_map SEC(".maps");
 41
 42struct {
 43	__uint(type, BPF_MAP_TYPE_ARRAY);
 44	__uint(max_entries, 1);
 45	__type(key, __u32);
 46	__type(value, __u32);
 47} linum_map SEC(".maps");
 48
 49struct {
 50	__uint(type, BPF_MAP_TYPE_ARRAY);
 51	__uint(max_entries, 1);
 52	__type(key, __u32);
 53	__type(value, struct data_check);
 54} data_check_map SEC(".maps");
 55
 56#define GOTO_DONE(_result) ({			\
 57	result = (_result);			\
 58	linum = __LINE__;			\
 59	goto done;				\
 60})
 61
 62SEC("sk_reuseport")
 63int _select_by_skb_data(struct sk_reuseport_md *reuse_md)
 64{
 65	__u32 linum, index = 0, flags = 0, index_zero = 0;
 66	__u32 *result_cnt;
 67	struct data_check data_check = {};
 68	struct cmd *cmd, cmd_copy;
 69	void *data, *data_end;
 70	void *reuseport_array;
 71	enum result result;
 72	int *index_ovr;
 73	int err;
 74
 75	data = reuse_md->data;
 76	data_end = reuse_md->data_end;
 77	data_check.len = reuse_md->len;
 78	data_check.eth_protocol = reuse_md->eth_protocol;
 79	data_check.ip_protocol = reuse_md->ip_protocol;
 80	data_check.hash = reuse_md->hash;
 81	data_check.bind_inany = reuse_md->bind_inany;
 82	if (data_check.eth_protocol == bpf_htons(ETH_P_IP)) {
 83		if (bpf_skb_load_bytes_relative(reuse_md,
 84						offsetof(struct iphdr, saddr),
 85						data_check.skb_addrs, 8,
 86						BPF_HDR_START_NET))
 87			GOTO_DONE(DROP_MISC);
 88	} else {
 89		if (bpf_skb_load_bytes_relative(reuse_md,
 90						offsetof(struct ipv6hdr, saddr),
 91						data_check.skb_addrs, 32,
 92						BPF_HDR_START_NET))
 93			GOTO_DONE(DROP_MISC);
 94	}
 95
 96	/*
 97	 * The ip_protocol could be a compile time decision
 98	 * if the bpf_prog.o is dedicated to either TCP or
 99	 * UDP.
100	 *
101	 * Otherwise, reuse_md->ip_protocol or
102	 * the protocol field in the iphdr can be used.
103	 */
104	if (data_check.ip_protocol == IPPROTO_TCP) {
105		struct tcphdr *th = data;
106
107		if (th + 1 > data_end)
108			GOTO_DONE(DROP_MISC);
109
110		data_check.skb_ports[0] = th->source;
111		data_check.skb_ports[1] = th->dest;
112
113		if (th->fin)
114			/* The connection is being torn down at the end of a
115			 * test. It can't contain a cmd, so return early.
116			 */
117			return SK_PASS;
118
119		if ((th->doff << 2) + sizeof(*cmd) > data_check.len)
120			GOTO_DONE(DROP_ERR_SKB_DATA);
121		if (bpf_skb_load_bytes(reuse_md, th->doff << 2, &cmd_copy,
122				       sizeof(cmd_copy)))
123			GOTO_DONE(DROP_MISC);
124		cmd = &cmd_copy;
125	} else if (data_check.ip_protocol == IPPROTO_UDP) {
126		struct udphdr *uh = data;
127
128		if (uh + 1 > data_end)
129			GOTO_DONE(DROP_MISC);
130
131		data_check.skb_ports[0] = uh->source;
132		data_check.skb_ports[1] = uh->dest;
133
134		if (sizeof(struct udphdr) + sizeof(*cmd) > data_check.len)
135			GOTO_DONE(DROP_ERR_SKB_DATA);
136		if (data + sizeof(struct udphdr) + sizeof(*cmd) > data_end) {
137			if (bpf_skb_load_bytes(reuse_md, sizeof(struct udphdr),
138					       &cmd_copy, sizeof(cmd_copy)))
139				GOTO_DONE(DROP_MISC);
140			cmd = &cmd_copy;
141		} else {
142			cmd = data + sizeof(struct udphdr);
143		}
144	} else {
145		GOTO_DONE(DROP_MISC);
146	}
147
148	reuseport_array = bpf_map_lookup_elem(&outer_map, &index_zero);
149	if (!reuseport_array)
150		GOTO_DONE(DROP_ERR_INNER_MAP);
151
152	index = cmd->reuseport_index;
153	index_ovr = bpf_map_lookup_elem(&tmp_index_ovr_map, &index_zero);
154	if (!index_ovr)
155		GOTO_DONE(DROP_MISC);
156
157	if (*index_ovr != -1) {
158		index = *index_ovr;
159		*index_ovr = -1;
160	}
161	err = bpf_sk_select_reuseport(reuse_md, reuseport_array, &index,
162				      flags);
163	if (!err)
164		GOTO_DONE(PASS);
165
166	if (cmd->pass_on_failure)
167		GOTO_DONE(PASS_ERR_SK_SELECT_REUSEPORT);
168	else
169		GOTO_DONE(DROP_ERR_SK_SELECT_REUSEPORT);
170
171done:
172	result_cnt = bpf_map_lookup_elem(&result_map, &result);
173	if (!result_cnt)
174		return SK_DROP;
175
176	bpf_map_update_elem(&linum_map, &index_zero, &linum, BPF_ANY);
177	bpf_map_update_elem(&data_check_map, &index_zero, &data_check, BPF_ANY);
178
179	(*result_cnt)++;
180	return result < PASS ? SK_DROP : SK_PASS;
181}
182
183char _license[] SEC("license") = "GPL";