Commit 56b4a177 authored by Benjamin Tissoires's avatar Benjamin Tissoires Committed by Alexei Starovoitov
Browse files

bpf: replace bpf_timer_init with a generic helper 



No code change except for the new flags argument being stored in the
local data struct.

Signed-off-by: default avatarBenjamin Tissoires <bentiss@kernel.org>
Link: https://lore.kernel.org/r/20240420-bpf_wq-v2-2-6c986a5a741f@kernel.org


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent be2749be

kernel/bpf/helpers.c

+63 −28
Original line number Diff line number Diff line
@@ -1111,7 +1111,10 @@ struct bpf_hrtimer { 


/* the actual struct hidden inside uapi struct bpf_timer */

struct bpf_async_kern {

	union {

		struct bpf_async_cb *cb;

		struct bpf_hrtimer *timer;

	};

	/* 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.
@@ -1119,6 +1122,10 @@ struct bpf_async_kern { 
	struct bpf_spin_lock lock;

} __attribute__((aligned(8)));



enum bpf_async_type {

	BPF_ASYNC_TYPE_TIMER = 0,

};



static DEFINE_PER_CPU(struct bpf_hrtimer *, hrtimer_running);



static enum hrtimer_restart bpf_timer_cb(struct hrtimer *hrtimer)
@@ -1160,46 +1167,55 @@ static enum hrtimer_restart bpf_timer_cb(struct hrtimer *hrtimer) 
	return HRTIMER_NORESTART;

}



BPF_CALL_3(bpf_timer_init, struct bpf_async_kern *, timer, struct bpf_map *, map,

	   u64, flags)

static int __bpf_async_init(struct bpf_async_kern *async, struct bpf_map *map, u64 flags,

			    enum bpf_async_type type)

{

	clockid_t clockid = flags & (MAX_CLOCKS - 1);

	struct bpf_async_cb *cb;

	struct bpf_hrtimer *t;

	clockid_t clockid;

	size_t size;

	int ret = 0;



	BUILD_BUG_ON(MAX_CLOCKS != 16);

	BUILD_BUG_ON(sizeof(struct bpf_async_kern) > sizeof(struct bpf_timer));

	BUILD_BUG_ON(__alignof__(struct bpf_async_kern) != __alignof__(struct bpf_timer));



	if (in_nmi())

		return -EOPNOTSUPP;



	if (flags >= MAX_CLOCKS ||

	    /* similar to timerfd except _ALARM variants are not supported */

	    (clockid != CLOCK_MONOTONIC &&

	     clockid != CLOCK_REALTIME &&

	     clockid != CLOCK_BOOTTIME))

	switch (type) {

	case BPF_ASYNC_TYPE_TIMER:

		size = sizeof(struct bpf_hrtimer);

		break;

	default:

		return -EINVAL;

	__bpf_spin_lock_irqsave(&timer->lock);

	t = timer->timer;

	}



	__bpf_spin_lock_irqsave(&async->lock);

	t = async->timer;

	if (t) {

		ret = -EBUSY;

		goto out;

	}



	/* allocate hrtimer via map_kmalloc to use memcg accounting */

	t = bpf_map_kmalloc_node(map, sizeof(*t), GFP_ATOMIC, map->numa_node);

	if (!t) {

	cb = bpf_map_kmalloc_node(map, size, GFP_ATOMIC, map->numa_node);

	if (!cb) {

		ret = -ENOMEM;

		goto out;

	}

	t->cb.value = (void *)timer - map->record->timer_off;

	t->cb.map = map;

	t->cb.prog = NULL;

	rcu_assign_pointer(t->cb.callback_fn, NULL);



	if (type == BPF_ASYNC_TYPE_TIMER) {

		clockid = flags & (MAX_CLOCKS - 1);

		t = (struct bpf_hrtimer *)cb;



		hrtimer_init(&t->timer, clockid, HRTIMER_MODE_REL_SOFT);

		t->timer.function = bpf_timer_cb;

	WRITE_ONCE(timer->timer, t);

	/* Guarantee the order between timer->timer and map->usercnt. So

		cb->value = (void *)async - map->record->timer_off;

	}

	cb->map = map;

	cb->prog = NULL;

	cb->flags = flags;

	rcu_assign_pointer(cb->callback_fn, NULL);



	WRITE_ONCE(async->cb, cb);

	/* 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

	 * timer or atomic64_read() below returns a zero usercnt.
@@ -1209,15 +1225,34 @@ BPF_CALL_3(bpf_timer_init, struct bpf_async_kern *, timer, struct bpf_map *, map 
		/* maps with timers must be either held by user space

		 * or pinned in bpffs.

		 */

		WRITE_ONCE(timer->timer, NULL);

		kfree(t);

		WRITE_ONCE(async->cb, NULL);

		kfree(cb);

		ret = -EPERM;

	}

out:

	__bpf_spin_unlock_irqrestore(&timer->lock);

	__bpf_spin_unlock_irqrestore(&async->lock);

	return ret;

}



BPF_CALL_3(bpf_timer_init, struct bpf_async_kern *, timer, struct bpf_map *, map,

	   u64, flags)

{

	clock_t clockid = flags & (MAX_CLOCKS - 1);



	BUILD_BUG_ON(MAX_CLOCKS != 16);

	BUILD_BUG_ON(sizeof(struct bpf_async_kern) > sizeof(struct bpf_timer));

	BUILD_BUG_ON(__alignof__(struct bpf_async_kern) != __alignof__(struct bpf_timer));



	if (flags >= MAX_CLOCKS ||

	    /* similar to timerfd except _ALARM variants are not supported */

	    (clockid != CLOCK_MONOTONIC &&

	     clockid != CLOCK_REALTIME &&

	     clockid != CLOCK_BOOTTIME))

		return -EINVAL;



	return __bpf_async_init(timer, map, flags, BPF_ASYNC_TYPE_TIMER);

}



static const struct bpf_func_proto bpf_timer_init_proto = {

	.func		= bpf_timer_init,

	.gpl_only	= true,