~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/samples/bpf/sockex2_kern.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <uapi/linux/bpf.h>
  2 #include <uapi/linux/in.h>
  3 #include <uapi/linux/if.h>
  4 #include <uapi/linux/if_ether.h>
  5 #include <uapi/linux/ip.h>
  6 #include <uapi/linux/ipv6.h>
  7 #include <uapi/linux/if_tunnel.h>
  8 #include <bpf/bpf_helpers.h>
  9 #include "bpf_legacy.h"
 10 #define IP_MF           0x2000
 11 #define IP_OFFSET       0x1FFF
 12 
 13 struct vlan_hdr {
 14         __be16 h_vlan_TCI;
 15         __be16 h_vlan_encapsulated_proto;
 16 };
 17 
 18 struct flow_key_record {
 19         __be32 src;
 20         __be32 dst;
 21         union {
 22                 __be32 ports;
 23                 __be16 port16[2];
 24         };
 25         __u16 thoff;
 26         __u8 ip_proto;
 27 };
 28 
 29 static inline int proto_ports_offset(__u64 proto)
 30 {
 31         switch (proto) {
 32         case IPPROTO_TCP:
 33         case IPPROTO_UDP:
 34         case IPPROTO_DCCP:
 35         case IPPROTO_ESP:
 36         case IPPROTO_SCTP:
 37         case IPPROTO_UDPLITE:
 38                 return 0;
 39         case IPPROTO_AH:
 40                 return 4;
 41         default:
 42                 return 0;
 43         }
 44 }
 45 
 46 static inline int ip_is_fragment(struct __sk_buff *ctx, __u64 nhoff)
 47 {
 48         return load_half(ctx, nhoff + offsetof(struct iphdr, frag_off))
 49                 & (IP_MF | IP_OFFSET);
 50 }
 51 
 52 static inline __u32 ipv6_addr_hash(struct __sk_buff *ctx, __u64 off)
 53 {
 54         __u64 w0 = load_word(ctx, off);
 55         __u64 w1 = load_word(ctx, off + 4);
 56         __u64 w2 = load_word(ctx, off + 8);
 57         __u64 w3 = load_word(ctx, off + 12);
 58 
 59         return (__u32)(w0 ^ w1 ^ w2 ^ w3);
 60 }
 61 
 62 static inline __u64 parse_ip(struct __sk_buff *skb, __u64 nhoff, __u64 *ip_proto,
 63                              struct flow_key_record *flow)
 64 {
 65         __u64 verlen;
 66 
 67         if (unlikely(ip_is_fragment(skb, nhoff)))
 68                 *ip_proto = 0;
 69         else
 70                 *ip_proto = load_byte(skb, nhoff + offsetof(struct iphdr, protocol));
 71 
 72         if (*ip_proto != IPPROTO_GRE) {
 73                 flow->src = load_word(skb, nhoff + offsetof(struct iphdr, saddr));
 74                 flow->dst = load_word(skb, nhoff + offsetof(struct iphdr, daddr));
 75         }
 76 
 77         verlen = load_byte(skb, nhoff + 0/*offsetof(struct iphdr, ihl)*/);
 78         if (likely(verlen == 0x45))
 79                 nhoff += 20;
 80         else
 81                 nhoff += (verlen & 0xF) << 2;
 82 
 83         return nhoff;
 84 }
 85 
 86 static inline __u64 parse_ipv6(struct __sk_buff *skb, __u64 nhoff, __u64 *ip_proto,
 87                                struct flow_key_record *flow)
 88 {
 89         *ip_proto = load_byte(skb,
 90                               nhoff + offsetof(struct ipv6hdr, nexthdr));
 91         flow->src = ipv6_addr_hash(skb,
 92                                    nhoff + offsetof(struct ipv6hdr, saddr));
 93         flow->dst = ipv6_addr_hash(skb,
 94                                    nhoff + offsetof(struct ipv6hdr, daddr));
 95         nhoff += sizeof(struct ipv6hdr);
 96 
 97         return nhoff;
 98 }
 99 
100 static inline bool flow_dissector(struct __sk_buff *skb,
101                                   struct flow_key_record *flow)
102 {
103         __u64 nhoff = ETH_HLEN;
104         __u64 ip_proto;
105         __u64 proto = load_half(skb, 12);
106         int poff;
107 
108         if (proto == ETH_P_8021AD) {
109                 proto = load_half(skb, nhoff + offsetof(struct vlan_hdr,
110                                                         h_vlan_encapsulated_proto));
111                 nhoff += sizeof(struct vlan_hdr);
112         }
113 
114         if (proto == ETH_P_8021Q) {
115                 proto = load_half(skb, nhoff + offsetof(struct vlan_hdr,
116                                                         h_vlan_encapsulated_proto));
117                 nhoff += sizeof(struct vlan_hdr);
118         }
119 
120         if (likely(proto == ETH_P_IP))
121                 nhoff = parse_ip(skb, nhoff, &ip_proto, flow);
122         else if (proto == ETH_P_IPV6)
123                 nhoff = parse_ipv6(skb, nhoff, &ip_proto, flow);
124         else
125                 return false;
126 
127         switch (ip_proto) {
128         case IPPROTO_GRE: {
129                 struct gre_hdr {
130                         __be16 flags;
131                         __be16 proto;
132                 };
133 
134                 __u64 gre_flags = load_half(skb,
135                                             nhoff + offsetof(struct gre_hdr, flags));
136                 __u64 gre_proto = load_half(skb,
137                                             nhoff + offsetof(struct gre_hdr, proto));
138 
139                 if (gre_flags & (GRE_VERSION|GRE_ROUTING))
140                         break;
141 
142                 proto = gre_proto;
143                 nhoff += 4;
144                 if (gre_flags & GRE_CSUM)
145                         nhoff += 4;
146                 if (gre_flags & GRE_KEY)
147                         nhoff += 4;
148                 if (gre_flags & GRE_SEQ)
149                         nhoff += 4;
150 
151                 if (proto == ETH_P_8021Q) {
152                         proto = load_half(skb,
153                                           nhoff + offsetof(struct vlan_hdr,
154                                                            h_vlan_encapsulated_proto));
155                         nhoff += sizeof(struct vlan_hdr);
156                 }
157 
158                 if (proto == ETH_P_IP)
159                         nhoff = parse_ip(skb, nhoff, &ip_proto, flow);
160                 else if (proto == ETH_P_IPV6)
161                         nhoff = parse_ipv6(skb, nhoff, &ip_proto, flow);
162                 else
163                         return false;
164                 break;
165         }
166         case IPPROTO_IPIP:
167                 nhoff = parse_ip(skb, nhoff, &ip_proto, flow);
168                 break;
169         case IPPROTO_IPV6:
170                 nhoff = parse_ipv6(skb, nhoff, &ip_proto, flow);
171                 break;
172         default:
173                 break;
174         }
175 
176         flow->ip_proto = ip_proto;
177         poff = proto_ports_offset(ip_proto);
178         if (poff >= 0) {
179                 nhoff += poff;
180                 flow->ports = load_word(skb, nhoff);
181         }
182 
183         flow->thoff = (__u16) nhoff;
184 
185         return true;
186 }
187 
188 struct pair {
189         long packets;
190         long bytes;
191 };
192 
193 struct {
194         __uint(type, BPF_MAP_TYPE_HASH);
195         __type(key, __be32);
196         __type(value, struct pair);
197         __uint(max_entries, 1024);
198 } hash_map SEC(".maps");
199 
200 SEC("socket2")
201 int bpf_prog2(struct __sk_buff *skb)
202 {
203         struct flow_key_record flow = {};
204         struct pair *value;
205         u32 key;
206 
207         if (!flow_dissector(skb, &flow))
208                 return 0;
209 
210         key = flow.dst;
211         value = bpf_map_lookup_elem(&hash_map, &key);
212         if (value) {
213                 __sync_fetch_and_add(&value->packets, 1);
214                 __sync_fetch_and_add(&value->bytes, skb->len);
215         } else {
216                 struct pair val = {1, skb->len};
217 
218                 bpf_map_update_elem(&hash_map, &key, &val, BPF_ANY);
219         }
220         return 0;
221 }
222 
223 char _license[] SEC("license") = "GPL";
224 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp