Searched full:program (Results 1 – 25 of 459) sorted by relevance
12345678910>>...19
| /Documentation/bpf/ |
| D | prog_sk_lookup.rst | 4 BPF sk_lookup program
7 BPF sk_lookup program type (``BPF_PROG_TYPE_SK_LOOKUP``) introduces programmability
11 When invoked BPF sk_lookup program can select a socket that will receive the
19 BPF sk_lookup program type was introduced to address setup scenarios where
36 BPF sk_lookup program can be attached to a network namespace with
53 verdict code. As for other BPF program types that are network filters,
58 A BPF sk_lookup program can also select a socket to receive the packet by
59 calling ``bpf_sk_assign()`` BPF helper. Typically, the program looks up a socket
62 selection. Selecting a socket only takes effect if the program has terminated
68 1. If any program returned ``SK_PASS`` and selected a valid socket, the socket
[all …]
|
| D | bpf_prog_run.rst | 19 execute a BPF program in the kernel and return the results to userspace. This
44 object and (for program types operating on network packets) a buffer containing
45 the packet data that the BPF program will operate on. The kernel will then
46 execute the program and return the results to userspace. Note that programs will
48 will not actually be redirected or dropped, the program return code will just be
57 be processed by the kernel after the execution of the XDP program as if they
59 ``BPF_F_TEST_XDP_LIVE_FRAMES`` flag when supplying an XDP program to
63 XDP program many times (suitable for, e.g., running as a traffic generator),
67 - When executing an XDP program in live frame mode, the result of the execution
69 operation indicated by the program's return code (drop the packet, redirect
[all …]
|
| D | map_cgroup_storage.rst | 11 storage is identified by the cgroup the program is attached to.
13 The map provide a local storage at the cgroup that the BPF program is attached
34 ``attach_type`` is the program's attach type.
42 To access the storage in a program, use ``bpf_get_local_storage``::
67 int program(struct __sk_buff *skb)
102 int program(struct __sk_buff *skb)
131 for a single ``CGROUP_STORAGE`` map, there can be at most one program loaded
132 that uses the map. A program may be attached to multiple cgroups or have
137 non-per-CPU) and the BPF program during load verification time. As a result,
138 each map can only be used by one BPF program and each BPF program can only use
[all …]
|
| D | bpf_iterators.rst | 34 A BPF iterator is a type of BPF program that allows users to iterate over
45 A BPF program is always loaded into the kernel at the behest of a user space
46 process. A user space process loads a BPF program by opening and initializing
47 the program skeleton as required and then invoking a syscall to have the BPF
48 program verified and loaded by the kernel.
50 In traditional tracing programs, a program is activated by having user space
51 obtain a ``bpf_link`` to the program with ``bpf_program__attach()``. Once
52 activated, the program callback will be invoked whenever the tracepoint is
54 program is obtained using ``bpf_link_create()``, and the program callback is
66 a BPF iterator program. To begin, we’ll look at `bpf_iter.c
[all …]
|
| D | prog_cgroup_sysctl.rst | 7 This document describes ``BPF_PROG_TYPE_CGROUP_SYSCTL`` program type that
17 ``BPF_PROG_TYPE_CGROUP_SYSCTL`` program to a cgroup.
23 BPF program::
49 ``BPF_PROG_TYPE_CGROUP_SYSCTL`` program must return one of the following
55 If program returns ``0`` user space will get ``-1`` from ``read(2)`` or
65 ``/proc/sys`` into provided by BPF program buffer;
68 sysctl into provided by BPF program buffer. This helper is available on both
78 has to be overridden BPF program can set ``file_pos`` to zero before calling
83 BPF program sees sysctl value same way as user space does in proc filesystem,
98 See `test_sysctl_prog.c`_ for an example of BPF program in C that access
[all …]
|
| D | prog_cgroup_sockopt.rst | 7 ``BPF_PROG_TYPE_CGROUP_SOCKOPT`` program type can be attached to two
26 If BPF program sets ``optlen`` to -1, the control will be returned
38 * ``1`` - success, continue with next BPF program in the cgroup chain.
62 the BPF program from the parent cgroup).
76 the programs are executed from the bottom up: B, A. First program
79 control will be passed to the second (A) program which will see the
82 Same for ``BPF_CGROUP_SETSOCKOPT``: if the program is attached to
85 then the next program in the chain (A) will see those changes,
91 When the ``optval`` is greater than the ``PAGE_SIZE``, the BPF program
96 done by the BPF program to the ``optval`` are ignored.
[all …]
|
| D | map_cgrp_storage.rst | 21 To access the storage in a program, use ``bpf_cgrp_storage_get``::
32 The map is available to all program types.
37 A BPF program example with BPF_MAP_TYPE_CGRP_STORAGE::
87 (1). ``BPF_MAP_TYPE_CGRP_STORAGE`` can be used by all program types while
88 ``BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED`` is available only to cgroup program types
93 which is attached by a BPF program.
100 ``bpf_map_update_elem()`` to pre-allocate local storage before a BPF program
103 (4). ``BPF_MAP_TYPE_CGRP_STORAGE`` supports deleting local storage by a BPF program
|
| D | prog_lsm.rst | 15 The example shows an eBPF program that can be attached to the ``file_mprotect``
24 headers for accessing information from the attached eBPF program's context.
25 They can simply declare the structures in the eBPF program and only specify
61 * ``"lsm/file_mprotect"`` indicates the LSM hook that the program must
63 * ``mprotect_audit`` is the name of the eBPF program
71 /* ret is the return value from the previous BPF program
93 eBPF program.
114 and the program can be loaded by including ``my_prog.skel.h`` and using
124 The program can be detached from the LSM hook by *destroying* the ``link``
133 An example eBPF program can be found in
|
| D | map_devmap.rst | 43 fails. This is so that the return value can be one of the XDP program return
75 from an eBPF program. Trying to call these functions from a kernel eBPF
76 program will result in the program failing to load and a verifier warning.
104 DEVMAPs can associate a program with a device entry by adding a ``bpf_prog.fd``
106 access to both Rx device and Tx device. The program associated with the ``fd``
108 When a program is associated with a device index, the program is run on an
170 The following code snippet shows a simple xdp_redirect_map program. This program
171 would work with a user space program that populates the devmap ``forward_map`` based
172 on ingress ifindexes. The BPF program (below) is redirecting packets using the
185 The following code snippet shows a BPF program that is broadcasting packets to
|
| D | map_sockmap.rst | 14 the result of a BPF (verdict) program with the help of the BPF helpers
28 These maps may have BPF programs attached to them, specifically a parser program
29 and a verdict program. The parser program determines how much data has been
31 verdict program is essentially the redirect program and can return a verdict
39 parse or verdict program. If adding a sock object to a map would result
59 - ``msg_parser`` program - ``BPF_SK_MSG_VERDICT``.
60 - ``stream_parser`` program - ``BPF_SK_SKB_STREAM_PARSER``.
61 - ``stream_verdict`` program - ``BPF_SK_SKB_STREAM_VERDICT``.
62 - ``skb_verdict`` program - ``BPF_SK_SKB_VERDICT``.
68 handles a different case where a BPF program cannot reach a verdict on a msg
[all …]
|
| D | programs.rst | 2 Program Types
11 For a list of all program types, see :ref:`program_types_and_elf` in
|
| D | map_cpumap.rst | 20 Starting from Linux kernel version 5.9 the CPUMAP can run a second XDP program
21 on the remote CPU. This allows an XDP program to split its processing across
25 initial CPU is where the XDP redirect program is executed. The remote CPU
43 fails. This is so that the return value can be one of the XDP program return
50 from an eBPF program. Trying to call these functions from a kernel eBPF
51 program will result in the program failing to load and a verifier warning.
|
| /Documentation/userspace-api/ |
| D | ELF.rst | 10 "First" program header is the one with the smallest offset in the file:
13 "Last" program header is the one with the biggest offset in the file:
19 First PT_INTERP program header is used to locate the filename of ELF
25 Last PT_GNU_STACK program header defines userspace stack executability
31 ELF interpreter's last PT_GNU_PROPERTY program header is used (since
33 program header of an executable is used. Other PT_GNU_PROPERTY headers
|
| /Documentation/hid/ |
| D | hid-bpf.rst | 38 HID-BPF allows the userspace program to load the program itself, ensuring we
48 We can reduce this burden by providing an eBPF program instead. Once such a
49 program has been verified by the user, we can embed the source code into the
50 kernel tree and ship the eBPF program and load it directly instead of loading
80 events into wheel events. Also, the userspace program can set/unset the haptic
96 kernel/bpf program because we can intercept any incoming command.
119 program.
128 When a BPF program needs to emit input events, it needs to talk with the HID
162 A ``hid_device_event`` is calling a BPF program when an event is received from
171 BPF program of this type. This is called on ``probe`` from the driver and allows to
[all …]
|
| /Documentation/admin-guide/nfs/ |
| D | nfs-idmapper.rst | 29 ``#OP TYPE DESCRIPTION CALLOUT INFO PROGRAM ARG1 ARG2 ARG3 ...``
34 This will direct all id_resolver requests to the program /usr/sbin/nfs.idmap.
47 program. If you would like to use your own program for a uid lookup then you
50 ``#OP TYPE DESCRIPTION CALLOUT INFO PROGRAM ARG1 ARG2 ARG3 ...``
52 ``create id_resolver uid:* * /some/other/program %k %d 600``
56 Notice that the new line was added above the line for the generic program.
57 request-key will find the first matching line and corresponding program. In
58 this case, /some/other/program will handle all uid lookups and
69 hand". This program takes two arguments, a serialized key and a key
|
| /Documentation/networking/ |
| D | xdp-rx-metadata.rst | 7 This document describes how an eXpress Data Path (XDP) program can access
31 An XDP program can use these kfuncs to read the metadata into stack
33 consumers, an XDP program can store it into the metadata area carried
52 An XDP program can store individual metadata items into this ``data_meta``
61 program that redirects XDP frames into the ``AF_XDP`` socket (``XSK``) and
62 the final consumer. Thus the BPF program manually allocates a fixed number of
82 This is the path where the packets processed by the XDP program are passed
90 In the future, we'd like to support a case where an XDP program
98 program after the redirect. However, the final consumer doesn't have
104 currently supported, which has to be prepared by the initial XDP program
[all …]
|
| /Documentation/misc-devices/ |
| D | spear-pcie-gadget.rst | 30 and then program its various registers to configure it as a particular device
68 bar0 is SYSRAM1(E0800000). Always program bar size before bar
78 Program all PCIe registers in such a way that when this device is connected
90 program vendor id as 0x104a::
94 program device id as 0xCD80::
98 program BAR0 size as 1MB::
106 Program BAR0 Address as DDR (0x2100000). This is the physical address of
108 can also be made visible to PCIe host. E.g., if you program base address of UART
116 program interrupt type : INTA::
142 if MSI is to be used as interrupt, program no of msi vector needed (say4)::
|
| /Documentation/driver-api/fpga/ |
| D | fpga-programming.rst | 18 * program the FPGA using info passed in :c:expr:`fpga_region->info`.
22 The struct fpga_image_info specifies what FPGA image to program. It is
26 How to program an FPGA using a region
42 * program.
87 * fpga_region_program_fpga() - Program an FPGA
88 * fpga_image_info() - Specifies what FPGA image to program
|
| /Documentation/admin-guide/ |
| D | java.rst | 8 other program after you have done the following:
60 You, too, need the little program after the script. Compile like::
66 Both the javawrapper shellscript and the javaclassname program
171 * This program is free software; you can redistribute it and/or modify
176 * This program is distributed in the hope that it will be useful,
182 * along with this program; if not, write to the Free Software
210 #define seek_error() error("%s: Cannot seek\n", program)
211 #define corrupt_error() error("%s: Class file corrupt\n", program)
212 #define eof_error() error("%s: Unexpected end of file\n", program)
213 #define utf8_error() error("%s: Only ASCII 1-255 supported\n", program);
[all …]
|
| /Documentation/leds/ |
| D | leds-lp55xx.rst | 15 Program memory for running LED patterns
55 - Program memory address access for running patterns
60 LP55xx family devices have the internal program memory for running
68 LP55xx chips have three program engines.
80 Select which engine is used for running program
82 Start program which is loaded via the firmware interface
84 Load program data
166 The sequence of running the program data is common.
177 Chip specific commands for loading and updating program memory.
|
| /Documentation/ABI/stable/ |
| D | vdso | 7 On some architectures, when the kernel loads any userspace program it
8 maps an ELF DSO into that program's address space. This DSO is called
20 To find the DSO, parse the auxiliary vector passed to the program's
|
| /Documentation/watchdog/ |
| D | pcwd-watchdog.rst | 25 Watchdog program.
29 to run the program with an "&" to run it in the background!)
31 If you want to write a program to be compatible with the PC Watchdog
32 driver, simply use of modify the watchdog test program:
|
| /Documentation/arch/s390/ |
| D | vfio-ccw.rst | 18 in the channel program directly, i.e. there is no iommu involved.
75 instruction to a specialized I/O channel processor. A channel program is
77 issue a channel program to the channel subsystem, it is required to
81 the channel program with a SSCH (start sub-channel) instruction. The
109 policing and translation how the channel program is programmed before
122 vfio_ccw also provides an I/O region to accept channel program
138 address, pin the page and program the hardware with the host physical
193 An I/O region is used to accept channel program request from user
329 passed in by a user space program are organized with their guest
331 space, and assemble a runnable kernel channel program by updating the
[all …]
|
| /Documentation/ABI/testing/ |
| D | sysfs-amd-pmc | 11 Description: Reading this file reports the program corresponding to the SMU
12 firmware version. The program field is used to disambiguate two
|
| /Documentation/bpf/libbpf/ |
| D | libbpf_overview.rst | 10 kernel hooks, allowing BPF application developers to focus only on BPF program
48 (setting BPF program types, if necessary; pre-setting initial values for
54 and loads the BPF program into the kernel, but no BPF program has yet been
56 state without racing with the BPF program code execution.
140 libbpf steps up the BPF program portability by supporting the BPF CO-RE concept.
158 ``vmlinux.h`` in your BPF program eliminates dependency on system-wide kernel
161 libbpf enables portability of BPF programs by looking at the BPF program’s
165 relocatable data to ensure that BPF program’s logic functions correctly for a
219 space part of the BPF application easier. Note that the BPF program themselves
233 * `Program types and ELF Sections <https://libbpf.readthedocs.io/en/latest/program_types.html>`_
|
12345678910>>...19