mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Toke Høiland-Jørgensen](/assets/img/avatar_default.png)
Fix all files in samples/bpf to include libbpf header files with the bpf/
prefix, to be consistent with external users of the library. Also ensure
that all includes of exported libbpf header files (those that are exported
on 'make install' of the library) use bracketed includes instead of quoted.
To make sure no new files are introduced that doesn't include the bpf/
prefix in its include, remove tools/lib/bpf from the include path entirely,
and use tools/lib instead.
Fixes: 6910d7d386
("selftests/bpf: Ensure bpf_helper_defs.h are taken from selftests dir")
Signed-off-by: Toke Høiland-Jørgensen <toke@redhat.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Jesper Dangaard Brouer <brouer@redhat.com>
Acked-by: Andrii Nakryiko <andriin@fb.com>
Link: https://lore.kernel.org/bpf/157952560911.1683545.8795966751309534150.stgit@toke.dk
155 lines
3.8 KiB
C
155 lines
3.8 KiB
C
/* SPDX-License-Identifier: GPL-2.0
|
|
* Copyright (c) 2018 Facebook
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
* License as published by the Free Software Foundation.
|
|
*
|
|
* This program shows how to use bpf_xdp_adjust_tail() by
|
|
* generating ICMPv4 "packet to big" (unreachable/ df bit set frag needed
|
|
* to be more preice in case of v4)" where receiving packets bigger then
|
|
* 600 bytes.
|
|
*/
|
|
#define KBUILD_MODNAME "foo"
|
|
#include <uapi/linux/bpf.h>
|
|
#include <linux/in.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/if_packet.h>
|
|
#include <linux/if_vlan.h>
|
|
#include <linux/ip.h>
|
|
#include <linux/icmp.h>
|
|
#include <bpf/bpf_helpers.h>
|
|
|
|
#define DEFAULT_TTL 64
|
|
#define MAX_PCKT_SIZE 600
|
|
#define ICMP_TOOBIG_SIZE 98
|
|
#define ICMP_TOOBIG_PAYLOAD_SIZE 92
|
|
|
|
/* volatile to prevent compiler optimizations */
|
|
static volatile __u32 max_pcktsz = MAX_PCKT_SIZE;
|
|
|
|
struct {
|
|
__uint(type, BPF_MAP_TYPE_ARRAY);
|
|
__type(key, __u32);
|
|
__type(value, __u64);
|
|
__uint(max_entries, 1);
|
|
} icmpcnt SEC(".maps");
|
|
|
|
static __always_inline void count_icmp(void)
|
|
{
|
|
u64 key = 0;
|
|
u64 *icmp_count;
|
|
|
|
icmp_count = bpf_map_lookup_elem(&icmpcnt, &key);
|
|
if (icmp_count)
|
|
*icmp_count += 1;
|
|
}
|
|
|
|
static __always_inline void swap_mac(void *data, struct ethhdr *orig_eth)
|
|
{
|
|
struct ethhdr *eth;
|
|
|
|
eth = data;
|
|
memcpy(eth->h_source, orig_eth->h_dest, ETH_ALEN);
|
|
memcpy(eth->h_dest, orig_eth->h_source, ETH_ALEN);
|
|
eth->h_proto = orig_eth->h_proto;
|
|
}
|
|
|
|
static __always_inline __u16 csum_fold_helper(__u32 csum)
|
|
{
|
|
return ~((csum & 0xffff) + (csum >> 16));
|
|
}
|
|
|
|
static __always_inline void ipv4_csum(void *data_start, int data_size,
|
|
__u32 *csum)
|
|
{
|
|
*csum = bpf_csum_diff(0, 0, data_start, data_size, *csum);
|
|
*csum = csum_fold_helper(*csum);
|
|
}
|
|
|
|
static __always_inline int send_icmp4_too_big(struct xdp_md *xdp)
|
|
{
|
|
int headroom = (int)sizeof(struct iphdr) + (int)sizeof(struct icmphdr);
|
|
|
|
if (bpf_xdp_adjust_head(xdp, 0 - headroom))
|
|
return XDP_DROP;
|
|
void *data = (void *)(long)xdp->data;
|
|
void *data_end = (void *)(long)xdp->data_end;
|
|
|
|
if (data + (ICMP_TOOBIG_SIZE + headroom) > data_end)
|
|
return XDP_DROP;
|
|
|
|
struct iphdr *iph, *orig_iph;
|
|
struct icmphdr *icmp_hdr;
|
|
struct ethhdr *orig_eth;
|
|
__u32 csum = 0;
|
|
__u64 off = 0;
|
|
|
|
orig_eth = data + headroom;
|
|
swap_mac(data, orig_eth);
|
|
off += sizeof(struct ethhdr);
|
|
iph = data + off;
|
|
off += sizeof(struct iphdr);
|
|
icmp_hdr = data + off;
|
|
off += sizeof(struct icmphdr);
|
|
orig_iph = data + off;
|
|
icmp_hdr->type = ICMP_DEST_UNREACH;
|
|
icmp_hdr->code = ICMP_FRAG_NEEDED;
|
|
icmp_hdr->un.frag.mtu = htons(max_pcktsz - sizeof(struct ethhdr));
|
|
icmp_hdr->checksum = 0;
|
|
ipv4_csum(icmp_hdr, ICMP_TOOBIG_PAYLOAD_SIZE, &csum);
|
|
icmp_hdr->checksum = csum;
|
|
iph->ttl = DEFAULT_TTL;
|
|
iph->daddr = orig_iph->saddr;
|
|
iph->saddr = orig_iph->daddr;
|
|
iph->version = 4;
|
|
iph->ihl = 5;
|
|
iph->protocol = IPPROTO_ICMP;
|
|
iph->tos = 0;
|
|
iph->tot_len = htons(
|
|
ICMP_TOOBIG_SIZE + headroom - sizeof(struct ethhdr));
|
|
iph->check = 0;
|
|
csum = 0;
|
|
ipv4_csum(iph, sizeof(struct iphdr), &csum);
|
|
iph->check = csum;
|
|
count_icmp();
|
|
return XDP_TX;
|
|
}
|
|
|
|
|
|
static __always_inline int handle_ipv4(struct xdp_md *xdp)
|
|
{
|
|
void *data_end = (void *)(long)xdp->data_end;
|
|
void *data = (void *)(long)xdp->data;
|
|
int pckt_size = data_end - data;
|
|
int offset;
|
|
|
|
if (pckt_size > max(max_pcktsz, ICMP_TOOBIG_SIZE)) {
|
|
offset = pckt_size - ICMP_TOOBIG_SIZE;
|
|
if (bpf_xdp_adjust_tail(xdp, 0 - offset))
|
|
return XDP_PASS;
|
|
return send_icmp4_too_big(xdp);
|
|
}
|
|
return XDP_PASS;
|
|
}
|
|
|
|
SEC("xdp_icmp")
|
|
int _xdp_icmp(struct xdp_md *xdp)
|
|
{
|
|
void *data_end = (void *)(long)xdp->data_end;
|
|
void *data = (void *)(long)xdp->data;
|
|
struct ethhdr *eth = data;
|
|
__u16 h_proto;
|
|
|
|
if (eth + 1 > data_end)
|
|
return XDP_DROP;
|
|
|
|
h_proto = eth->h_proto;
|
|
|
|
if (h_proto == htons(ETH_P_IP))
|
|
return handle_ipv4(xdp);
|
|
else
|
|
return XDP_PASS;
|
|
}
|
|
|
|
char _license[] SEC("license") = "GPL";
|