bpf: Avoid locks in bpf_timer and bpf_wq
Subsystems (4)
v4 cover bpf: Avoid locks in bpf_timer and bpf_wq
This series reworks implementation of BPF timer and workqueue APIs. The goal is to make both timers and wq non-blocking, enabling their use in NMI context.
Today this code relies on a bpf_spin_lock embedded in the map element to serialize:
* init of the async object,
* setting/changing the callback and bpf_prog
* starting/cancelling the timer/work
* tearing down when the map element is deleted or the map’s user ref is dropped
The basic design approach in this series:
* Use irq_work to offload all blocking work from NMI
* Introduce refcount to guarantee lifetime of the bpf_async_cb structs deferred to potentially multiple irq_work callbacks
* Keep objects under RCU protection to make sure they are not freed while kfuncs/helpers access them (We can't use refcnt for this, as refcnt itself is part of the bpf_async_cb struct)
---
Changes in v4:
- Handle irq_work_queue failures in both schedule and cancel_and_free
paths: introduced bpf_async_refcnt_dec_cleanup() that decrements refcnt and makes sure if last reference is put, there is at least one irq_work scheduled to execute final cleanup.
- Additional refcnt inc/dec in set_callback() + rcu lock to make sure cleanup is not running at the same time as set_callback().
- Added READ_ONCE where it was needed.
- Squash 'bpf: Refactor __bpf_async_set_callback()' commit into 'bpf:
Add lock-free cell for NMI-safe
async operations'
- Removed mpmc_cell, use seqcount_latch_t instead.
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Major rework
- Introduce mpmc_cell, allowing concurrent writes and reads
- Implement irq_work deferring
- Adding selftests
- Introduces bpf_timer_cancel_async kfunc
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Move refcnt initialization and put (from cancel_and_free())
from patch 5 into the patch 4, so that patch 4 has more clear and full implementation and use of refcnt
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Mykyta Yatsenko (8):
bpf: Factor out timer deletion helper
bpf: Simplify bpf_timer_cancel()
bpf: Enable bpf timer and workqueue use in NMI
bpf: Add verifier support for bpf_timer argument in kfuncs
bpf: Introduce bpf_timer_cancel_async() kfunc selftests/bpf: Refactor timer selftests selftests/bpf: Add stress test for timer async cancel selftests/bpf: Verify bpf_timer_cancel_async works
kernel/bpf/helpers.c | 441 ++++++++++++++++--------- kernel/bpf/verifier.c | 59 +++- tools/testing/selftests/bpf/prog_tests/timer.c | 92 +++++- tools/testing/selftests/bpf/progs/timer.c | 37 ++- 4 files changed, 444 insertions(+), 185 deletions(-)
---
base-commit: 46c76760febfb14618d88f6a01fca2d93d003082
change-id: 20251028-timer_nolock-457f5b9daace
Best regards,
Signature · 1 line
Mykyta Yatsenko <[email protected]>
RFC PATCH v4 1/8 bpf: Factor out timer deletion helper
From: Mykyta Yatsenko <[email protected]>
Move the timer deletion logic into a dedicated bpf_timer_delete() helper so it can be reused by later patches.
--- kernel/bpf/helpers.c | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-)
kernel/bpf/helpers.c +18 -11
@@ -1558,18 +1558,10 @@ static struct bpf_async_cb *__bpf_async_cancel_and_free(struct bpf_async_kern *areturn cb; } -/* This function is called by map_delete/update_elem for individual element and -* by ops->map_release_uref when the user space reference to a map reaches zero. -*/ -void bpf_timer_cancel_and_free (void *val) +static void bpf_timer_delete (struct bpf_hrtimer *t) { -struct bpf_hrtimer *t; - - t = (struct bpf_hrtimer *)__bpf_async_cancel_and_free (val); - -if (!t) -return ; -/* We check that bpf_map_delete/update_elem() was called from timer +/* +* We check that bpf_map_delete/update_elem() was called from timer * callback_fn. In such case we don't call hrtimer_cancel() (since it * will deadlock) and don't call hrtimer_try_to_cancel() (since it will * just return -1). Though callback_fn is still running on this cpu it's
@@ -1618,6 +1610,21 @@ void bpf_timer_cancel_and_free(void *val) } } +/* +* This function is called by map_delete/update_elem for individual element and +* by ops->map_release_uref when the user space reference to a map reaches zero. +*/ +void bpf_timer_cancel_and_free (void *val) +{ +struct bpf_hrtimer *t; + + t = (struct bpf_hrtimer *)__bpf_async_cancel_and_free (val); +if (!t) +return ; + +bpf_timer_delete (t); +} +/* This function is called by map_delete/update_elem for individual element and * by ops->map_release_uref when the user space reference to a map reaches zero. */
Signature · 1 line
2.52.0
RFC PATCH v4 2/8 bpf: Simplify bpf_timer_cancel()
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Remove lock from the bpf_timer_cancel() helper. The lock does not protect from concurrent modification of the bpf_async_cb data fields as those are modified in the callback without locking.
Use guard(rcu)() instead of pair of explicit lock()/unlock().
--- kernel/bpf/helpers.c | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-)
kernel/bpf/helpers.c +14 -17
@@ -1465,7 +1465,7 @@ static void drop_prog_refcnt(struct bpf_async_cb *async) } } -BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer) +BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, async) {struct bpf_hrtimer *t, *cur_t;bool inc = false;
@@ -1473,13 +1473,12 @@ BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer)if (in_nmi ())return -EOPNOTSUPP ; -rcu_read_lock (); -__bpf_spin_lock_irqsave (&timer->lock); - t = timer->timer; -if (!t) { - ret = -EINVAL ; - goto out; - } + +guard (rcu)(); + + t =READ_ONCE (async->timer); +if (!t) +return -EINVAL ; cur_t =this_cpu_read (hrtimer_running);if (cur_t == t) {
@@ -1487,8 +1486,7 @@ BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer)* its own timer the hrtimer_cancel() will deadlock * since it waits for callback_fn to finish. */ - ret = -EDEADLK ; - goto out; +return -EDEADLK ; }/* Only account in-flight cancellations when invoked from a timer
@@ -1511,20 +1509,19 @@ BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer)* cancelling and waiting for it synchronously, since it might * do the same. Bail! */ - ret = -EDEADLK ; - goto out; +atomic_dec (&t->cancelling); +return -EDEADLK ; } + drop: -drop_prog_refcnt (&t->cb); -out: -__bpf_spin_unlock_irqrestore (&timer->lock); +__bpf_async_set_callback (async,NULL ,NULL );/* Cancel the timer and wait for associated callback to finish * if it was running. */ - ret = ret ?:hrtimer_cancel (&t->timer); + ret =hrtimer_cancel (&t->timer); +if (inc)atomic_dec (&t->cancelling); -rcu_read_unlock ();return ret; }
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH RFC v4 2/8] bpf: Simplify bpf_timer_cancel()
Does this call __bpf_async_set_callback() with only 3 arguments when the function signature requires 5?
Quoted 4 lines
kernel/bpf/helpers.c +0
-0
[ ... ]
Quoted 5 lines
kernel/bpf/helpers.c +0
-1@@ -1511,20 +1509,19 @@ BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer)* cancelling and waiting for it synchronously, since it might * do the same. Bail! */ - ret = -EDEADLK ;
kernel/bpf/helpers.c BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer) · line 1517
Quoted 10 lines
kernel/bpf/helpers.c +4
-4- goto out; +atomic_dec (&t->cancelling); +return -EDEADLK ; } + drop: -drop_prog_refcnt (&t->cb); -out: -__bpf_spin_unlock_irqrestore (&timer->lock); +__bpf_async_set_callback (async,NULL ,NULL );
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Does this call __bpf_async_set_callback() with only 3 arguments when the function signature requires 5?
Looking at __bpf_async_set_callback() defined earlier in the same file:
static int __bpf_async_set_callback(struct bpf_async_kern *async,
void *callback_fn,
struct bpf_prog_aux *aux,
unsigned int flags,
enum bpf_async_type type)
{
struct bpf_prog *prev, *prog = aux->prog;
...
}The call passes (async, NULL, NULL) where aux=NULL, but the first line of the function dereferences aux->prog which would crash. The old code called drop_prog_refcnt(&t->cb) instead which is a 1-argument function that safely handles the callback cleanup.
This appears to be a bisection-breaking regression. A fix appears later in the series at commit 250c67a454a9 ("bpf: Enable bpf timer and workqueue use in NMI") which changes __bpf_async_set_callback() to take 3 arguments, but until that patch is applied this commit would cause a NULL pointer dereference whenever bpf_timer_cancel() reaches the drop label.
kernel/bpf/helpers.c BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, timer) · line 1520
Quoted 3 lines
kernel/bpf/helpers.c +0
-0/* Cancel the timer and wait for associated callback to finish * if it was running. */
[ ... ]
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21005624319
RFC PATCH v4 3/8 bpf: Enable bpf timer and workqueue use in NMI
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Refactor bpf timer and workqueue helpers to allow calling them from NMI context by making all operations lock-free and deferring NMI-unsafe work to irq_work.
Previously, bpf_timer_start(), and bpf_wq_start()
could not be called from NMI context because they acquired bpf_spin_lock and called hrtimer/schedule_work APIs directly. This patch removes these limitations.
Key changes:
* Remove bpf_spin_lock from struct bpf_async_kern. Replace locked operations with atomic cmpxchg() for initialization and xchg() for cancel and free.
* Add per-async irq_work to defer NMI-unsafe operations (hrtimer_start, hrtimer_try_to_cancel, schedule_work) from NMI to softirq context.
* Use the lock-free seqcount_latch_t to pass operation commands (start/cancel/free) along with their parameters (nsec, mode) from NMI-safe callers to the irq_work handler.
* Add reference counting to bpf_async_cb to ensure the object stays alive until all scheduled irq_work completes and the timer/work callback finishes.
* Move bpf_prog_put() to RCU callback to handle races between set_callback() and cancel_and_free().
* Refactor __bpf_async_set_callback() getting rid of locks. The idea of the algorithm is to store both callback_fn and prog in struct bpf_async_cb and verify that both pointers are stored, if any pointer does not match (because of the concurrent update), retry until complete match.
On each iteration, increment refcnt of the prog that is going to be set and decrement the one that is evicted, ensuring that get/put are balanced, as each iteration has both inc/dec.
This enables BPF programs attached to NMI-context hooks (perf events) to use timers and workqueues for deferred processing.
--- kernel/bpf/helpers.c | 381 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 243 insertions(+), 138 deletions(-)
kernel/bpf/helpers.c +243 -138
@@ -29,6 +29,7 @@#include <linux/task_work.h> #include <linux/irq_work.h> #include <linux/buildid.h> +#include <linux/seqlock.h> #include "../../lib/kstrtox.h"
@@ -1095,6 +1096,23 @@ static void *map_key_from_value(struct bpf_map *map, void *value, u32 *arr_idx)return (void *)value -round_up (map->key_size,8 ); } +enum bpf_async_type { +BPF_ASYNC_TYPE_TIMER =0 , +BPF_ASYNC_TYPE_WQ , +}; + +enum bpf_async_op { +BPF_ASYNC_START , +BPF_ASYNC_CANCEL , +BPF_ASYNC_CANCEL_AND_FREE , +}; + +struct bpf_async_cmd { +u64 nsec; +u32 mode; +u32 op; +}; +struct bpf_async_cb {struct bpf_map *map;struct bpf_prog *prog;
@@ -1105,6 +1123,13 @@ struct bpf_async_cb {struct work_struct delete_work; };u64 flags; +struct irq_work worker; +atomic_t writer; +seqcount_latch_t latch; +struct bpf_async_cmd cmd[2 ]; +atomic_t last_seq; +refcount_t refcnt; +enum bpf_async_type type; };/* BPF map elements can contain 'struct bpf_timer'.
@@ -1142,18 +1167,9 @@ struct bpf_async_kern {struct bpf_hrtimer *timer;struct bpf_work *work; }; -/* bpf_spin_lock is used here instead of spinlock_t to make -* sure that it always fits into space reserved by struct bpf_timer -* regardless of LOCKDEP and spinlock debug flags. -*/ -struct bpf_spin_lock lock; +u32 __opaque; } __attribute__((aligned(8))); -enum bpf_async_type { -BPF_ASYNC_TYPE_TIMER =0 , -BPF_ASYNC_TYPE_WQ , -}; - static DEFINE_PER_CPU(struct bpf_hrtimer *, hrtimer_running);static enum hrtimer_restart bpf_timer_cb (struct hrtimer *hrtimer)
@@ -1219,6 +1235,13 @@ static void bpf_async_cb_rcu_free(struct rcu_head *rcu) { struct bpf_async_cb *cb = container_of(rcu, struct bpf_async_cb, rcu); +/* +* Drop the last reference to prog only after RCU GP, as set_callback() +* may race with cancel_and_free() +*/ +if (cb->prog) +bpf_prog_put (cb->prog); +kfree_nolock (cb); }
@@ -1246,18 +1269,17 @@ static void bpf_timer_delete_work(struct work_struct *work)call_rcu (&t->cb.rcu, bpf_async_cb_rcu_free); } +static void __bpf_async_cancel_and_free (struct bpf_async_kern *async); +static void bpf_async_irq_worker (struct irq_work *work); +static int __bpf_async_init (struct bpf_async_kern *async,struct bpf_map *map,u64 flags,enum bpf_async_type type) { -struct bpf_async_cb *cb; +struct bpf_async_cb *cb, *old_cb;struct bpf_hrtimer *t;struct bpf_work *w;clockid_t clockid;size_t size; -int ret =0 ; - -if (in_nmi ()) -return -EOPNOTSUPP ;switch (type) {case BPF_ASYNC_TYPE_TIMER :
@@ -1270,18 +1292,13 @@ static int __bpf_async_init(struct bpf_async_kern *async, struct bpf_map *map, ureturn -EINVAL ; } -__bpf_spin_lock_irqsave (&async->lock); - t = async->timer; -if (t) { - ret = -EBUSY ; - goto out; - } + old_cb =READ_ONCE (async->cb); +if (old_cb) +return -EBUSY ; cb =bpf_map_kmalloc_nolock (map, size,0 , map->numa_node); -if (!cb) { - ret = -ENOMEM ; - goto out; - } +if (!cb) +return -ENOMEM ;switch (type) {case BPF_ASYNC_TYPE_TIMER :
@@ -1304,9 +1321,20 @@ static int __bpf_async_init(struct bpf_async_kern *async, struct bpf_map *map, u cb->map = map; cb->prog =NULL ; cb->flags = flags; + cb->worker =IRQ_WORK_INIT (bpf_async_irq_worker); +seqcount_latch_init (&cb->latch); +atomic_set (&cb->writer,0 ); +refcount_set (&cb->refcnt,1 );/* map's reference */ +atomic_set (&cb->last_seq,0 ); + cb->type = type;rcu_assign_pointer (cb->callback_fn,NULL ); -WRITE_ONCE (async->cb, cb); + old_cb =cmpxchg (&async->cb,NULL , cb); +if (old_cb) { +/* Lost the race to initialize this bpf_async_kern, drop the allocated object */ +kfree_nolock (cb); +return -EBUSY ; + }/* Guarantee the order between async->cb and map->usercnt. So * when there are concurrent uref release and bpf timer init, either * bpf_timer_cancel_and_free() called by uref release reads a no-NULL
@@ -1317,13 +1345,11 @@ static int __bpf_async_init(struct bpf_async_kern *async, struct bpf_map *map, u/* maps with timers must be either held by user space * or pinned in bpffs. */ -WRITE_ONCE (async->cb,NULL ); -kfree_nolock (cb); - ret = -EPERM ; +__bpf_async_cancel_and_free (async); +return -EPERM ; } -out: -__bpf_spin_unlock_irqrestore (&async->lock); -return ret; + +return 0 ; } BPF_CALL_3(bpf_timer_init, struct bpf_async_kern *, timer, struct bpf_map *, map,
@@ -1354,56 +1380,119 @@ static const struct bpf_func_proto bpf_timer_init_proto = { .arg3_type = ARG_ANYTHING, }; +/* Decrements bpf_async_cb refcnt, if it becomes 0 schedule cleanup irq_work */ +static void bpf_async_refcnt_dec_cleanup (struct bpf_async_cb *cb) +{ +if (!refcount_dec_and_test (&cb->refcnt)) +return ; + +/* +* At this point we took the last reference +* Try to schedule cleanup, either: +* - Set ref to 1 and succeed irq_work_queue +* - See non-zero refcnt after decrement - other irq_work is going to cleanup +*/ +do { +refcount_set (&cb->refcnt,1 ); +if (irq_work_queue (&cb->worker)) +break ; + }while (refcount_dec_and_test (&cb->refcnt)); +} + +static int bpf_async_schedule_op (struct bpf_async_cb *cb,u32 op,u64 nsec,u32 timer_mode) +{ +/* Acquire active writer atomic*/ +if (atomic_cmpxchg_acquire (&cb->writer,0 ,1 )) +return -EBUSY ; + +write_seqcount_latch_begin (&cb->latch); + cb->cmd[0 ].nsec = nsec; + cb->cmd[0 ].mode = timer_mode; + cb->cmd[0 ].op = op; +write_seqcount_latch (&cb->latch); + cb->cmd[1 ].nsec = nsec; + cb->cmd[1 ].mode = timer_mode; + cb->cmd[1 ].op = op; +write_seqcount_latch_end (&cb->latch); +atomic_set (&cb->writer,0 ); + +if (!refcount_inc_not_zero (&cb->refcnt)) +return -EBUSY ; + +/* TODO: Run operation without irq_work if not in NMI */ +if (!irq_work_queue (&cb->worker)) +/* irq_work is already scheduled on this CPU */ +bpf_async_refcnt_dec_cleanup (cb); + +return 0 ; +} + +static int bpf_async_read_op (struct bpf_async_cb *cb,enum bpf_async_op *op, +u64 *nsec,u32 *flags) +{ +u32 seq, last_seq, idx; + +while (true) { + last_seq =atomic_read_acquire (&cb->last_seq); + + seq =raw_read_seqcount_latch (&cb->latch); + +/* Return -EBUSY if current seq is consumed by another reader */ +if (seq == last_seq) +return -EBUSY ; + + idx = seq &1 ; + *nsec = cb->cmd[idx].nsec; + *flags = cb->cmd[idx].mode; + *op = cb->cmd[idx].op; + +if (raw_read_seqcount_latch_retry (&cb->latch, seq)) +continue ; +/* Commit read sequence number, own snapshot exclusively */ +if (atomic_cmpxchg_release (&cb->last_seq, last_seq, seq) == last_seq) +break ; + } + +return 0 ; +} +static int __bpf_async_set_callback (struct bpf_async_kern *async,void *callback_fn, -struct bpf_prog_aux *aux,unsigned int flags, -enum bpf_async_type type) +struct bpf_prog *prog) { -struct bpf_prog *prev, *prog = aux->prog; +struct bpf_prog *prev;struct bpf_async_cb *cb; -int ret =0 ; -if (in_nmi ()) -return -EOPNOTSUPP ; -__bpf_spin_lock_irqsave (&async->lock); - cb = async->cb; -if (!cb) { - ret = -EINVAL ; - goto out; - } -if (!atomic64_read (&cb->map->usercnt)) { -/* maps with timers must be either held by user space -* or pinned in bpffs. Otherwise timer might still be -* running even when bpf prog is detached and user space -* is gone, since map_release_uref won't ever be called. -*/ - ret = -EPERM ; - goto out; - } - prev = cb->prog; -if (prev != prog) { -/* Bump prog refcnt once. Every bpf_timer_set_callback() -* can pick different callback_fn-s within the same prog. -*/ +/* Make sure bpf_async_cb_rcu_free() is not called while here */ +guard (rcu)(); + + cb =READ_ONCE (async->cb); +if (!cb || !prog) +return -EINVAL ; + +/* Additional prog's refcnt to make sure it is not dropped to 0 in the loop */ + prog =bpf_prog_inc_not_zero (prog); +if (IS_ERR (prog)) +return PTR_ERR (prog); + +do { prog =bpf_prog_inc_not_zero (prog); -if (IS_ERR (prog)) { - ret =PTR_ERR (prog); - goto out; - } + prev =xchg (&cb->prog, prog); +rcu_assign_pointer (cb->callback_fn, callback_fn); +if (prev) -/* Drop prev prog refcnt when swapping with new prog */ bpf_prog_put (prev); - cb->prog = prog; - } -rcu_assign_pointer (cb->callback_fn, callback_fn); -out: -__bpf_spin_unlock_irqrestore (&async->lock); -return ret; + + }while (READ_ONCE (cb->prog) != prog ||READ_ONCE (cb->callback_fn) != callback_fn); + +bpf_prog_put (prog); + +return 0 ; } BPF_CALL_3(bpf_timer_set_callback, struct bpf_async_kern *, timer, void *, callback_fn, struct bpf_prog_aux *, aux) { -return __bpf_async_set_callback (timer, callback_fn, aux,0 ,BPF_ASYNC_TYPE_TIMER ); +return __bpf_async_set_callback (timer, callback_fn, aux->prog); }static const struct bpf_func_proto bpf_timer_set_callback_proto = {
@@ -1414,22 +1503,19 @@ static const struct bpf_func_proto bpf_timer_set_callback_proto = { .arg2_type = ARG_PTR_TO_FUNC, }; -BPF_CALL_3(bpf_timer_start, struct bpf_async_kern *, timer, u64, nsecs, u64, flags) +BPF_CALL_3(bpf_timer_start, struct bpf_async_kern *, async, u64, nsecs, u64, flags) {struct bpf_hrtimer *t; -int ret =0 ; -enum hrtimer_mode mode; +u32 mode; -if (in_nmi ()) -return -EOPNOTSUPP ;if (flags & ~(BPF_F_TIMER_ABS |BPF_F_TIMER_CPU_PIN ))return -EINVAL ; -__bpf_spin_lock_irqsave (&timer->lock); - t = timer->timer; -if (!t || !t->cb.prog) { - ret = -EINVAL ; - goto out; - } + +guard (rcu)(); + + t =READ_ONCE (async->timer); +if (!t || !READ_ONCE (t->cb.prog)) +return -EINVAL ;if (flags &BPF_F_TIMER_ABS ) mode =HRTIMER_MODE_ABS_SOFT ;
@@ -1439,10 +1525,7 @@ BPF_CALL_3(bpf_timer_start, struct bpf_async_kern *, timer, u64, nsecs, u64, flaif (flags &BPF_F_TIMER_CPU_PIN ) mode |=HRTIMER_MODE_PINNED ; -hrtimer_start (&t->timer,ns_to_ktime (nsecs), mode); -out: -__bpf_spin_unlock_irqrestore (&timer->lock); -return ret; +return bpf_async_schedule_op (&t->cb,BPF_ASYNC_START , nsecs, mode); }static const struct bpf_func_proto bpf_timer_start_proto = {
@@ -1454,17 +1537,6 @@ static const struct bpf_func_proto bpf_timer_start_proto = { .arg3_type = ARG_ANYTHING, }; -static void drop_prog_refcnt (struct bpf_async_cb *async) -{ -struct bpf_prog *prog = async->prog; - -if (prog) { -bpf_prog_put (prog); - async->prog =NULL ; -rcu_assign_pointer (async->callback_fn,NULL ); - } -} - BPF_CALL_1(bpf_timer_cancel, struct bpf_async_kern *, async) {struct bpf_hrtimer *t, *cur_t;
@@ -1532,27 +1604,16 @@ static const struct bpf_func_proto bpf_timer_cancel_proto = { .arg1_type = ARG_PTR_TO_TIMER, }; -static struct bpf_async_cb *__bpf_async_cancel_and_free (struct bpf_async_kern *async) +static void __bpf_async_cancel_and_free (struct bpf_async_kern *async) {struct bpf_async_cb *cb; -/* Performance optimization: read async->cb without lock first. */ -if (!READ_ONCE (async->cb)) -return NULL ; - -__bpf_spin_lock_irqsave (&async->lock); -/* re-read it under lock */ - cb = async->cb; + cb =xchg (&async->cb,NULL );if (!cb) - goto out; -drop_prog_refcnt (cb); -/* The subsequent bpf_timer_start/cancel() helpers won't be able to use -* this timer, since it won't be initialized. -*/ -WRITE_ONCE (async->cb,NULL ); -out: -__bpf_spin_unlock_irqrestore (&async->lock); -return cb; +return ; + +/* Consume map's own refcnt, schedule cleanup irq_work if this is the last ref */ +bpf_async_refcnt_dec_cleanup (cb); }static void bpf_timer_delete (struct bpf_hrtimer *t)
@@ -1607,19 +1668,76 @@ static void bpf_timer_delete(struct bpf_hrtimer *t) } } +static void bpf_async_process_op (struct bpf_async_cb *cb,u32 op, +u64 timer_nsec,u32 timer_mode) +{ +switch (cb->type) { +case BPF_ASYNC_TYPE_TIMER : { + struct bpf_hrtimer *t = container_of(cb, struct bpf_hrtimer, cb); + +switch (op) { +case BPF_ASYNC_START : +hrtimer_start (&t->timer,ns_to_ktime (timer_nsec), timer_mode); +break ; +case BPF_ASYNC_CANCEL : +hrtimer_try_to_cancel (&t->timer); +break ; +case BPF_ASYNC_CANCEL_AND_FREE : +bpf_timer_delete (t); +break ; +default : +break ; + } +break ; + } +case BPF_ASYNC_TYPE_WQ : { + struct bpf_work *w = container_of(cb, struct bpf_work, cb); + +switch (op) { +case BPF_ASYNC_START : +schedule_work (&w->work); +break ; +case BPF_ASYNC_CANCEL_AND_FREE : +/* +* Trigger cancel of the sleepable work, but *do not* wait for +* it to finish. +* kfree will be called once the work has finished. +*/ +schedule_work (&w->delete_work); +break ; +default : +break ; + } +break ; + } + } +} + +static void bpf_async_irq_worker (struct irq_work *work) +{ + struct bpf_async_cb *cb = container_of(work, struct bpf_async_cb, worker); +u32 op, timer_mode; +u64 nsec; +int err; + + err =bpf_async_read_op (cb, &op, &nsec, &timer_mode); +if (err) + goto out; + +bpf_async_process_op (cb, op, nsec, timer_mode); + +out: +if (refcount_dec_and_test (&cb->refcnt)) +bpf_async_process_op (cb,BPF_ASYNC_CANCEL_AND_FREE ,0 ,0 ); +} +/* * This function is called by map_delete/update_elem for individual element and * by ops->map_release_uref when the user space reference to a map reaches zero. */ void bpf_timer_cancel_and_free (void *val) { -struct bpf_hrtimer *t; - - t = (struct bpf_hrtimer *)__bpf_async_cancel_and_free (val); -if (!t) -return ; - -bpf_timer_delete (t); +__bpf_async_cancel_and_free (val); }/* This function is called by map_delete/update_elem for individual element and
@@ -1627,19 +1745,7 @@ void bpf_timer_cancel_and_free(void *val)*/ void bpf_wq_cancel_and_free (void *val) { -struct bpf_work *work; - -BTF_TYPE_EMIT (struct bpf_wq ); - - work = (struct bpf_work *)__bpf_async_cancel_and_free (val); -if (!work) -return ; -/* Trigger cancel of the sleepable work, but *do not* wait for -* it to finish if it was running as we might not be in a -* sleepable context. -* kfree will be called once the work has finished. -*/ -schedule_work (&work->delete_work); +__bpf_async_cancel_and_free (val); } BPF_CALL_2(bpf_kptr_xchg, void *, dst, void *, ptr)
@@ -3112,16 +3218,15 @@ __bpf_kfunc int bpf_wq_start(struct bpf_wq *wq, unsigned int flags)struct bpf_async_kern *async = (struct bpf_async_kern *)wq;struct bpf_work *w; -if (in_nmi ()) -return -EOPNOTSUPP ;if (flags)return -EINVAL ; + +guard (rcu)(); w =READ_ONCE (async->work);if (!w || !READ_ONCE (w->cb.prog))return -EINVAL ; -schedule_work (&w->work); -return 0 ; +return bpf_async_schedule_op (&w->cb,BPF_ASYNC_START ,0 ,0 ); } __bpf_kfunc int bpf_wq_set_callback_impl(struct bpf_wq *wq,
@@ -3135,7 +3240,7 @@ __bpf_kfunc int bpf_wq_set_callback_impl(struct bpf_wq *wq,if (flags)return -EINVAL ; -return __bpf_async_set_callback (async, callback_fn, aux, flags,BPF_ASYNC_TYPE_WQ ); +return __bpf_async_set_callback (async, callback_fn, aux->prog); } __bpf_kfunc void bpf_preempt_disable(void)
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH RFC v4 3/8] bpf: Enable bpf timer and workqueue use in NMI
Can this loop leak BPF program references? If the loop iterates more than once due to concurrent modification, each iteration calls bpf_prog_inc_not_zero(prog) which increments the reference count.…
Quoted 4 lines
kernel/bpf/helpers.c +0
-0
[ ... ]
Quoted 57 lines
kernel/bpf/helpers.c +19
-32+static int __bpf_async_set_callback (struct bpf_async_kern *async,void *callback_fn, +struct bpf_prog *prog) { -struct bpf_prog *prev, *prog = aux->prog; +struct bpf_prog *prev;struct bpf_async_cb *cb; -int ret =0 ; -if (in_nmi ()) -return -EOPNOTSUPP ; -__bpf_spin_lock_irqsave (&async->lock); - cb = async->cb; -if (!cb) { - ret = -EINVAL ; - goto out; - } -if (!atomic64_read (&cb->map->usercnt)) { -/* maps with timers must be either held by user space -* or pinned in bpffs. Otherwise timer might still be -* running even when bpf prog is detached and user space -* is gone, since map_release_uref won't ever be called. -*/ - ret = -EPERM ; - goto out; - } - prev = cb->prog; -if (prev != prog) { -/* Bump prog refcnt once. Every bpf_timer_set_callback() -* can pick different callback_fn-s within the same prog. -*/ +/* Make sure bpf_async_cb_rcu_free() is not called while here */ +guard (rcu)(); + + cb =READ_ONCE (async->cb); +if (!cb || !prog) +return -EINVAL ; + +/* Additional prog's refcnt to make sure it is not dropped to 0 in the loop */ + prog =bpf_prog_inc_not_zero (prog); +if (IS_ERR (prog)) +return PTR_ERR (prog); + + do { prog = bpf_prog_inc_not_zero(prog); -if (IS_ERR (prog)) { - ret =PTR_ERR (prog); - goto out; - } + prev = xchg(&cb->prog, prog); + rcu_assign_pointer(cb->callback_fn, callback_fn); + if (prev) -/* Drop prev prog refcnt when swapping with new prog */ bpf_prog_put(prev); - cb->prog = prog; - } -rcu_assign_pointer (cb->callback_fn, callback_fn);
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_timer_init_proto = { · line 1490
Quoted 10 lines
kernel/bpf/helpers.c +6
-3-out: -__bpf_spin_unlock_irqrestore (&async->lock); -return ret; + + }while (READ_ONCE (cb->prog) != prog ||READ_ONCE (cb->callback_fn) != callback_fn); + +bpf_prog_put (prog); + +return 0 ; }
Can this loop leak BPF program references? If the loop iterates more than once due to concurrent modification, each iteration calls bpf_prog_inc_not_zero(prog) which increments the reference count. The bpf_prog_put(prev) only releases the old cb->prog reference, not the accumulated references on prog.
For example, if the loop runs twice:
- iter 1: bpf_prog_inc_not_zero(prog) increments refcnt
- iter 1: xchg stores prog in cb->prog, bpf_prog_put(prev) puts old value
- (concurrent modification changes cb->prog)
- iter 2: bpf_prog_inc_not_zero(prog) increments refcnt again
- iter 2: xchg stores prog, bpf_prog_put(prev) puts concurrently stored value
- after loop: bpf_prog_put(prog) releases only one reference
The commit message states "ensuring that get/put are balanced, as each iteration has both inc/dec", but the dec (bpf_prog_put) operates on prev, not on prog. When prev is a different object than prog, the reference taken on prog in that iteration is never released.
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21005624319
RFC PATCH v4 4/8 bpf: Add verifier support for bpf_timer argument in kfuncs
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Extend the verifier to recognize struct bpf_timer as a valid kfunc argument type. Previously, bpf_timer was only supported in BPF helpers.
This prepares for adding timer-related kfuncs in subsequent patches.
--- kernel/bpf/verifier.c | 59 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 6 deletions(-)
kernel/bpf/verifier.c +53 -6
@@ -8566,17 +8566,15 @@ static int check_map_field_pointer(struct bpf_verifier_env *env, u32 regno, }static int process_timer_func (struct bpf_verifier_env *env,int regno, -struct bpf_call_arg_meta *meta) +struct bpf_map *map) { -struct bpf_reg_state *reg =reg_state (env, regno); -struct bpf_map *map = reg->map_ptr;int err; err =check_map_field_pointer (env, regno,BPF_TIMER );if (err)return err; -if (meta->map_ptr) { +if (map) {verifier_bug (env,"Two map pointers in a timer helper" );return -EFAULT ; }
@@ -8584,8 +8582,36 @@ static int process_timer_func(struct bpf_verifier_env *env, int regno,verbose (env,"bpf_timer cannot be used for PREEMPT_RT.\n" );return -EOPNOTSUPP ; } +return 0 ; +} + +static int process_timer_helper (struct bpf_verifier_env *env,int regno, +struct bpf_call_arg_meta *meta) +{ +struct bpf_reg_state *reg =reg_state (env, regno); +int err; + + err =process_timer_func (env, regno, meta->map_ptr); +if (err) +return err; + meta->map_uid = reg->map_uid; - meta->map_ptr = map; + meta->map_ptr = reg->map_ptr; +return 0 ; +} + +static int process_timer_kfunc (struct bpf_verifier_env *env,int regno, +struct bpf_kfunc_call_arg_meta *meta) +{ +struct bpf_reg_state *reg =reg_state (env, regno); +int err; + + err =process_timer_func (env, regno, meta->map.ptr); +if (err) +return err; + + meta->map.uid = reg->map_uid; + meta->map.ptr = reg->map_ptr;return 0 ; }
@@ -9908,7 +9934,7 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, }break ;case ARG_PTR_TO_TIMER : - err =process_timer_func (env, regno, meta); + err =process_timer_helper (env, regno, meta);if (err)return err;break ;
@@ -12161,6 +12187,7 @@ enum {KF_ARG_WORKQUEUE_ID ,KF_ARG_RES_SPIN_LOCK_ID ,KF_ARG_TASK_WORK_ID , +KF_ARG_TIMER_ID , };BTF_ID_LIST (kf_arg_btf_ids)
@@ -12172,6 +12199,7 @@ BTF_ID(struct, bpf_rb_node) BTF_ID(struct, bpf_wq) BTF_ID(struct, bpf_res_spin_lock) BTF_ID(struct, bpf_task_work) +BTF_ID(struct, bpf_timer)static bool __is_kfunc_ptr_arg_type (const struct btf *btf,const struct btf_param *arg,int type)
@@ -12215,6 +12243,11 @@ static bool is_kfunc_arg_rbtree_node(const struct btf *btf, const struct btf_parreturn __is_kfunc_ptr_arg_type (btf, arg,KF_ARG_RB_NODE_ID ); } +static bool is_kfunc_arg_timer (const struct btf *btf,const struct btf_param *arg) +{ +return __is_kfunc_ptr_arg_type (btf, arg,KF_ARG_TIMER_ID ); +} +static bool is_kfunc_arg_wq (const struct btf *btf,const struct btf_param *arg) {return __is_kfunc_ptr_arg_type (btf, arg,KF_ARG_WORKQUEUE_ID );
@@ -12309,6 +12342,7 @@ enum kfunc_ptr_arg_type {KF_ARG_PTR_TO_NULL ,KF_ARG_PTR_TO_CONST_STR ,KF_ARG_PTR_TO_MAP , +KF_ARG_PTR_TO_TIMER ,KF_ARG_PTR_TO_WORKQUEUE ,KF_ARG_PTR_TO_IRQ_FLAG , KF_ARG_PTR_TO_RES_SPIN_LOCK,
@@ -12554,6 +12588,9 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,if (is_kfunc_arg_wq (meta->btf, &args[argno]))return KF_ARG_PTR_TO_WORKQUEUE ; +if (is_kfunc_arg_timer (meta->btf, &args[argno])) +return KF_ARG_PTR_TO_TIMER ; +if (is_kfunc_arg_task_work (meta->btf, &args[argno]))return KF_ARG_PTR_TO_TASK_WORK ;
@@ -13340,6 +13377,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_REFCOUNTED_KPTR :case KF_ARG_PTR_TO_CONST_STR :case KF_ARG_PTR_TO_WORKQUEUE : +case KF_ARG_PTR_TO_TIMER :case KF_ARG_PTR_TO_TASK_WORK :case KF_ARG_PTR_TO_IRQ_FLAG :case KF_ARG_PTR_TO_RES_SPIN_LOCK :
@@ -13639,6 +13677,15 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_if (ret <0 )return ret;break ; +case KF_ARG_PTR_TO_TIMER : +if (reg->type !=PTR_TO_MAP_VALUE ) { +verbose (env,"arg#%d doesn't point to a map value\n" , i); +return -EINVAL ; + } + ret =process_timer_kfunc (env, regno, meta); +if (ret <0 ) +return ret; +break ;case KF_ARG_PTR_TO_TASK_WORK :if (reg->type !=PTR_TO_MAP_VALUE ) {verbose (env,"arg#%d doesn't point to a map value\n" , i);
Signature · 1 line
2.52.0
RFC PATCH v4 5/8 bpf: Introduce bpf_timer_cancel_async() kfunc
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
introducing bpf timer cancel kfunc that attempts canceling timer asynchronously, hence, supports working in NMI context.
--- kernel/bpf/helpers.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
kernel/bpf/helpers.c +14 -0
@@ -4469,6 +4469,19 @@ __bpf_kfunc int bpf_dynptr_file_discard(struct bpf_dynptr *dynptr)return 0 ; } +__bpf_kfunc int bpf_timer_cancel_async(struct bpf_timer *timer) +{ +struct bpf_async_cb *cb; +struct bpf_async_kern *async = (void *)timer; + +guard (rcu)(); + cb =READ_ONCE (async->cb); +if (!cb) +return -EINVAL ; + +return bpf_async_schedule_op (cb,BPF_ASYNC_CANCEL ,0 ,0 ); +} +__bpf_kfunc_end_defs ();static void bpf_task_work_cancel_scheduled (struct irq_work *irq_work)
@@ -4650,6 +4663,7 @@ BTF_ID_FLAGS(func, bpf_task_work_schedule_signal_impl) BTF_ID_FLAGS(func, bpf_task_work_schedule_resume_impl) BTF_ID_FLAGS(func, bpf_dynptr_from_file) BTF_ID_FLAGS(func, bpf_dynptr_file_discard) +BTF_ID_FLAGS(func, bpf_timer_cancel_async)BTF_KFUNCS_END (common_btf_ids) static const struct btf_kfunc_id_set common_kfunc_set = {
Signature · 1 line
2.52.0
RFC PATCH v4 6/8 selftests/bpf: Refactor timer selftests
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Refactor timer selftests, extracting stress test into a separate test. This makes it easier to debug test failures and allows to extend.
--- tools/testing/selftests/bpf/prog_tests/timer.c | 55 +++++++++++++++++--------- 1 file changed, 36 insertions(+), 19 deletions(-)
tools/testing/selftests/bpf/prog_tests/timer.c +36 -19
@@ -22,13 +22,35 @@ static void *spin_lock_thread(void *arg)pthread_exit (arg); } -static int timer (struct timer *timer_skel) + +static int timer_stress (struct timer *timer_skel) { -int i, err, prog_fd; +int i, err =1 , prog_fd;LIBBPF_OPTS (bpf_test_run_opts, topts);pthread_t thread_id[NUM_THR ];void *ret; + prog_fd =bpf_program__fd (timer_skel->progs.race); +for (i =0 ; i <NUM_THR ; i++) { + err =pthread_create (&thread_id[i],NULL , + &spin_lock_thread, &prog_fd); +if (!ASSERT_OK (err,"pthread_create" )) +break ; + } + +while (i) { + err =pthread_join (thread_id[--i], &ret); +if (ASSERT_OK (err,"pthread_join" )) +ASSERT_EQ (ret, (void *)&prog_fd,"pthread_join" ); + } +return err; +} + +static int timer (struct timer *timer_skel) +{ +int err, prog_fd; +LIBBPF_OPTS (bpf_test_run_opts, topts); + err =timer__attach (timer_skel);if (!ASSERT_OK (err,"timer_attach" ))return err;
@@ -63,25 +85,10 @@ static int timer(struct timer *timer_skel)/* check that code paths completed */ ASSERT_EQ (timer_skel->bss->ok,1 |2 |4 ,"ok" ); - prog_fd =bpf_program__fd (timer_skel->progs.race); -for (i =0 ; i <NUM_THR ; i++) { - err =pthread_create (&thread_id[i],NULL , - &spin_lock_thread, &prog_fd); -if (!ASSERT_OK (err,"pthread_create" )) -break ; - } - -while (i) { - err =pthread_join (thread_id[--i], &ret); -if (ASSERT_OK (err,"pthread_join" )) -ASSERT_EQ (ret, (void *)&prog_fd,"pthread_join" ); - } -return 0 ; } -/* TODO: use pid filtering */ -void serial_test_timer (void ) +static void test_timer (int (*timer_test_fn)(struct timer *timer_skel)) {struct timer *timer_skel =NULL ;int err;
@@ -94,13 +101,23 @@ void serial_test_timer(void)if (!ASSERT_OK_PTR (timer_skel,"timer_skel_load" ))return ; - err =timer (timer_skel); + err =timer_test_fn (timer_skel);ASSERT_OK (err,"timer" );timer__destroy (timer_skel); +} + +void serial_test_timer (void ) +{ +test_timer (timer);RUN_TESTS (timer_failure); } +void serial_test_timer_stress (void ) +{ +test_timer (timer_stress); +} +void test_timer_interrupt (void ) {struct timer_interrupt *skel =NULL ;
Signature · 1 line
2.52.0
RFC PATCH v4 7/8 selftests/bpf: Add stress test for timer async cancel
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Extend BPF timer selftest to run stress test for async cancel.
--- tools/testing/selftests/bpf/prog_tests/timer.c | 18 +++++++++++++++++- tools/testing/selftests/bpf/progs/timer.c | 14 +++++++++++--- 2 files changed, 28 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/prog_tests/timer.c +17 -1
@@ -23,13 +23,14 @@ static void *spin_lock_thread(void *arg) } -static int timer_stress (struct timer *timer_skel) +static int timer_stress_runner (struct timer *timer_skel,bool async_cancel) {int i, err =1 , prog_fd;LIBBPF_OPTS (bpf_test_run_opts, topts);pthread_t thread_id[NUM_THR ];void *ret; + timer_skel->bss->async_cancel = async_cancel; prog_fd =bpf_program__fd (timer_skel->progs.race);for (i =0 ; i <NUM_THR ; i++) { err = pthread_create(&thread_id[i], NULL,
@@ -46,6 +47,16 @@ static int timer_stress(struct timer *timer_skel)return err; } +static int timer_stress (struct timer *timer_skel) +{ +return timer_stress_runner (timer_skel, false); +} + +static int timer_stress_async_cancel (struct timer *timer_skel) +{ +return timer_stress_runner (timer_skel, true); +} +static int timer (struct timer *timer_skel) {int err, prog_fd;
@@ -118,6 +129,11 @@ void serial_test_timer_stress(void)test_timer (timer_stress); } +void serial_test_timer_stress_async_cancel (void ) +{ +test_timer (timer_stress_async_cancel); +} +void test_timer_interrupt (void ) {struct timer_interrupt *skel =NULL ;
tools/testing/selftests/bpf/progs/timer.c +11 -3
@@ -1,13 +1,17 @@// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2021 Facebook */ -#include <linux/bpf.h> -#include <time.h> + +#include <vmlinux.h> #include <stdbool.h> #include <errno.h> #include <bpf/bpf_helpers.h> #include <bpf/bpf_tracing.h> +#define CLOCK_MONOTONIC 1 +#define CLOCK_BOOTTIME 7 + char _license[] SEC("license") = "GPL"; +struct hmap_elem {int counter;struct bpf_timer timer;
@@ -63,6 +67,7 @@ __u64 callback_check = 52;__u64 callback2_check =52 ;__u64 pinned_callback_check;__s32 pinned_cpu; +bool async_cancel =0 ;#define ARRAY 1#define HTAB 2
@@ -419,7 +424,10 @@ int race(void *ctx)bpf_timer_set_callback (timer, race_timer_callback);bpf_timer_start (timer,0 ,0 ); -bpf_timer_cancel (timer); +if (async_cancel) +bpf_timer_cancel_async (timer); +else +bpf_timer_cancel (timer);return 0 ; }
Signature · 1 line
2.52.0
RFC PATCH v4 8/8 selftests/bpf: Verify bpf_timer_cancel_async works
In reply to Mykyta YatsenkoFrom: Mykyta Yatsenko <[email protected]>
Add test that verifies that bpf_timer_cancel_async works: can cancel callback successfully.
--- tools/testing/selftests/bpf/prog_tests/timer.c | 25 +++++++++++++++++++++++++ tools/testing/selftests/bpf/progs/timer.c | 23 +++++++++++++++++++++++ 2 files changed, 48 insertions(+)
tools/testing/selftests/bpf/prog_tests/timer.c +25 -0
@@ -99,6 +99,26 @@ static int timer(struct timer *timer_skel)return 0 ; } +static int timer_cancel_async (struct timer *timer_skel) +{ +int err, prog_fd; +LIBBPF_OPTS (bpf_test_run_opts, topts); + + prog_fd =bpf_program__fd (timer_skel->progs.test_async_cancel_succeed); + err =bpf_prog_test_run_opts (prog_fd, &topts); +ASSERT_OK (err,"test_run" ); +ASSERT_EQ (topts.retval,0 ,"test_run" ); + +usleep (500 ); +/* check that there were no errors in timer execution */ +ASSERT_EQ (timer_skel->bss->err,0 ,"err" ); + +/* check that code paths completed */ +ASSERT_EQ (timer_skel->bss->ok,1 |2 |4 ,"ok" ); + +return 0 ; +} +static void test_timer (int (*timer_test_fn)(struct timer *timer_skel)) {struct timer *timer_skel =NULL ;
@@ -134,6 +154,11 @@ void serial_test_timer_stress_async_cancel(void)test_timer (timer_stress_async_cancel); } +void serial_test_timer_async_cancel (void ) +{ +test_timer (timer_cancel_async); +} +void test_timer_interrupt (void ) {struct timer_interrupt *skel =NULL ;
tools/testing/selftests/bpf/progs/timer.c +23 -0
@@ -169,6 +169,29 @@ int BPF_PROG2(test1, int, a)return 0 ; } +static int timer_error (void *map,int *key,struct bpf_timer *timer) +{ + err =42 ; +return 0 ; +} + +SEC("syscall") +int test_async_cancel_succeed (void *ctx) +{ +struct bpf_timer *arr_timer; +int array_key =ARRAY ; + + arr_timer =bpf_map_lookup_elem (&array, &array_key); +if (!arr_timer) +return 0 ; +bpf_timer_init (arr_timer, &array,CLOCK_MONOTONIC ); +bpf_timer_set_callback (arr_timer, timer_error); +bpf_timer_start (arr_timer,100000 /* 100us */ ,0 ); +bpf_timer_cancel_async (arr_timer); + ok =7 ; +return 0 ; +} +/* callback for prealloc and non-prealloca hashtab timers */ static int timer_cb2 (void *map,int *key,struct hmap_elem *val) {
Signature · 1 line
2.52.0