]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/bpf-program.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
8 #include "alloc-util.h"
9 #include "bpf-program.h"
13 #include "path-util.h"
16 int bpf_program_new(uint32_t prog_type
, BPFProgram
**ret
) {
17 _cleanup_(bpf_program_unrefp
) BPFProgram
*p
= NULL
;
19 p
= new0(BPFProgram
, 1);
24 p
->prog_type
= prog_type
;
32 BPFProgram
*bpf_program_ref(BPFProgram
*p
) {
42 BPFProgram
*bpf_program_unref(BPFProgram
*p
) {
52 /* Unfortunately, the kernel currently doesn't implicitly detach BPF programs from their cgroups when the last
53 * fd to the BPF program is closed. This has nasty side-effects since this means that abnormally terminated
54 * programs that attached one of their BPF programs to a cgroup will leave this programs pinned for good with
55 * zero chance of recovery, until the cgroup is removed. This is particularly problematic if the cgroup in
56 * question is the root cgroup (or any other cgroup belonging to a service that cannot be restarted during
57 * operation, such as dbus), as the memory for the BPF program can only be reclaimed through a reboot. To
58 * counter this, we track closely to which cgroup a program was attached to and will detach it on our own
59 * whenever we close the BPF fd. */
60 (void) bpf_program_cgroup_detach(p
);
62 safe_close(p
->kernel_fd
);
63 free(p
->instructions
);
64 free(p
->attached_path
);
69 int bpf_program_add_instructions(BPFProgram
*p
, const struct bpf_insn
*instructions
, size_t count
) {
73 if (p
->kernel_fd
>= 0) /* don't allow modification after we uploaded things to the kernel */
76 if (!GREEDY_REALLOC(p
->instructions
, p
->allocated
, p
->n_instructions
+ count
))
79 memcpy(p
->instructions
+ p
->n_instructions
, instructions
, sizeof(struct bpf_insn
) * count
);
80 p
->n_instructions
+= count
;
85 int bpf_program_load_kernel(BPFProgram
*p
, char *log_buf
, size_t log_size
) {
90 if (p
->kernel_fd
>= 0) { /* make this idempotent */
91 memzero(log_buf
, log_size
);
95 attr
= (union bpf_attr
) {
96 .prog_type
= p
->prog_type
,
97 .insns
= PTR_TO_UINT64(p
->instructions
),
98 .insn_cnt
= p
->n_instructions
,
99 .license
= PTR_TO_UINT64("GPL"),
100 .log_buf
= PTR_TO_UINT64(log_buf
),
101 .log_level
= !!log_buf
,
102 .log_size
= log_size
,
105 p
->kernel_fd
= bpf(BPF_PROG_LOAD
, &attr
, sizeof(attr
));
106 if (p
->kernel_fd
< 0)
112 int bpf_program_cgroup_attach(BPFProgram
*p
, int type
, const char *path
, uint32_t flags
) {
113 _cleanup_free_
char *copy
= NULL
;
114 _cleanup_close_
int fd
= -1;
122 if (!IN_SET(flags
, 0, BPF_F_ALLOW_OVERRIDE
, BPF_F_ALLOW_MULTI
))
125 /* We need to track which cgroup the program is attached to, and we can only track one attachment, hence let's
126 * refuse this early. */
127 if (p
->attached_path
) {
128 if (!path_equal(p
->attached_path
, path
))
130 if (p
->attached_type
!= type
)
132 if (p
->attached_flags
!= flags
)
135 /* Here's a shortcut: if we previously attached this program already, then we don't have to do so
136 * again. Well, with one exception: if we are in BPF_F_ALLOW_OVERRIDE mode then someone else might have
137 * replaced our program since the last time, hence let's reattach it again, just to be safe. In flags
138 * == 0 mode this is not an issue since nobody else can replace our program in that case, and in flags
139 * == BPF_F_ALLOW_MULTI mode any other's program would be installed in addition to ours hence ours
140 * would remain in effect. */
141 if (flags
!= BPF_F_ALLOW_OVERRIDE
)
145 /* Ensure we have a kernel object for this. */
146 r
= bpf_program_load_kernel(p
, NULL
, 0);
154 fd
= open(path
, O_DIRECTORY
|O_RDONLY
|O_CLOEXEC
);
158 attr
= (union bpf_attr
) {
161 .attach_bpf_fd
= p
->kernel_fd
,
162 .attach_flags
= flags
,
165 if (bpf(BPF_PROG_ATTACH
, &attr
, sizeof(attr
)) < 0)
168 free_and_replace(p
->attached_path
, copy
);
169 p
->attached_type
= type
;
170 p
->attached_flags
= flags
;
175 int bpf_program_cgroup_detach(BPFProgram
*p
) {
176 _cleanup_close_
int fd
= -1;
180 if (!p
->attached_path
)
183 fd
= open(p
->attached_path
, O_DIRECTORY
|O_RDONLY
|O_CLOEXEC
);
188 /* If the cgroup does not exist anymore, then we don't have to explicitly detach, it got detached
189 * implicitly by the removal, hence don't complain */
194 attr
= (union bpf_attr
) {
195 .attach_type
= p
->attached_type
,
197 .attach_bpf_fd
= p
->kernel_fd
,
200 if (bpf(BPF_PROG_DETACH
, &attr
, sizeof(attr
)) < 0)
204 p
->attached_path
= mfree(p
->attached_path
);
209 int bpf_map_new(enum bpf_map_type type
, size_t key_size
, size_t value_size
, size_t max_entries
, uint32_t flags
) {
210 union bpf_attr attr
= {
212 .key_size
= key_size
,
213 .value_size
= value_size
,
214 .max_entries
= max_entries
,
219 fd
= bpf(BPF_MAP_CREATE
, &attr
, sizeof(attr
));
226 int bpf_map_update_element(int fd
, const void *key
, void *value
) {
228 union bpf_attr attr
= {
230 .key
= PTR_TO_UINT64(key
),
231 .value
= PTR_TO_UINT64(value
),
234 if (bpf(BPF_MAP_UPDATE_ELEM
, &attr
, sizeof(attr
)) < 0)
240 int bpf_map_lookup_element(int fd
, const void *key
, void *value
) {
242 union bpf_attr attr
= {
244 .key
= PTR_TO_UINT64(key
),
245 .value
= PTR_TO_UINT64(value
),
248 if (bpf(BPF_MAP_LOOKUP_ELEM
, &attr
, sizeof(attr
)) < 0)