ba39486d2c
[Changes from V1:
- The __compat_break has been abandoned in favor of
a more readable can_loop macro that can be used anywhere, including
loop conditions.]
The macro list_for_each_entry is defined in bpf_arena_list.h as
follows:
#define list_for_each_entry(pos, head, member) \
for (void * ___tmp = (pos = list_entry_safe((head)->first, \
typeof(*(pos)), member), \
(void *)0); \
pos && ({ ___tmp = (void *)pos->member.next; 1; }); \
cond_break, \
pos = list_entry_safe((void __arena *)___tmp, typeof(*(pos)), member))
The macro cond_break, in turn, expands to a statement expression that
contains a `break' statement. Compound statement expressions, and the
subsequent ability of placing statements in the header of a `for'
loop, are GNU extensions.
Unfortunately, clang implements this GNU extension differently than
GCC:
- In GCC the `break' statement is bound to the containing "breakable"
context in which the defining `for' appears. If there is no such
context, GCC emits a warning: break statement without enclosing `for'
o `switch' statement.
- In clang the `break' statement is bound to the defining `for'. If
the defining `for' is itself inside some breakable construct, then
clang emits a -Wgcc-compat warning.
This patch adds a new macro can_loop to bpf_experimental, that
implements the same logic than cond_break but evaluates to a boolean
expression. The patch also changes all the current instances of usage
of cond_break withing the header of loop accordingly.
Tested in bpf-next master.
No regressions.
Signed-off-by: Jose E. Marchesi <jose.marchesi@oracle.com>
Cc: david.faust@oracle.com
Cc: cupertino.miranda@oracle.com
Cc: Alexei Starovoitov <alexei.starovoitov@gmail.com>
Link: https://lore.kernel.org/r/20240511212243.23477-1-jose.marchesi@oracle.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
93 lines
2.4 KiB
C
93 lines
2.4 KiB
C
/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
|
|
/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
|
|
#pragma once
|
|
#include "bpf_arena_common.h"
|
|
|
|
struct arena_list_node;
|
|
|
|
typedef struct arena_list_node __arena arena_list_node_t;
|
|
|
|
struct arena_list_node {
|
|
arena_list_node_t *next;
|
|
arena_list_node_t * __arena *pprev;
|
|
};
|
|
|
|
struct arena_list_head {
|
|
struct arena_list_node __arena *first;
|
|
};
|
|
typedef struct arena_list_head __arena arena_list_head_t;
|
|
|
|
#define list_entry(ptr, type, member) arena_container_of(ptr, type, member)
|
|
|
|
#define list_entry_safe(ptr, type, member) \
|
|
({ typeof(*ptr) * ___ptr = (ptr); \
|
|
___ptr ? ({ cast_kern(___ptr); list_entry(___ptr, type, member); }) : NULL; \
|
|
})
|
|
|
|
#ifndef __BPF__
|
|
static inline void *bpf_iter_num_new(struct bpf_iter_num *it, int i, int j) { return NULL; }
|
|
static inline void bpf_iter_num_destroy(struct bpf_iter_num *it) {}
|
|
static inline bool bpf_iter_num_next(struct bpf_iter_num *it) { return true; }
|
|
#define cond_break ({})
|
|
#define can_loop true
|
|
#endif
|
|
|
|
/* Safely walk link list elements. Deletion of elements is allowed. */
|
|
#define list_for_each_entry(pos, head, member) \
|
|
for (void * ___tmp = (pos = list_entry_safe((head)->first, \
|
|
typeof(*(pos)), member), \
|
|
(void *)0); \
|
|
pos && ({ ___tmp = (void *)pos->member.next; 1; }) && can_loop; \
|
|
pos = list_entry_safe((void __arena *)___tmp, typeof(*(pos)), member))
|
|
|
|
static inline void list_add_head(arena_list_node_t *n, arena_list_head_t *h)
|
|
{
|
|
arena_list_node_t *first = h->first, * __arena *tmp;
|
|
|
|
cast_user(first);
|
|
cast_kern(n);
|
|
WRITE_ONCE(n->next, first);
|
|
cast_kern(first);
|
|
if (first) {
|
|
tmp = &n->next;
|
|
cast_user(tmp);
|
|
WRITE_ONCE(first->pprev, tmp);
|
|
}
|
|
cast_user(n);
|
|
WRITE_ONCE(h->first, n);
|
|
|
|
tmp = &h->first;
|
|
cast_user(tmp);
|
|
cast_kern(n);
|
|
WRITE_ONCE(n->pprev, tmp);
|
|
}
|
|
|
|
static inline void __list_del(arena_list_node_t *n)
|
|
{
|
|
arena_list_node_t *next = n->next, *tmp;
|
|
arena_list_node_t * __arena *pprev = n->pprev;
|
|
|
|
cast_user(next);
|
|
cast_kern(pprev);
|
|
tmp = *pprev;
|
|
cast_kern(tmp);
|
|
WRITE_ONCE(tmp, next);
|
|
if (next) {
|
|
cast_user(pprev);
|
|
cast_kern(next);
|
|
WRITE_ONCE(next->pprev, pprev);
|
|
}
|
|
}
|
|
|
|
#define POISON_POINTER_DELTA 0
|
|
|
|
#define LIST_POISON1 ((void __arena *) 0x100 + POISON_POINTER_DELTA)
|
|
#define LIST_POISON2 ((void __arena *) 0x122 + POISON_POINTER_DELTA)
|
|
|
|
static inline void list_del(arena_list_node_t *n)
|
|
{
|
|
__list_del(n);
|
|
n->next = LIST_POISON1;
|
|
n->pprev = LIST_POISON2;
|
|
}
|