Lines Matching defs:data
83 __u8 data[0]; /* Arbitrary size */
337 * data *data_in*, and return the modified program context
338 * *ctx_out*, *data_out* (for example, packet data), result of the
958 * are not subject to a stable API since kernel internal data
1390 __u32 btf_fd; /* fd pointing to a BTF type data */
1450 __u32 prog_btf_fd; /* fd pointing to BTF type data */
1768 * kernel space address *unsafe_ptr* and store the data in *dst*.
2039 * only hold data for one version of cgroups at a time).
2242 * long bpf_perf_event_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size)
2244 * Write raw *data* blob into a special BPF perf event held by
2257 * pointed by *data*.
2265 * *map*. This must be done before the eBPF program can send data
2272 * than **bpf_trace_printk**\ () for sharing data with user
2273 * space, and is much better suitable for streaming data from eBPF
2278 * where it allows for passing data to user space listeners. Data
2289 * This helper was provided as an easy way to load data from a
2295 * by "direct packet access", enabling packet data to be
2296 * manipulated with *skb*\ **->data** and *skb*\ **->data_end**
2297 * pointing respectively to the first byte of packet data and to
2298 * the byte after the last byte of packet data. However, it
2299 * remains useful if one wishes to read large quantities of data
2325 * can be further combined with other data (including other stack
2358 * checksum, it can be used when pushing new data.
2360 * checksum, it can be used when removing data from a packet.
2376 * *skb*, and store the raw tunnel option data to the buffer *opt*
2389 * The size of the option data retrieved.
2394 * to the option data contained in the raw buffer *opt* of *size*.
2545 * Pull in non-linear data in case the *skb* is non-linear and not
2557 * data is in non-linear parts of the *skb*. On failure the
2559 * buffer, use a helper to make the data available. The
2561 * the data. Another one consists in using **bpf_skb_pull_data**
2563 * eventually access the data.
2586 * when the checksum needs to be updated after data has been
2636 * Adjust (move) *xdp_md*\ **->data** by *delta* bytes. Note that
2752 * Grow or shrink the room for data in the packet associated to
2760 * checksum data of the skb to CHECKSUM_NONE.
2866 * operation modifies the address stored in *xdp_md*\ **->data**,
2873 * possible to push further meta data along with it before passing
2881 * data they need.
2908 * structure. This allows for additional data to be retrieved: in
3077 * smaller than the current data being processed from a
3080 * the pointer for start of data pointing to byte number *bytes*
3081 * **+ 1**. If *bytes* is larger than the current data being
3087 * a non-zero value, this is not a problem because data is not
3099 * before a verdict can be assigned, even if the data spans
3112 * For socket policies, pull in non-linear data from user space
3113 * for *msg* and set pointers *msg*\ **->data** and *msg*\
3118 * *msg* it can only parse data that the (**data**, **data_end**)
3122 * be the range (**0**, **0**) because the data is shared with
3124 * user space to modify data while (or after) eBPF verdict is
3125 * being decided. This helper can be used to pull in data and to
3127 * copied if necessary (i.e. if data was not linear and if start
3242 * Base offset to load data from is *skb*'s mac header.
3244 * Base offset to load data from is *skb*'s network header.
3247 * access packet data, however, this helper is in particular useful
3248 * in socket filters where *skb*\ **->data** does not always point
3529 * the shared data.
3732 * helpers. Loading or storing data into the **struct
4028 * long bpf_skb_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size)
4030 * Write raw *data* blob into a special BPF perf event held by
4043 * pointed by *data*.
4055 * *unsafe_ptr* and store the data in *dst*.
4062 * *unsafe_ptr* and store the data in *dst*.
4176 * long bpf_xdp_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size)
4178 * Write raw *data* blob into a special BPF perf event held by
4191 * pointed by *data*.
4317 * long bpf_seq_printf(struct seq_file *m, const char *fmt, u32 fmt_size, const void *data, u32 data_len)
4322 * the format string itself. The *data* and *data_len* are format string
4323 * arguments. The *data* are a **u64** array and corresponding format string
4325 * are accessed, only the pointer values are stored in the *data* array.
4326 * The *data_len* is the size of *data* in bytes - must be a multiple of 8.
4346 * long bpf_seq_write(struct seq_file *m, const void *data, u32 len)
4348 * **bpf_seq_write**\ () uses seq_file **seq_write**\ () to write the data.
4349 * The *m* represents the seq_file. The *data* and *len* represent the
4350 * data to write in bytes.
4388 * long bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags)
4390 * Copy *size* bytes from *data* into a ring buffer *ringbuf*.
4392 * of new data availability is sent.
4394 * of new data availability is sent unconditionally.
4396 * of new data availability is sent.
4413 * void bpf_ringbuf_submit(void *data, u64 flags)
4415 * Submit reserved ring buffer sample, pointed to by *data*.
4417 * of new data availability is sent.
4419 * of new data availability is sent unconditionally.
4421 * of new data availability is sent.
4427 * void bpf_ringbuf_discard(void *data, u64 flags)
4429 * Discard reserved ring buffer sample, pointed to by *data*.
4431 * of new data availability is sent.
4433 * of new data availability is sent unconditionally.
4435 * of new data availability is sent.
4446 * * **BPF_RB_AVAIL_DATA**: Amount of data not yet consumed.
4620 * Store header option. The data will be copied
4625 * option data. The *len* must be at least kind-length
4724 * the data in *dst*. This is a wrapper of **copy_from_user**\ ().
4734 * data structure using BTF, the type information and values are
4736 * the pointer data is carried out to avoid kernel crashes during
4738 * larger programs can use map data to store the string
5025 * long bpf_snprintf(char *str, u32 str_size, const char *fmt, u64 *data, u32 data_len)
5032 * in the **data** array. For strings and pointers where pointees
5033 * are accessed, only the pointer values are stored in the *data*
5034 * array. The *data_len* is the size of *data* in bytes - must be
5185 * The data is stored as struct perf_branch_entry into output
5197 * long bpf_trace_vprintk(const char *fmt, u32 fmt_size, const void *data, u32 data_len)
5343 * This helper is provided as an easy way to load data from a
5360 * address space, and stores the data in *dst*. *flags* is not
5432 * long bpf_dynptr_from_mem(void *data, u32 size, u64 flags, struct bpf_dynptr *ptr)
5434 * Get a dynptr to local memory *data*.
5436 * *data* must be a ptr to a map value.
5456 * Submit reserved ring buffer sample, pointed to by *data*,
5482 * of *src*'s data, -EINVAL if *src* is an invalid dynptr or if
5493 * * All data slices of the dynptr are automatically
5502 * of *dst*'s data, -EINVAL if *dst* is an invalid dynptr or if *dst*
5508 * Get a pointer to the underlying dynptr data.
5510 * *len* must be a statically known value. The returned data slice
5516 * Pointer to the underlying dynptr data, NULL if the dynptr is
6125 __u32 data;
6251 * total number of data segments in.
6257 * total number of data segments sent.
6272 __u32 delivered; /* Total data packets delivered incl. rexmits */
6330 __u32 data;
6342 * The struct data-layout of map-value is a configuration interface.
6355 * The struct data-layout of map-value is a configuration interface.
6375 __bpf_md_ptr(void *, data);
6392 * Start of directly accessible data. It begins from
6395 __bpf_md_ptr(void *, data);
6396 /* End of directly accessible data */
6400 * Note that the directly accessible bytes (data_end - data)
7019 /* set if lookup is to consider L4 data - e.g., FIB rules */
7212 /* User accessible data for SK_LOOKUP programs. Add new fields at the end. */
7233 * type id is used to render the pointer data as the appropriate type
7282 * "struct bpf_core_relo" is used to pass relocation data form LLVM to libbpf
7285 * CO-RE relocation captures the following data:
7324 * In this case Clang will emit field relocation recording necessary data to