• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of version 2 of the GNU General Public
6  * License as published by the Free Software Foundation.
7  */
8 #ifndef __LINUX_BPF_H__
9 #define __LINUX_BPF_H__
10 
11 #include <linux/types.h>
12 #include <linux/bpf_common.h>
13 
14 /* Extended instruction set based on top of classic BPF */
15 
16 /* instruction classes */
17 #define BPF_ALU64	0x07	/* alu mode in double word width */
18 
19 /* ld/ldx fields */
20 #define BPF_DW		0x18	/* double word */
21 #define BPF_XADD	0xc0	/* exclusive add */
22 
23 /* alu/jmp fields */
24 #define BPF_MOV		0xb0	/* mov reg to reg */
25 #define BPF_ARSH	0xc0	/* sign extending arithmetic shift right */
26 
27 /* change endianness of a register */
28 #define BPF_END		0xd0	/* flags for endianness conversion: */
29 #define BPF_TO_LE	0x00	/* convert to little-endian */
30 #define BPF_TO_BE	0x08	/* convert to big-endian */
31 #define BPF_FROM_LE	BPF_TO_LE
32 #define BPF_FROM_BE	BPF_TO_BE
33 
34 /* jmp encodings */
35 #define BPF_JNE		0x50	/* jump != */
36 #define BPF_JLT		0xa0	/* LT is unsigned, '<' */
37 #define BPF_JLE		0xb0	/* LE is unsigned, '<=' */
38 #define BPF_JSGT	0x60	/* SGT is signed '>', GT in x86 */
39 #define BPF_JSGE	0x70	/* SGE is signed '>=', GE in x86 */
40 #define BPF_JSLT	0xc0	/* SLT is signed, '<' */
41 #define BPF_JSLE	0xd0	/* SLE is signed, '<=' */
42 #define BPF_CALL	0x80	/* function call */
43 #define BPF_EXIT	0x90	/* function return */
44 
45 /* Register numbers */
46 enum {
47 	BPF_REG_0 = 0,
48 	BPF_REG_1,
49 	BPF_REG_2,
50 	BPF_REG_3,
51 	BPF_REG_4,
52 	BPF_REG_5,
53 	BPF_REG_6,
54 	BPF_REG_7,
55 	BPF_REG_8,
56 	BPF_REG_9,
57 	BPF_REG_10,
58 	__MAX_BPF_REG,
59 };
60 
61 /* BPF has 10 general purpose 64-bit registers and stack frame. */
62 #define MAX_BPF_REG	__MAX_BPF_REG
63 
64 struct bpf_insn {
65 	__u8	code;		/* opcode */
66 	__u8	dst_reg:4;	/* dest register */
67 	__u8	src_reg:4;	/* source register */
68 	__s16	off;		/* signed offset */
69 	__s32	imm;		/* signed immediate constant */
70 };
71 
72 /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */
73 struct bpf_lpm_trie_key {
74 	__u32	prefixlen;	/* up to 32 for AF_INET, 128 for AF_INET6 */
75 	__u8	data[0];	/* Arbitrary size */
76 };
77 
78 /* BPF syscall commands, see bpf(2) man-page for details. */
79 enum bpf_cmd {
80 	BPF_MAP_CREATE,
81 	BPF_MAP_LOOKUP_ELEM,
82 	BPF_MAP_UPDATE_ELEM,
83 	BPF_MAP_DELETE_ELEM,
84 	BPF_MAP_GET_NEXT_KEY,
85 	BPF_PROG_LOAD,
86 	BPF_OBJ_PIN,
87 	BPF_OBJ_GET,
88 	BPF_PROG_ATTACH,
89 	BPF_PROG_DETACH,
90 	BPF_PROG_TEST_RUN,
91 	BPF_PROG_GET_NEXT_ID,
92 	BPF_MAP_GET_NEXT_ID,
93 	BPF_PROG_GET_FD_BY_ID,
94 	BPF_MAP_GET_FD_BY_ID,
95 	BPF_OBJ_GET_INFO_BY_FD,
96 };
97 
98 enum bpf_map_type {
99 	BPF_MAP_TYPE_UNSPEC,
100 	BPF_MAP_TYPE_HASH,
101 	BPF_MAP_TYPE_ARRAY,
102 	BPF_MAP_TYPE_PROG_ARRAY,
103 	BPF_MAP_TYPE_PERF_EVENT_ARRAY,
104 	BPF_MAP_TYPE_PERCPU_HASH,
105 	BPF_MAP_TYPE_PERCPU_ARRAY,
106 	BPF_MAP_TYPE_STACK_TRACE,
107 	BPF_MAP_TYPE_CGROUP_ARRAY,
108 	BPF_MAP_TYPE_LRU_HASH,
109 	BPF_MAP_TYPE_LRU_PERCPU_HASH,
110 	BPF_MAP_TYPE_LPM_TRIE,
111 	BPF_MAP_TYPE_ARRAY_OF_MAPS,
112 	BPF_MAP_TYPE_HASH_OF_MAPS,
113 	BPF_MAP_TYPE_DEVMAP,
114 	BPF_MAP_TYPE_SOCKMAP,
115 };
116 
117 enum bpf_prog_type {
118 	BPF_PROG_TYPE_UNSPEC,
119 	BPF_PROG_TYPE_SOCKET_FILTER,
120 	BPF_PROG_TYPE_KPROBE,
121 	BPF_PROG_TYPE_SCHED_CLS,
122 	BPF_PROG_TYPE_SCHED_ACT,
123 	BPF_PROG_TYPE_TRACEPOINT,
124 	BPF_PROG_TYPE_XDP,
125 	BPF_PROG_TYPE_PERF_EVENT,
126 	BPF_PROG_TYPE_CGROUP_SKB,
127 	BPF_PROG_TYPE_CGROUP_SOCK,
128 	BPF_PROG_TYPE_LWT_IN,
129 	BPF_PROG_TYPE_LWT_OUT,
130 	BPF_PROG_TYPE_LWT_XMIT,
131 	BPF_PROG_TYPE_SOCK_OPS,
132 	BPF_PROG_TYPE_SK_SKB,
133 };
134 
135 enum bpf_attach_type {
136 	BPF_CGROUP_INET_INGRESS,
137 	BPF_CGROUP_INET_EGRESS,
138 	BPF_CGROUP_INET_SOCK_CREATE,
139 	BPF_CGROUP_SOCK_OPS,
140 	BPF_SK_SKB_STREAM_PARSER,
141 	BPF_SK_SKB_STREAM_VERDICT,
142 	__MAX_BPF_ATTACH_TYPE
143 };
144 
145 #define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE
146 
147 /* If BPF_F_ALLOW_OVERRIDE flag is used in BPF_PROG_ATTACH command
148  * to the given target_fd cgroup the descendent cgroup will be able to
149  * override effective bpf program that was inherited from this cgroup
150  */
151 #define BPF_F_ALLOW_OVERRIDE	(1U << 0)
152 
153 /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the
154  * verifier will perform strict alignment checking as if the kernel
155  * has been built with CONFIG_EFFICIENT_UNALIGNED_ACCESS not set,
156  * and NET_IP_ALIGN defined to 2.
157  */
158 #define BPF_F_STRICT_ALIGNMENT	(1U << 0)
159 
160 #define BPF_PSEUDO_MAP_FD	1
161 
162 /* flags for BPF_MAP_UPDATE_ELEM command */
163 #define BPF_ANY		0 /* create new element or update existing */
164 #define BPF_NOEXIST	1 /* create new element if it didn't exist */
165 #define BPF_EXIST	2 /* update existing element */
166 
167 /* flags for BPF_MAP_CREATE command */
168 #define BPF_F_NO_PREALLOC	(1U << 0)
169 /* Instead of having one common LRU list in the
170  * BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list
171  * which can scale and perform better.
172  * Note, the LRU nodes (including free nodes) cannot be moved
173  * across different LRU lists.
174  */
175 #define BPF_F_NO_COMMON_LRU	(1U << 1)
176 /* Specify numa node during map creation */
177 #define BPF_F_NUMA_NODE		(1U << 2)
178 
179 union bpf_attr {
180 	struct { /* anonymous struct used by BPF_MAP_CREATE command */
181 		__u32	map_type;	/* one of enum bpf_map_type */
182 		__u32	key_size;	/* size of key in bytes */
183 		__u32	value_size;	/* size of value in bytes */
184 		__u32	max_entries;	/* max number of entries in a map */
185 		__u32	map_flags;	/* BPF_MAP_CREATE related
186 					 * flags defined above.
187 					 */
188 		__u32	inner_map_fd;	/* fd pointing to the inner map */
189 		__u32	numa_node;	/* numa node (effective only if
190 					 * BPF_F_NUMA_NODE is set).
191 					 */
192 	};
193 
194 	struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
195 		__u32		map_fd;
196 		__aligned_u64	key;
197 		union {
198 			__aligned_u64 value;
199 			__aligned_u64 next_key;
200 		};
201 		__u64		flags;
202 	};
203 
204 	struct { /* anonymous struct used by BPF_PROG_LOAD command */
205 		__u32		prog_type;	/* one of enum bpf_prog_type */
206 		__u32		insn_cnt;
207 		__aligned_u64	insns;
208 		__aligned_u64	license;
209 		__u32		log_level;	/* verbosity level of verifier */
210 		__u32		log_size;	/* size of user buffer */
211 		__aligned_u64	log_buf;	/* user supplied buffer */
212 		__u32		kern_version;	/* checked when prog_type=kprobe */
213 		__u32		prog_flags;
214 	};
215 
216 	struct { /* anonymous struct used by BPF_OBJ_* commands */
217 		__aligned_u64	pathname;
218 		__u32		bpf_fd;
219 	};
220 
221 	struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */
222 		__u32		target_fd;	/* container object to attach to */
223 		__u32		attach_bpf_fd;	/* eBPF program to attach */
224 		__u32		attach_type;
225 		__u32		attach_flags;
226 	};
227 
228 	struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */
229 		__u32		prog_fd;
230 		__u32		retval;
231 		__u32		data_size_in;
232 		__u32		data_size_out;
233 		__aligned_u64	data_in;
234 		__aligned_u64	data_out;
235 		__u32		repeat;
236 		__u32		duration;
237 	} test;
238 
239 	struct { /* anonymous struct used by BPF_*_GET_*_ID */
240 		union {
241 			__u32		start_id;
242 			__u32		prog_id;
243 			__u32		map_id;
244 		};
245 		__u32		next_id;
246 	};
247 
248 	struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */
249 		__u32		bpf_fd;
250 		__u32		info_len;
251 		__aligned_u64	info;
252 	} info;
253 } __attribute__((aligned(8)));
254 
255 /* BPF helper function descriptions:
256  *
257  * void *bpf_map_lookup_elem(&map, &key)
258  *     Return: Map value or NULL
259  *
260  * int bpf_map_update_elem(&map, &key, &value, flags)
261  *     Return: 0 on success or negative error
262  *
263  * int bpf_map_delete_elem(&map, &key)
264  *     Return: 0 on success or negative error
265  *
266  * int bpf_probe_read(void *dst, int size, void *src)
267  *     Return: 0 on success or negative error
268  *
269  * u64 bpf_ktime_get_ns(void)
270  *     Return: current ktime
271  *
272  * int bpf_trace_printk(const char *fmt, int fmt_size, ...)
273  *     Return: length of buffer written or negative error
274  *
275  * u32 bpf_prandom_u32(void)
276  *     Return: random value
277  *
278  * u32 bpf_raw_smp_processor_id(void)
279  *     Return: SMP processor ID
280  *
281  * int bpf_skb_store_bytes(skb, offset, from, len, flags)
282  *     store bytes into packet
283  *     @skb: pointer to skb
284  *     @offset: offset within packet from skb->mac_header
285  *     @from: pointer where to copy bytes from
286  *     @len: number of bytes to store into packet
287  *     @flags: bit 0 - if true, recompute skb->csum
288  *             other bits - reserved
289  *     Return: 0 on success or negative error
290  *
291  * int bpf_l3_csum_replace(skb, offset, from, to, flags)
292  *     recompute IP checksum
293  *     @skb: pointer to skb
294  *     @offset: offset within packet where IP checksum is located
295  *     @from: old value of header field
296  *     @to: new value of header field
297  *     @flags: bits 0-3 - size of header field
298  *             other bits - reserved
299  *     Return: 0 on success or negative error
300  *
301  * int bpf_l4_csum_replace(skb, offset, from, to, flags)
302  *     recompute TCP/UDP checksum
303  *     @skb: pointer to skb
304  *     @offset: offset within packet where TCP/UDP checksum is located
305  *     @from: old value of header field
306  *     @to: new value of header field
307  *     @flags: bits 0-3 - size of header field
308  *             bit 4 - is pseudo header
309  *             other bits - reserved
310  *     Return: 0 on success or negative error
311  *
312  * int bpf_tail_call(ctx, prog_array_map, index)
313  *     jump into another BPF program
314  *     @ctx: context pointer passed to next program
315  *     @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY
316  *     @index: 32-bit index inside array that selects specific program to run
317  *     Return: 0 on success or negative error
318  *
319  * int bpf_clone_redirect(skb, ifindex, flags)
320  *     redirect to another netdev
321  *     @skb: pointer to skb
322  *     @ifindex: ifindex of the net device
323  *     @flags: bit 0 - if set, redirect to ingress instead of egress
324  *             other bits - reserved
325  *     Return: 0 on success or negative error
326  *
327  * u64 bpf_get_current_pid_tgid(void)
328  *     Return: current->tgid << 32 | current->pid
329  *
330  * u64 bpf_get_current_uid_gid(void)
331  *     Return: current_gid << 32 | current_uid
332  *
333  * int bpf_get_current_comm(char *buf, int size_of_buf)
334  *     stores current->comm into buf
335  *     Return: 0 on success or negative error
336  *
337  * u32 bpf_get_cgroup_classid(skb)
338  *     retrieve a proc's classid
339  *     @skb: pointer to skb
340  *     Return: classid if != 0
341  *
342  * int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci)
343  *     Return: 0 on success or negative error
344  *
345  * int bpf_skb_vlan_pop(skb)
346  *     Return: 0 on success or negative error
347  *
348  * int bpf_skb_get_tunnel_key(skb, key, size, flags)
349  * int bpf_skb_set_tunnel_key(skb, key, size, flags)
350  *     retrieve or populate tunnel metadata
351  *     @skb: pointer to skb
352  *     @key: pointer to 'struct bpf_tunnel_key'
353  *     @size: size of 'struct bpf_tunnel_key'
354  *     @flags: room for future extensions
355  *     Return: 0 on success or negative error
356  *
357  * u64 bpf_perf_event_read(map, flags)
358  *     read perf event counter value
359  *     @map: pointer to perf_event_array map
360  *     @flags: index of event in the map or bitmask flags
361  *     Return: value of perf event counter read or error code
362  *
363  * int bpf_redirect(ifindex, flags)
364  *     redirect to another netdev
365  *     @ifindex: ifindex of the net device
366  *     @flags:
367  *	  cls_bpf:
368  *          bit 0 - if set, redirect to ingress instead of egress
369  *          other bits - reserved
370  *	  xdp_bpf:
371  *	    all bits - reserved
372  *     Return: cls_bpf: TC_ACT_REDIRECT on success or TC_ACT_SHOT on error
373  *	       xdp_bfp: XDP_REDIRECT on success or XDP_ABORT on error
374  * int bpf_redirect_map(map, key, flags)
375  *     redirect to endpoint in map
376  *     @map: pointer to dev map
377  *     @key: index in map to lookup
378  *     @flags: --
379  *     Return: XDP_REDIRECT on success or XDP_ABORT on error
380  *
381  * u32 bpf_get_route_realm(skb)
382  *     retrieve a dst's tclassid
383  *     @skb: pointer to skb
384  *     Return: realm if != 0
385  *
386  * int bpf_perf_event_output(ctx, map, flags, data, size)
387  *     output perf raw sample
388  *     @ctx: struct pt_regs*
389  *     @map: pointer to perf_event_array map
390  *     @flags: index of event in the map or bitmask flags
391  *     @data: data on stack to be output as raw data
392  *     @size: size of data
393  *     Return: 0 on success or negative error
394  *
395  * int bpf_get_stackid(ctx, map, flags)
396  *     walk user or kernel stack and return id
397  *     @ctx: struct pt_regs*
398  *     @map: pointer to stack_trace map
399  *     @flags: bits 0-7 - numer of stack frames to skip
400  *             bit 8 - collect user stack instead of kernel
401  *             bit 9 - compare stacks by hash only
402  *             bit 10 - if two different stacks hash into the same stackid
403  *                      discard old
404  *             other bits - reserved
405  *     Return: >= 0 stackid on success or negative error
406  *
407  * s64 bpf_csum_diff(from, from_size, to, to_size, seed)
408  *     calculate csum diff
409  *     @from: raw from buffer
410  *     @from_size: length of from buffer
411  *     @to: raw to buffer
412  *     @to_size: length of to buffer
413  *     @seed: optional seed
414  *     Return: csum result or negative error code
415  *
416  * int bpf_skb_get_tunnel_opt(skb, opt, size)
417  *     retrieve tunnel options metadata
418  *     @skb: pointer to skb
419  *     @opt: pointer to raw tunnel option data
420  *     @size: size of @opt
421  *     Return: option size
422  *
423  * int bpf_skb_set_tunnel_opt(skb, opt, size)
424  *     populate tunnel options metadata
425  *     @skb: pointer to skb
426  *     @opt: pointer to raw tunnel option data
427  *     @size: size of @opt
428  *     Return: 0 on success or negative error
429  *
430  * int bpf_skb_change_proto(skb, proto, flags)
431  *     Change protocol of the skb. Currently supported is v4 -> v6,
432  *     v6 -> v4 transitions. The helper will also resize the skb. eBPF
433  *     program is expected to fill the new headers via skb_store_bytes
434  *     and lX_csum_replace.
435  *     @skb: pointer to skb
436  *     @proto: new skb->protocol type
437  *     @flags: reserved
438  *     Return: 0 on success or negative error
439  *
440  * int bpf_skb_change_type(skb, type)
441  *     Change packet type of skb.
442  *     @skb: pointer to skb
443  *     @type: new skb->pkt_type type
444  *     Return: 0 on success or negative error
445  *
446  * int bpf_skb_under_cgroup(skb, map, index)
447  *     Check cgroup2 membership of skb
448  *     @skb: pointer to skb
449  *     @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
450  *     @index: index of the cgroup in the bpf_map
451  *     Return:
452  *       == 0 skb failed the cgroup2 descendant test
453  *       == 1 skb succeeded the cgroup2 descendant test
454  *        < 0 error
455  *
456  * u32 bpf_get_hash_recalc(skb)
457  *     Retrieve and possibly recalculate skb->hash.
458  *     @skb: pointer to skb
459  *     Return: hash
460  *
461  * u64 bpf_get_current_task(void)
462  *     Returns current task_struct
463  *     Return: current
464  *
465  * int bpf_probe_write_user(void *dst, void *src, int len)
466  *     safely attempt to write to a location
467  *     @dst: destination address in userspace
468  *     @src: source address on stack
469  *     @len: number of bytes to copy
470  *     Return: 0 on success or negative error
471  *
472  * int bpf_current_task_under_cgroup(map, index)
473  *     Check cgroup2 membership of current task
474  *     @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
475  *     @index: index of the cgroup in the bpf_map
476  *     Return:
477  *       == 0 current failed the cgroup2 descendant test
478  *       == 1 current succeeded the cgroup2 descendant test
479  *        < 0 error
480  *
481  * int bpf_skb_change_tail(skb, len, flags)
482  *     The helper will resize the skb to the given new size, to be used f.e.
483  *     with control messages.
484  *     @skb: pointer to skb
485  *     @len: new skb length
486  *     @flags: reserved
487  *     Return: 0 on success or negative error
488  *
489  * int bpf_skb_pull_data(skb, len)
490  *     The helper will pull in non-linear data in case the skb is non-linear
491  *     and not all of len are part of the linear section. Only needed for
492  *     read/write with direct packet access.
493  *     @skb: pointer to skb
494  *     @len: len to make read/writeable
495  *     Return: 0 on success or negative error
496  *
497  * s64 bpf_csum_update(skb, csum)
498  *     Adds csum into skb->csum in case of CHECKSUM_COMPLETE.
499  *     @skb: pointer to skb
500  *     @csum: csum to add
501  *     Return: csum on success or negative error
502  *
503  * void bpf_set_hash_invalid(skb)
504  *     Invalidate current skb->hash.
505  *     @skb: pointer to skb
506  *
507  * int bpf_get_numa_node_id()
508  *     Return: Id of current NUMA node.
509  *
510  * int bpf_skb_change_head()
511  *     Grows headroom of skb and adjusts MAC header offset accordingly.
512  *     Will extends/reallocae as required automatically.
513  *     May change skb data pointer and will thus invalidate any check
514  *     performed for direct packet access.
515  *     @skb: pointer to skb
516  *     @len: length of header to be pushed in front
517  *     @flags: Flags (unused for now)
518  *     Return: 0 on success or negative error
519  *
520  * int bpf_xdp_adjust_head(xdp_md, delta)
521  *     Adjust the xdp_md.data by delta
522  *     @xdp_md: pointer to xdp_md
523  *     @delta: An positive/negative integer to be added to xdp_md.data
524  *     Return: 0 on success or negative on error
525  *
526  * int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr)
527  *     Copy a NUL terminated string from unsafe address. In case the string
528  *     length is smaller than size, the target is not padded with further NUL
529  *     bytes. In case the string length is larger than size, just count-1
530  *     bytes are copied and the last byte is set to NUL.
531  *     @dst: destination address
532  *     @size: maximum number of bytes to copy, including the trailing NUL
533  *     @unsafe_ptr: unsafe address
534  *     Return:
535  *       > 0 length of the string including the trailing NUL on success
536  *       < 0 error
537  *
538  * u64 bpf_get_socket_cookie(skb)
539  *     Get the cookie for the socket stored inside sk_buff.
540  *     @skb: pointer to skb
541  *     Return: 8 Bytes non-decreasing number on success or 0 if the socket
542  *     field is missing inside sk_buff
543  *
544  * u32 bpf_get_socket_uid(skb)
545  *     Get the owner uid of the socket stored inside sk_buff.
546  *     @skb: pointer to skb
547  *     Return: uid of the socket owner on success or overflowuid if failed.
548  *
549  * u32 bpf_set_hash(skb, hash)
550  *     Set full skb->hash.
551  *     @skb: pointer to skb
552  *     @hash: hash to set
553  *
554  * int bpf_setsockopt(bpf_socket, level, optname, optval, optlen)
555  *     Calls setsockopt. Not all opts are available, only those with
556  *     integer optvals plus TCP_CONGESTION.
557  *     Supported levels: SOL_SOCKET and IPROTO_TCP
558  *     @bpf_socket: pointer to bpf_socket
559  *     @level: SOL_SOCKET or IPROTO_TCP
560  *     @optname: option name
561  *     @optval: pointer to option value
562  *     @optlen: length of optval in byes
563  *     Return: 0 or negative error
564  *
565  * int bpf_skb_adjust_room(skb, len_diff, mode, flags)
566  *     Grow or shrink room in sk_buff.
567  *     @skb: pointer to skb
568  *     @len_diff: (signed) amount of room to grow/shrink
569  *     @mode: operation mode (enum bpf_adj_room_mode)
570  *     @flags: reserved for future use
571  *     Return: 0 on success or negative error code
572  *
573  * int bpf_sk_redirect_map(map, key, flags)
574  *     Redirect skb to a sock in map using key as a lookup key for the
575  *     sock in map.
576  *     @map: pointer to sockmap
577  *     @key: key to lookup sock in map
578  *     @flags: reserved for future use
579  *     Return: SK_PASS
580  *
581  * int bpf_sock_map_update(skops, map, key, flags)
582  *	@skops: pointer to bpf_sock_ops
583  *	@map: pointer to sockmap to update
584  *	@key: key to insert/update sock in map
585  *	@flags: same flags as map update elem
586  */
587 #define __BPF_FUNC_MAPPER(FN)		\
588 	FN(unspec),			\
589 	FN(map_lookup_elem),		\
590 	FN(map_update_elem),		\
591 	FN(map_delete_elem),		\
592 	FN(probe_read),			\
593 	FN(ktime_get_ns),		\
594 	FN(trace_printk),		\
595 	FN(get_prandom_u32),		\
596 	FN(get_smp_processor_id),	\
597 	FN(skb_store_bytes),		\
598 	FN(l3_csum_replace),		\
599 	FN(l4_csum_replace),		\
600 	FN(tail_call),			\
601 	FN(clone_redirect),		\
602 	FN(get_current_pid_tgid),	\
603 	FN(get_current_uid_gid),	\
604 	FN(get_current_comm),		\
605 	FN(get_cgroup_classid),		\
606 	FN(skb_vlan_push),		\
607 	FN(skb_vlan_pop),		\
608 	FN(skb_get_tunnel_key),		\
609 	FN(skb_set_tunnel_key),		\
610 	FN(perf_event_read),		\
611 	FN(redirect),			\
612 	FN(get_route_realm),		\
613 	FN(perf_event_output),		\
614 	FN(skb_load_bytes),		\
615 	FN(get_stackid),		\
616 	FN(csum_diff),			\
617 	FN(skb_get_tunnel_opt),		\
618 	FN(skb_set_tunnel_opt),		\
619 	FN(skb_change_proto),		\
620 	FN(skb_change_type),		\
621 	FN(skb_under_cgroup),		\
622 	FN(get_hash_recalc),		\
623 	FN(get_current_task),		\
624 	FN(probe_write_user),		\
625 	FN(current_task_under_cgroup),	\
626 	FN(skb_change_tail),		\
627 	FN(skb_pull_data),		\
628 	FN(csum_update),		\
629 	FN(set_hash_invalid),		\
630 	FN(get_numa_node_id),		\
631 	FN(skb_change_head),		\
632 	FN(xdp_adjust_head),		\
633 	FN(probe_read_str),		\
634 	FN(get_socket_cookie),		\
635 	FN(get_socket_uid),		\
636 	FN(set_hash),			\
637 	FN(setsockopt),			\
638 	FN(skb_adjust_room),		\
639 	FN(redirect_map),		\
640 	FN(sk_redirect_map),		\
641 	FN(sock_map_update),		\
642 
643 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
644  * function eBPF program intends to call
645  */
646 #define __BPF_ENUM_FN(x) BPF_FUNC_ ## x
647 enum bpf_func_id {
648 	__BPF_FUNC_MAPPER(__BPF_ENUM_FN)
649 	__BPF_FUNC_MAX_ID,
650 };
651 #undef __BPF_ENUM_FN
652 
653 /* All flags used by eBPF helper functions, placed here. */
654 
655 /* BPF_FUNC_skb_store_bytes flags. */
656 #define BPF_F_RECOMPUTE_CSUM		(1ULL << 0)
657 #define BPF_F_INVALIDATE_HASH		(1ULL << 1)
658 
659 /* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags.
660  * First 4 bits are for passing the header field size.
661  */
662 #define BPF_F_HDR_FIELD_MASK		0xfULL
663 
664 /* BPF_FUNC_l4_csum_replace flags. */
665 #define BPF_F_PSEUDO_HDR		(1ULL << 4)
666 #define BPF_F_MARK_MANGLED_0		(1ULL << 5)
667 #define BPF_F_MARK_ENFORCE		(1ULL << 6)
668 
669 /* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */
670 #define BPF_F_INGRESS			(1ULL << 0)
671 
672 /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */
673 #define BPF_F_TUNINFO_IPV6		(1ULL << 0)
674 
675 /* BPF_FUNC_get_stackid flags. */
676 #define BPF_F_SKIP_FIELD_MASK		0xffULL
677 #define BPF_F_USER_STACK		(1ULL << 8)
678 #define BPF_F_FAST_STACK_CMP		(1ULL << 9)
679 #define BPF_F_REUSE_STACKID		(1ULL << 10)
680 
681 /* BPF_FUNC_skb_set_tunnel_key flags. */
682 #define BPF_F_ZERO_CSUM_TX		(1ULL << 1)
683 #define BPF_F_DONT_FRAGMENT		(1ULL << 2)
684 
685 /* BPF_FUNC_perf_event_output and BPF_FUNC_perf_event_read flags. */
686 #define BPF_F_INDEX_MASK		0xffffffffULL
687 #define BPF_F_CURRENT_CPU		BPF_F_INDEX_MASK
688 /* BPF_FUNC_perf_event_output for sk_buff input context. */
689 #define BPF_F_CTXLEN_MASK		(0xfffffULL << 32)
690 
691 /* Mode for BPF_FUNC_skb_adjust_room helper. */
692 enum bpf_adj_room_mode {
693 	BPF_ADJ_ROOM_NET,
694 };
695 
696 /* user accessible mirror of in-kernel sk_buff.
697  * new fields can only be added to the end of this structure
698  */
699 struct __sk_buff {
700 	__u32 len;
701 	__u32 pkt_type;
702 	__u32 mark;
703 	__u32 queue_mapping;
704 	__u32 protocol;
705 	__u32 vlan_present;
706 	__u32 vlan_tci;
707 	__u32 vlan_proto;
708 	__u32 priority;
709 	__u32 ingress_ifindex;
710 	__u32 ifindex;
711 	__u32 tc_index;
712 	__u32 cb[5];
713 	__u32 hash;
714 	__u32 tc_classid;
715 	__u32 data;
716 	__u32 data_end;
717 	__u32 napi_id;
718 
719 	/* accessed by BPF_PROG_TYPE_sk_skb types */
720 	__u32 family;
721 	__u32 remote_ip4;	/* Stored in network byte order */
722 	__u32 local_ip4;	/* Stored in network byte order */
723 	__u32 remote_ip6[4];	/* Stored in network byte order */
724 	__u32 local_ip6[4];	/* Stored in network byte order */
725 	__u32 remote_port;	/* Stored in network byte order */
726 	__u32 local_port;	/* stored in host byte order */
727 };
728 
729 struct bpf_tunnel_key {
730 	__u32 tunnel_id;
731 	union {
732 		__u32 remote_ipv4;
733 		__u32 remote_ipv6[4];
734 	};
735 	__u8 tunnel_tos;
736 	__u8 tunnel_ttl;
737 	__u16 tunnel_ext;
738 	__u32 tunnel_label;
739 };
740 
741 /* Generic BPF return codes which all BPF program types may support.
742  * The values are binary compatible with their TC_ACT_* counter-part to
743  * provide backwards compatibility with existing SCHED_CLS and SCHED_ACT
744  * programs.
745  *
746  * XDP is handled seprately, see XDP_*.
747  */
748 enum bpf_ret_code {
749 	BPF_OK = 0,
750 	/* 1 reserved */
751 	BPF_DROP = 2,
752 	/* 3-6 reserved */
753 	BPF_REDIRECT = 7,
754 	/* >127 are reserved for prog type specific return codes */
755 };
756 
757 struct bpf_sock {
758 	__u32 bound_dev_if;
759 	__u32 family;
760 	__u32 type;
761 	__u32 protocol;
762 	__u32 mark;
763 	__u32 priority;
764 };
765 
766 #define XDP_PACKET_HEADROOM 256
767 
768 /* User return codes for XDP prog type.
769  * A valid XDP program must return one of these defined values. All other
770  * return codes are reserved for future use. Unknown return codes will
771  * result in packet drops and a warning via bpf_warn_invalid_xdp_action().
772  */
773 enum xdp_action {
774 	XDP_ABORTED = 0,
775 	XDP_DROP,
776 	XDP_PASS,
777 	XDP_TX,
778 	XDP_REDIRECT,
779 };
780 
781 /* user accessible metadata for XDP packet hook
782  * new fields must be added to the end of this structure
783  */
784 struct xdp_md {
785 	__u32 data;
786 	__u32 data_end;
787 };
788 
789 enum sk_action {
790 	SK_DROP = 0,
791 	SK_PASS,
792 };
793 
794 #define BPF_TAG_SIZE	8
795 
796 struct bpf_prog_info {
797 	__u32 type;
798 	__u32 id;
799 	__u8  tag[BPF_TAG_SIZE];
800 	__u32 jited_prog_len;
801 	__u32 xlated_prog_len;
802 	__aligned_u64 jited_prog_insns;
803 	__aligned_u64 xlated_prog_insns;
804 } __attribute__((aligned(8)));
805 
806 struct bpf_map_info {
807 	__u32 type;
808 	__u32 id;
809 	__u32 key_size;
810 	__u32 value_size;
811 	__u32 max_entries;
812 	__u32 map_flags;
813 } __attribute__((aligned(8)));
814 
815 /* User bpf_sock_ops struct to access socket values and specify request ops
816  * and their replies.
817  * Some of this fields are in network (bigendian) byte order and may need
818  * to be converted before use (bpf_ntohl() defined in samples/bpf/bpf_endian.h).
819  * New fields can only be added at the end of this structure
820  */
821 struct bpf_sock_ops {
822 	__u32 op;
823 	union {
824 		__u32 reply;
825 		__u32 replylong[4];
826 	};
827 	__u32 family;
828 	__u32 remote_ip4;	/* Stored in network byte order */
829 	__u32 local_ip4;	/* Stored in network byte order */
830 	__u32 remote_ip6[4];	/* Stored in network byte order */
831 	__u32 local_ip6[4];	/* Stored in network byte order */
832 	__u32 remote_port;	/* Stored in network byte order */
833 	__u32 local_port;	/* stored in host byte order */
834 };
835 
836 /* List of known BPF sock_ops operators.
837  * New entries can only be added at the end
838  */
839 enum {
840 	BPF_SOCK_OPS_VOID,
841 	BPF_SOCK_OPS_TIMEOUT_INIT,	/* Should return SYN-RTO value to use or
842 					 * -1 if default value should be used
843 					 */
844 	BPF_SOCK_OPS_RWND_INIT,		/* Should return initial advertized
845 					 * window (in packets) or -1 if default
846 					 * value should be used
847 					 */
848 	BPF_SOCK_OPS_TCP_CONNECT_CB,	/* Calls BPF program right before an
849 					 * active connection is initialized
850 					 */
851 	BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB,	/* Calls BPF program when an
852 						 * active connection is
853 						 * established
854 						 */
855 	BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB,	/* Calls BPF program when a
856 						 * passive connection is
857 						 * established
858 						 */
859 	BPF_SOCK_OPS_NEEDS_ECN,		/* If connection's congestion control
860 					 * needs ECN
861 					 */
862 };
863 
864 #define TCP_BPF_IW		1001	/* Set TCP initial congestion window */
865 #define TCP_BPF_SNDCWND_CLAMP	1002	/* Set sndcwnd_clamp */
866 
867 #endif /* __LINUX_BPF_H__ */
868