Lines Matching refs:value
53 * Map value associated to *key*, or **NULL** if no entry was
61 * Add or update the value of the entry associated to *key* in
62 * *map* with *value*. *flags* is one of:
71 * Flag value **BPF_NOEXIST** cannot be used for maps of types
78 static long (*bpf_map_update_elem)(void *map, const void *key, const void *value, __u64 flags) = (void *) 2;
152 * * ``0x00000001`` is a fake value used by BPF for the
191 * A random 32-bit unsigned value.
234 * must know the former value of the header field that was
235 * modified (*from*), the new value of this field (*to*), and the
263 * helper must know the former value of the header field that was
264 * modified (*from*), the new value of this field (*to*), and the
274 * for updates resulting in a null checksum the value is set to
335 * value in *flags* is used to make the distinction (ingress path
566 * Read the value of a perf event counter. This helper relies on a
570 * is the number of available CPUs, and each cell contains a value
571 * relative to one CPU. The value to retrieve is indicated by
574 * **BPF_F_CURRENT_CPU** to indicate that the value for the
583 * quirks where error and counter value are used as a return code
591 * The value of the perf event counter read from the map, or a
605 * for redirection. The **BPF_F_INGRESS** value in *flags* is used
661 * the value must be put, masked with **BPF_F_INDEX_MASK**.
666 * The value to write, of *size*, is passed through eBPF stack and
759 * # sysctl kernel.perf_event_max_stack=<new value>
773 * (same remark). An optional *seed* can be added to the value
903 * The return value depends on the result of the test, and can be:
972 * The return value depends on the result of the test, and can be:
1013 * from *skb* readable and writable. If a zero value is passed for
1123 * it is possible to use a negative value for *delta*. This helper
1151 * value.
1180 * time-wait or a request socket instead), **overflowuid** value
1182 * UID value for the socket).
1190 * to value *hash*.
1204 * The option value of length *optlen* is pointed by *optval*.
1309 * the map lookup fails. This is so that the return value can be
1322 * **XDP_REDIRECT** on success, or the value of the two lower bits
1333 * **BPF_F_INGRESS** value in *flags* is used to make the
1346 * *skops* is used as a new value for the entry associated to
1401 * Read the value of a perf event counter, and store it into *buf*
1406 * available CPUs, and each cell contains a value relative to one
1407 * CPU. The value to retrieve is indicated by *flags*, that
1410 * **BPF_F_CURRENT_CPU** to indicate that the value for the
1415 * just returning the value observed, it fills the *buf*
1428 * multiplexing happens, the number of samples or counter value
1431 * Typically, the counter value should be normalized before
1445 * value and do the calculation inside the eBPF program.
1456 * value of the event counter associated to *ctx* and store it in
1474 * The retrieved value is stored in the structure pointed by
1498 * the return value of the probed function, and to set it to *rc*.
1506 * value.
1526 * Attempt to set the value of the **bpf_sock_ops_cb_flags** field
1533 * code. A program of the same type can change its value, per
1580 * **BPF_F_INGRESS** value in *flags* is used to make the
1619 * a non-zero value, this is not a problem because data is not
1730 * The retrieved value is stored in the **struct bpf_xfrm_state**
1783 * # sysctl kernel.perf_event_max_stack=<new value>
1873 * The *skops* is used as a new value for the entry associated to
1901 * **BPF_F_INGRESS** value in *flags* is used to make the
1919 * **BPF_F_INGRESS** value in *flags* is used to make the
2069 * *toggle* value in the given *protocol*. The scancode will be
2168 * associated with *skb*, then return value will be same as that
2187 * network namespace *netns*. The return value must be checked,
2205 * If *netns* is any other signed 32-bit value greater than or
2228 * network namespace *netns*. The return value must be checked,
2246 * If *netns* is any other signed 32-bit value greater than or
2280 * Push an element *value* in *map*. *flags* is one of:
2289 static long (*bpf_map_push_elem)(void *map, const void *value, __u64 flags) = (void *) 87;
2299 static long (*bpf_map_pop_elem)(void *map, void *value) = (void *) 88;
2309 static long (*bpf_map_peek_elem)(void *map, void *value) = (void *) 89;
2340 * payload and/or *pop* value being to large.
2369 * stored as part of a value of a map. Taking the lock allows to
2370 * safely update the rest of the fields in that value. The
2395 * of the map value must be a struct and have **struct
2398 * * The **struct bpf_spin_lock** *lock* field in a map value must
2399 * be aligned on a multiple of 4 bytes in that value.
2456 * to **CE** (Congestion Encountered) if current value is **ECT**
2482 * network namespace *netns*. The return value must be checked,
2544 * Get current value of sysctl as it is presented in /proc/sys
2548 * The whole value is copied, no matter what file position user
2559 * **-EINVAL** if current value was unavailable, e.g. because
2567 * Get new value being written by user space to sysctl (before
2571 * User space may write new value at file position > 0.
2588 * Override new value being written by user space to sysctl with
2589 * value provided by program in buffer *buf* of size *buf_len*.
2594 * User space may write new value at file position > 0. To override
2595 * the whole sysctl value file position should be set to zero.
2630 * **-ERANGE** if resulting value was out of range.
2657 * **-ERANGE** if resulting value was out of range.
2666 * Logically, it could be thought of getting the value from
2673 * Underneath, the value is stored locally at *sk* instead of
2683 * created if one does not exist. *value* can be used
2685 * the initial value of a bpf-local-storage. If *value* is
2694 static void *(*bpf_sk_storage_get)(void *map, void *sk, void *value, __u64 flags) = (void *) 107;
2744 * followed by 16 bits which hold the MSS value for that cookie,
2747 * On failure, the returned value is one of the following:
2769 * the value must be put, masked with **BPF_F_INDEX_MASK**.
2774 * The value to write, of *size*, is passed through eBPF stack and
2847 * **->mm->env_start**: using this helper and the return value,
2853 * value.
2865 * the trailing NUL character. On error, a negative value.
2918 * negative value.
2957 * the value must be put, masked with **BPF_F_INDEX_MASK**.
2962 * The value to write, of *size*, is passed through eBPF stack and
2999 * associated with the current task, then return value will be the
3130 * associated with *sk*, then return value will be same as that
3231 * Requested value, or 0, if *flags* are not recognized.
3352 * # sysctl kernel.perf_event_max_stack=<new value>
3406 * The return value is the total length copied. On failure, a
3438 * and setting the 4 bytes aligned value to th->doff.
3495 * Logically, it could be thought of as getting the value from
3502 * Underneath, the value is stored locally at *inode* instead of
3509 * created if one does not exist. *value* can be used
3511 * the initial value of a bpf_local_storage. If *value* is
3520 static void *(*bpf_inode_storage_get)(void *map, void *inode, void *value, __u64 flags) = (void *) 145;
3546 * value.
3565 * using *ptr*->type_id. This value should specify the type
3664 * bpf_per_cpu_ptr() must check the returned value.
3713 * Logically, it could be thought of as getting the value from
3720 * Underneath, the value is stored locally at *task* instead of
3727 * created if one does not exist. *value* can be used
3729 * the initial value of a bpf_local_storage. If *value* is
3738 static void *(*bpf_task_storage_get)(void *map, struct task_struct *task, void *value, __u64 flags) = (void *) 156;
3839 * reject BPF program. If the value *mtu_len* is initialized to
3840 * zero then the ctx packet size is use. When value *mtu_len* is
3843 * this value is L3 as this correlate to MTU and IP-header tot_len
3868 * On return *mtu_len* pointer contains the MTU value of the net
3872 * MTU value in your BPF-code.
3876 * * 0 on success, and populate MTU value in *mtu_len* pointer.
3881 * value in *mtu_len* pointer, as this can be needed for
3906 * long (\*callback_fn)(struct bpf_map \*map, const void \*key, void \*value, void \*ctx);
3908 * For per_cpu maps, the map_value is the value on the cpu where the
3912 * element. If return value is 1, the helper will skip the rest of
3946 * the trailing zero character. If the return value is greater than
4039 * different maps if key/value layout matches across maps.
4045 * Start the timer in absolute expire value instead of the
4091 * Get bpf_cookie value provided (optionally) during the program
4134 * negative value.
4173 * On success, zero. On error, a negative value.
4225 * loop. If return value is 1, the helper will skip the rest of
4254 * returned in **value**.
4261 static long (*bpf_get_func_arg)(void *ctx, __u32 n, __u64 *value) = (void *) 183;
4266 * Get return value of the traced function (for tracing programs)
4267 * in **value**.
4274 static long (*bpf_get_func_ret)(void *ctx, __u64 *value) = (void *) 184;
4291 * Get the BPF program's return value that will be returned to the upper layers.
4294 * where BPF program's return value is returned to the userspace via errno.
4297 * The BPF program's return value.
4304 * Set the BPF program's return value that will be returned to the upper layers.
4307 * where BPF program's return value is returned to the userspace via errno.
4315 * In this case, the BPF program's return value will use helper's -EPERM. This
4379 * the tstamp value can be directly written to __sk_buff->tstamp
4424 * old value. *ptr* can be NULL, otherwise it must be a referenced
4428 * The old value of kptr (which can be NULL). The returned pointer
4442 * Map value associated to *key* on *cpu*, or **NULL** if no entry
4462 * *data* must be a ptr to a map value.
4560 * *len* must be a statically known value. The returned data slice
4588 * followed by 16 bits which hold the MSS value for that cookie,
4591 * On failure, the returned value is one of the following:
4612 * followed by 16 bits which hold the MSS value for that cookie,
4615 * On failure, the returned value is one of the following:
4636 * On failure, the returned value is one of the following:
4655 * On failure, the returned value is one of the following:
4688 * BPF_MAX_USER_RINGBUF_SAMPLES samples. If the return value is 1,
4704 * On failure, the returned value is one of the following:
4725 * Logically, it could be thought of as getting the value from
4732 * In reality, the local-storage value is embedded directly inside of the
4734 * **BPF_MAP_TYPE_CGRP_STORAGE** map. When the local-storage value is
4737 * *cgroup* object until the local-storage value for the *map* is found.
4741 * created if one does not exist. *value* can be used
4743 * the initial value of a bpf_local_storage. If *value* is
4752 static void *(*bpf_cgrp_storage_get)(void *map, struct cgroup *cgroup, void *value, __u64 flags) = (void *) 210;