Implement mechanism to signal other threads
Subsystems (6)
v2 cover Implement mechanism to signal other threads
This set implements a kfunc called bpf_send_signal_remote() that is similar to sigqueue() as it can send a signal along with a cookie to a thread or thread group.
The send_signal selftest has been updated to also test this new kfunc under all contexts.
Changes in v2:
v1: https://lore.kernel.org/bpf/[email protected]/
- Convert to a kfunc
- Add mechanism to send a cookie with the signal.
Puranjay Mohan (2):
bpf: implement bpf_send_signal_remote() kfunc selftests/bpf: Augment send_signal test with remote signaling
kernel/trace/bpf_trace.c | 78 +++++++++- .../selftests/bpf/prog_tests/send_signal.c | 133 +++++++++++++----- .../bpf/progs/test_send_signal_kern.c | 35 ++++- 3 files changed, 207 insertions(+), 39 deletions(-)
Signature · 1 line
2.40.1
PATCH v2 1/2 bpf: implement bpf_send_signal_remote() kfunc
Implement bpf_send_signal_remote kfunc that is similar to bpf_send_signal_thread and bpf_send_signal helpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar to sigqueue().
If the receiving process establishes a handler for the signal using the SA_SIGINFO flag to sigaction(), then it can obtain this cookie via the si_value field of the siginfo_t structure passed as the second argument to the handler.
--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)
kernel/trace/bpf_trace.c +77 -1
@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);
@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }
@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);
@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value) +{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */ +if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value; + +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task); + work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type); +} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func ,bpf_send_signal_remote ,KF_TRUSTED_ARGS ) +BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = { + .owner =THIS_MODULE , + .set = &send_signal_kfunc_ids, +}; + +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set); +} + +late_initcall (bpf_send_signal_kfuncs_init);
Signature · 1 line
2.40.1
Re: [PATCH bpf-next v2 1/2] bpf: implement bpf_send_signal_remote() kfunc
Quoted 94 lines · Puranjay Mohan
Implement
bpf_send_signal_remotekfunc that is similar tobpf_send_signal_threadandbpf_send_signalhelpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar tosigqueue().If the receiving process establishes a handler for the signal using the
SA_SIGINFOflag tosigaction(), then it can obtain this cookie via thesi_valuefield of thesiginfo_tstructure passed as the second argument to the handler.Signed-off-by Puranjay Mohan <[email protected]>--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)kernel/trace/bpf_trace.c +48
-1@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value) +{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */ +if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value; + +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task);
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3543
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+ work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type);
This is very similar with bpf_send_signal_common(). Pls avoid copy paste and share the code instead.
Quoted 9 lines
kernel/trace/bpf_trace.c +9
-0+} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func ,bpf_send_signal_remote ,KF_TRUSTED_ARGS ) +BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = {
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3562
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+ .owner = THIS_MODULE, + .set = &send_signal_kfunc_ids, +}; + +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set); +} + +late_initcall (bpf_send_signal_kfuncs_init);
Let's avoid all this later_init proliferation.
We have way too many of them across the whole kernel. Reuse one of the existing places and add kfunc there. With that extra bpf_send_signal_kfunc_set and send_signal_kfunc_ids won't be necessary.
pw-bot: cr
Re: [PATCH bpf-next v2 1/2] bpf: implement bpf_send_signal_remote() kfunc
In reply to Puranjay MohanQuoted 71 lines · Puranjay Mohan
Implement
bpf_send_signal_remotekfunc that is similar tobpf_send_signal_threadandbpf_send_signalhelpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar tosigqueue().If the receiving process establishes a handler for the signal using the
SA_SIGINFOflag tosigaction(), then it can obtain this cookie via thesi_valuefield of thesiginfo_tstructure passed as the second argument to the handler.Signed-off-by Puranjay Mohan <[email protected]>--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)kernel/trace/bpf_trace.c +25
-1@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value) +{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3520
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value;
It seems like it could be either int sival_int or void *sival_ptr, i.e., it's actually a 64-bit value on 64-bit architectures.
Can we allow passing a full u64 here and assign it to sival_ptr (with a cast)?
Quoted 29 lines
kernel/trace/bpf_trace.c +29
-0+ +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task); + work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type); +} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func, bpf_send_signal_remote, KF_TRUSTED_ARGS)
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3559
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = { + .owner =THIS_MODULE , + .set = &send_signal_kfunc_ids, +}; + +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set);
let's allow it for other program types (at least kprobes, tracepoints, raw_tp, etc, etc)? Is there any problem just allowing it for any program type?
Quoted 6 lines
kernel/trace/bpf_trace.c +3
-1+} + +late_initcall (bpf_send_signal_kfuncs_init); --2.40.1
Re: [PATCH bpf-next v2 1/2] bpf: implement bpf_send_signal_remote() kfunc
Quoted 56 lines · Andrii Nakryiko
Quoted 54 lines · Puranjay Mohan
Implement
bpf_send_signal_remotekfunc that is similar tobpf_send_signal_threadandbpf_send_signalhelpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar tosigqueue().If the receiving process establishes a handler for the signal using the
SA_SIGINFOflag tosigaction(), then it can obtain this cookie via thesi_valuefield of thesiginfo_tstructure passed as the second argument to the handler.Signed-off-by Puranjay Mohan <[email protected]>--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)kernel/trace/bpf_trace.c +9
-1@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }
Quoted 6 lines
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3499
Quoted 6 lines
kernel/trace/bpf_trace.c +5
-0late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value)
Bikeshedding here a bit, but would bpf_send_signal_task() be a better name for something that accepts task_struct?
Quoted 25 lines
Quoted 11 lines
kernel/trace/bpf_trace.c +11
-0+{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */ kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3520
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value;It seems like it could be either int
sival_intorvoid *sival_ptr, i.e., it's actually a 64-bit value on 64-bit architectures.
Quoted 1 line
Can we allow passing a full u64 here and assign it to
sival_ptr(with a cast)?
Seems like Alexei already suggested that on patch #2, I support the request.
Quoted 52 lines
Quoted 30 lines
kernel/trace/bpf_trace.c +29
-0+ +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task); + work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type); +} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func, bpf_send_signal_remote, KF_TRUSTED_ARGS)kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3559
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = { + .owner =THIS_MODULE , + .set = &send_signal_kfunc_ids, +}; + +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set);let's allow it for other program types (at least kprobes, tracepoints,
raw_tp, etc, etc)? Is there any problem just allowing it for any program type?Quoted 6 lines
kernel/trace/bpf_trace.c +3
-1+} + +late_initcall (bpf_send_signal_kfuncs_init); --2.40.1
Re: [PATCH bpf-next v2 1/2] bpf: implement bpf_send_signal_remote() kfunc
Quoted 58 lines · Andrii Nakryiko
Quoted 56 lines · Andrii Nakryiko
Quoted 54 lines · Puranjay Mohan
Implement
bpf_send_signal_remotekfunc that is similar tobpf_send_signal_threadandbpf_send_signalhelpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar tosigqueue().If the receiving process establishes a handler for the signal using the
SA_SIGINFOflag tosigaction(), then it can obtain this cookie via thesi_valuefield of thesiginfo_tstructure passed as the second argument to the handler.Signed-off-by Puranjay Mohan <[email protected]>--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)kernel/trace/bpf_trace.c +9
-1@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }
Quoted 9 lines
Quoted 6 lines
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3499
Quoted 6 lines
kernel/trace/bpf_trace.c +5
-0late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value)Bikeshedding here a bit, but would
bpf_send_signal_task()be a better name for something that acceptstask_struct?
I agree, will use that name in the next version.
Quoted 81 lines
Quoted 25 lines
Quoted 11 lines
kernel/trace/bpf_trace.c +11
-0+{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */ kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3520
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value;It seems like it could be either int
sival_intorvoid *sival_ptr, i.e., it's actually a 64-bit value on 64-bit architectures.Quoted 1 line
Can we allow passing a full u64 here and assign it to
sival_ptr(with a cast)?Seems like Alexei already suggested that on patch #2, I support the request.
Quoted 52 lines
Quoted 30 lines
kernel/trace/bpf_trace.c +29
-0+ +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task); + work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type); +} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func, bpf_send_signal_remote, KF_TRUSTED_ARGS)kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3559
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = { + .owner =THIS_MODULE , + .set = &send_signal_kfunc_ids, +}; + +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set);let's allow it for other program types (at least kprobes, tracepoints,
raw_tp, etc, etc)? Is there any problem just allowing it for any program type?Quoted 6 lines
kernel/trace/bpf_trace.c +3
-1+} + +late_initcall (bpf_send_signal_kfuncs_init); --2.40.1
Re: [PATCH bpf-next v2 1/2] bpf: implement bpf_send_signal_remote() kfunc
In reply to Andrii NakryikoQuoted 86 lines · Andrii Nakryiko
Quoted 71 lines · Puranjay Mohan
Implement
bpf_send_signal_remotekfunc that is similar tobpf_send_signal_threadandbpf_send_signalhelpers but can be used to send signals to other threads and processes. It also supports sending a cookie with the signal similar tosigqueue().If the receiving process establishes a handler for the signal using the
SA_SIGINFOflag tosigaction(), then it can obtain this cookie via thesi_valuefield of thesiginfo_tstructure passed as the second argument to the handler.Signed-off-by Puranjay Mohan <[email protected]>--- kernel/trace/bpf_trace.c | 78 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-)kernel/trace/bpf_trace.c +25
-1@@ -802,6 +802,9 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool is_siginfo; +kernel_siginfo_t info; +int value; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -811,7 +814,11 @@ static void do_bpf_send_signal(struct irq_work *entry)struct send_signal_irq_work *work; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +if (work->is_siginfo) +group_send_sig_info (work->sig, &work->info, work->task, work->type); +else +group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); +put_task_struct (work->task); }@@ -848,6 +855,7 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* irq works get executed. */ work->task =get_task_struct (current); + work->is_siginfo = false; work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);@@ -3484,3 +3492,71 @@ static int __init bpf_kprobe_multi_kfuncs_init(void) }late_initcall (bpf_kprobe_multi_kfuncs_init); + +__bpf_kfunc_start_defs (); + +__bpf_kfunc int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, +int value) +{ +struct send_signal_irq_work *work =NULL ; +kernel_siginfo_t info; + +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; +if (unlikely (task->flags & (PF_KTHREAD |PF_EXITING ))) +return -EPERM ; +if (unlikely (!nmi_uaccess_okay ())) +return -EPERM ; +/* Task should not be pid=1 to avoid kernel panic. */ kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3520
Quoted 10 lines
kernel/trace/bpf_trace.c +10
-0+if (unlikely (is_global_init (task))) +return -EPERM ; + +clear_siginfo (&info); + info.si_signo = sig; + info.si_errno =0 ; + info.si_code =SI_KERNEL ; + info.si_pid =0 ; + info.si_uid =0 ; + info.si_value.sival_int = value;It seems like it could be either int
sival_intorvoid *sival_ptr, i.e., it's actually a 64-bit value on 64-bit architectures.
Quoted 1 line
Can we allow passing a full u64 here and assign it to
sival_ptr(with a cast)?
Yes, I initially thought of allowing the kfunc to take the union itself but turns out unions are not supported, so I will just use a cast to put the value in sival_ptr.
Quoted 35 lines
Quoted 35 lines
kernel/trace/bpf_trace.c +35
-0+ +if (irqs_disabled ()) { +/* Do an early check on signal validity. Otherwise, +* the error is lost in deferred irq_work. +*/ +if (unlikely (!valid_signal (sig))) +return -EINVAL ; + + work =this_cpu_ptr (&send_signal_work); +if (irq_work_is_busy (&work->irq_work)) +return -EBUSY ; + + work->task =get_task_struct (task); + work->is_siginfo = true; + work->info = info; + work->sig = sig; + work->type = type; + work->value = value; +irq_work_queue (&work->irq_work); +return 0 ; + } + +return group_send_sig_info (sig, &info, task, type); +} + +__bpf_kfunc_end_defs (); + +BTF_KFUNCS_START (send_signal_kfunc_ids) +BTF_ID_FLAGS (func ,bpf_send_signal_remote ,KF_TRUSTED_ARGS ) +BTF_KFUNCS_END (send_signal_kfunc_ids) + +static const struct btf_kfunc_id_set bpf_send_signal_kfunc_set = { + .owner =THIS_MODULE , + .set = &send_signal_kfunc_ids, +};
Quoted 8 lines
kernel/trace/bpf_trace.c static int __init bpf_kprobe_multi_kfuncs_init(void) · line 3559
Quoted 4 lines
kernel/trace/bpf_trace.c +4
-0+ +static int __init bpf_send_signal_kfuncs_init (void ) +{ +return register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_send_signal_kfunc_set);let's allow it for other program types (at least kprobes, tracepoints,
raw_tp, etc, etc)? Is there any problem just allowing it for any program type?
I guess we can allow it for all program types.
Quoted 7 lines
Quoted 7 lines
kernel/trace/bpf_trace.c +3
-1+} + +late_initcall (bpf_send_signal_kfuncs_init); --2.40.1
PATCH v2 2/2 selftests/bpf: Augment send_signal test with remote signaling
In reply to Puranjay MohanAdd testcases to test bpf_send_signal_remote(). In these new test cases, the main process triggers the BPF program and the forked process receives the signals. The target process's signal handler receives a cookie from the bpf program.
--- .../selftests/bpf/prog_tests/send_signal.c | 133 +++++++++++++----- .../bpf/progs/test_send_signal_kern.c | 35 ++++- 2 files changed, 130 insertions(+), 38 deletions(-)
tools/testing/selftests/bpf/prog_tests/send_signal.c +101 -32
@@ -8,17 +8,25 @@ static int sigusr1_received;static void sigusr1_handler (int signum) { - sigusr1_received =1 ; + sigusr1_received =8 ; +} + +static void sigusr1_siginfo_handler (int s,siginfo_t *i,void *v) +{ + sigusr1_received = i->si_value.sival_int; }static void test_send_signal_common (struct perf_event_attr *attr, -bool signal_thread) +bool signal_thread,bool remote) {struct test_send_signal_kern *skel; +struct sigaction sa;int pipe_c2p[2 ], pipe_p2c[2 ];int err =-1 , pmu_fd =-1 ; +volatile int j =0 ;char buf[256 ];pid_t pid; +int old_prio;if (!ASSERT_OK (pipe (pipe_c2p),"pipe_c2p" ))return ;
@@ -39,11 +47,14 @@ static void test_send_signal_common(struct perf_event_attr *attr, }if (pid ==0 ) { -int old_prio; -volatile int j =0 ; -/* install signal handler and notify parent */ -ASSERT_NEQ (signal (SIGUSR1 , sigusr1_handler),SIG_ERR ,"signal" ); +if (remote) { + sa.sa_sigaction = sigusr1_siginfo_handler; + sa.sa_flags =SA_RESTART |SA_SIGINFO ; +ASSERT_NEQ (sigaction (SIGUSR1 , &sa,NULL ),-1 ,"sigaction" ); + }else { +ASSERT_NEQ (signal (SIGUSR1 , sigusr1_handler),SIG_ERR ,"signal" ); + }close (pipe_c2p[0 ]);/* close read */ close (pipe_p2c[1 ]);/* close write */
@@ -52,10 +63,12 @@ static void test_send_signal_common(struct perf_event_attr *attr,* that if an interrupt happens, the underlying task * is this process. */ - errno =0 ; - old_prio =getpriority (PRIO_PROCESS ,0 ); -ASSERT_OK (errno,"getpriority" ); -ASSERT_OK (setpriority (PRIO_PROCESS ,0 ,-20 ),"setpriority" ); +if (!remote) { + errno =0 ; + old_prio =getpriority (PRIO_PROCESS ,0 ); +ASSERT_OK (errno,"getpriority" ); +ASSERT_OK (setpriority (PRIO_PROCESS ,0 ,-20 ),"setpriority" ); + }/* notify parent signal handler is installed */ ASSERT_EQ (write (pipe_c2p[1 ], buf,1 ),1 ,"pipe_write" );
@@ -66,20 +79,25 @@ static void test_send_signal_common(struct perf_event_attr *attr,/* wait a little for signal handler */ for (int i =0 ; i <1000000000 && !sigusr1_received; i++) { j /= i + j +1 ; -if (!attr) -/* trigger the nanosleep tracepoint program. */ -usleep (1 ); +if (remote) +sleep (1 ); +else +if (!attr) +/* trigger the nanosleep tracepoint program. */ +usleep (1 ); } - buf[0 ] = sigusr1_received ?'2' :'0' ; -ASSERT_EQ (sigusr1_received,1 ,"sigusr1_received" ); + buf[0 ] = sigusr1_received; + +ASSERT_EQ (sigusr1_received,8 ,"sigusr1_received" );ASSERT_EQ (write (pipe_c2p[1 ], buf,1 ),1 ,"pipe_write" );/* wait for parent notification and exit */ ASSERT_EQ (read (pipe_p2c[0 ], buf,1 ),1 ,"pipe_read" );/* restore the old priority */ -ASSERT_OK (setpriority (PRIO_PROCESS ,0 , old_prio),"setpriority" ); +if (!remote) +ASSERT_OK (setpriority (PRIO_PROCESS ,0 , old_prio),"setpriority" );close (pipe_c2p[1 ]);close (pipe_p2c[0 ]);
@@ -93,6 +111,17 @@ static void test_send_signal_common(struct perf_event_attr *attr,if (!ASSERT_OK_PTR (skel,"skel_open_and_load" )) goto skel_open_load_failure; +/* boost with a high priority so we got a higher chance +* that if an interrupt happens, the underlying task +* is this process. +*/ +if (remote) { + errno =0 ; + old_prio =getpriority (PRIO_PROCESS ,0 ); +ASSERT_OK (errno,"getpriority" ); +ASSERT_OK (setpriority (PRIO_PROCESS ,0 ,-20 ),"setpriority" ); + } +if (!attr) { err =test_send_signal_kern__attach (skel);if (!ASSERT_OK (err,"skel_attach" )) {
@@ -100,8 +129,12 @@ static void test_send_signal_common(struct perf_event_attr *attr, goto destroy_skel; } }else { - pmu_fd =syscall (__NR_perf_event_open, attr, pid,-1 /* cpu */ , --1 /* group id */ ,0 /* flags */ ); +if (!remote) + pmu_fd =syscall (__NR_perf_event_open, attr, pid,-1 /* cpu */ , +-1 /* group id */ ,0 /* flags */ ); +else + pmu_fd =syscall (__NR_perf_event_open, attr,getpid (),-1 /* cpu */ , +-1 /* group id */ ,0 /* flags */ );if (!ASSERT_GE (pmu_fd,0 ,"perf_event_open" )) { err =-1 ; goto destroy_skel;
@@ -119,11 +152,30 @@ static void test_send_signal_common(struct perf_event_attr *attr,/* trigger the bpf send_signal */ skel->bss->signal_thread = signal_thread; skel->bss->sig =SIGUSR1 ; - skel->bss->pid = pid; +if (!remote) { + skel->bss->target_pid =0 ; + skel->bss->pid = pid; + }else { + skel->bss->target_pid = pid; + skel->bss->pid =getpid (); + }/* notify child that bpf program can send_signal now */ ASSERT_EQ (write (pipe_p2c[1 ], buf,1 ),1 ,"pipe_write" ); +/* For the remote test, the BPF program is triggered from this +* process but the other process/thread is signaled. +*/ +if (remote) { +if (!attr) { +for (int i =0 ; i <10 ; i++) +usleep (1 ); + }else { +for (int i =0 ; i <100000000 ; i++) + j /= i +1 ; + } + } +/* wait for result */ err =read (pipe_c2p[0 ], buf,1 );if (!ASSERT_GE (err,0 ,"reading pipe" ))
@@ -133,7 +185,7 @@ static void test_send_signal_common(struct perf_event_attr *attr, goto disable_pmu; } -ASSERT_EQ (buf[0 ],'2' ,"incorrect result" ); +ASSERT_EQ (buf[0 ],8 ,"incorrect result" );/* notify child safe to exit */ ASSERT_EQ (write (pipe_p2c[1 ], buf,1 ),1 ,"pipe_write" );
@@ -142,18 +194,21 @@ static void test_send_signal_common(struct perf_event_attr *attr,close (pmu_fd); destroy_skel:test_send_signal_kern__destroy (skel); +/* restore the old priority */ +if (remote) +ASSERT_OK (setpriority (PRIO_PROCESS ,0 , old_prio),"setpriority" ); skel_open_load_failure:close (pipe_c2p[0 ]);close (pipe_p2c[1 ]);wait (NULL ); } -static void test_send_signal_tracepoint (bool signal_thread) +static void test_send_signal_tracepoint (bool signal_thread,bool remote) { -test_send_signal_common (NULL , signal_thread); +test_send_signal_common (NULL , signal_thread, remote); } -static void test_send_signal_perf (bool signal_thread) +static void test_send_signal_perf (bool signal_thread,bool remote) {struct perf_event_attr attr = { .freq =1 ,
@@ -162,10 +217,10 @@ static void test_send_signal_perf(bool signal_thread) .config = PERF_COUNT_SW_CPU_CLOCK, }; -test_send_signal_common (&attr, signal_thread); +test_send_signal_common (&attr, signal_thread, remote); } -static void test_send_signal_nmi (bool signal_thread) +static void test_send_signal_nmi (bool signal_thread,bool remote) {struct perf_event_attr attr = { .sample_period =1 ,
@@ -191,21 +246,35 @@ static void test_send_signal_nmi(bool signal_thread)close (pmu_fd); } -test_send_signal_common (&attr, signal_thread); +test_send_signal_common (&attr, signal_thread, remote); }void test_send_signal (void ) {if (test__start_subtest ("send_signal_tracepoint" )) -test_send_signal_tracepoint (false); +test_send_signal_tracepoint (false, false);if (test__start_subtest ("send_signal_perf" )) -test_send_signal_perf (false); +test_send_signal_perf (false, false);if (test__start_subtest ("send_signal_nmi" )) -test_send_signal_nmi (false); +test_send_signal_nmi (false, false);if (test__start_subtest ("send_signal_tracepoint_thread" )) -test_send_signal_tracepoint (true); +test_send_signal_tracepoint (true, false);if (test__start_subtest ("send_signal_perf_thread" )) -test_send_signal_perf (true); +test_send_signal_perf (true, false);if (test__start_subtest ("send_signal_nmi_thread" )) -test_send_signal_nmi (true); +test_send_signal_nmi (true, false); + +/* Signal remote thread and thread group */ +if (test__start_subtest ("send_signal_tracepoint_remote" )) +test_send_signal_tracepoint (false, true); +if (test__start_subtest ("send_signal_perf_remote" )) +test_send_signal_perf (false, true); +if (test__start_subtest ("send_signal_nmi_remote" )) +test_send_signal_nmi (false, true); +if (test__start_subtest ("send_signal_tracepoint_thread_remote" )) +test_send_signal_tracepoint (true, true); +if (test__start_subtest ("send_signal_perf_thread_remote" )) +test_send_signal_perf (true, true); +if (test__start_subtest ("send_signal_nmi_thread_remote" )) +test_send_signal_nmi (true, true); }
tools/testing/selftests/bpf/progs/test_send_signal_kern.c +29 -6
@@ -1,27 +1,50 @@// SPDX-License-Identifier: GPL-2.0 // Copyright (c) 2019 Facebook -#include <linux/bpf.h> +#include <vmlinux.h> #include <linux/version.h> #include <bpf/bpf_helpers.h> -__u32 sig =0 , pid =0 , status =0 , signal_thread =0 ; +struct task_struct *bpf_task_from_pid (int pid) __ksym; +void bpf_task_release(struct task_struct *p) __ksym; +int bpf_send_signal_remote(struct task_struct *task, int sig, enum pid_type type, int value) __ksym; + +__u32 sig =0 , pid =0 , status =0 , signal_thread =0 , target_pid =0 ; static __always_inline int bpf_send_signal_test(void *ctx) { +struct task_struct *target_task =NULL ;int ret; +int value;if (status !=0 || pid ==0 )return 0 ;if ((bpf_get_current_pid_tgid () >>32 ) == pid) { -if (signal_thread) - ret =bpf_send_signal_thread (sig); -else - ret =bpf_send_signal (sig); +if (target_pid) { + target_task =bpf_task_from_pid (target_pid); +if (!target_task) +return 0 ; + value =8 ; + } + +if (signal_thread) { +if (target_pid) + ret =bpf_send_signal_remote (target_task, sig,PIDTYPE_PID , value); +else + ret =bpf_send_signal_thread (sig); + }else { +if (target_pid) + ret =bpf_send_signal_remote (target_task, sig,PIDTYPE_TGID , value); +else + ret =bpf_send_signal (sig); + }if (ret ==0 ) status =1 ; } +if (target_task) +bpf_task_release (target_task); +return 0 ; }
Signature · 1 line
2.40.1
Re: [PATCH bpf-next v2 2/2] selftests/bpf: Augment send_signal test with remote signaling
Quoted 17 lines · Puranjay Mohan
Add testcases to test
bpf_send_signal_remote(). In these new test cases, the main process triggers the BPF program and the forked process receives the signals. The target process's signal handler receives a cookie from the bpf program.Signed-off-by Puranjay Mohan <[email protected]>--- .../selftests/bpf/prog_tests/send_signal.c | 133 +++++++++++++----- .../bpf/progs/test_send_signal_kern.c | 35 ++++- 2 files changed, 130 insertions(+), 38 deletions(-)tools/testing/selftests/bpf/prog_tests/send_signal.c +0
-0
tools/testing/selftests/bpf/prog_tests/send_signal.c static int sigusr1_received; · line 16
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/send_signal.c +6
-1@@ -8,17 +8,25 @@ static int sigusr1_received;static void sigusr1_handler (int signum) { - sigusr1_received =1 ; + sigusr1_received =8 ; +} + +static void sigusr1_siginfo_handler (int s,siginfo_t *i,void *v) +{ + sigusr1_received = i->si_value.sival_int;
If I'm reading this correctly:
typedef union sigval {
int sival_int;
void *sival_ptr;
} sigval_t;the user space will receive 4 bytes of garbage if it reads sival_ptr instead.
I think it's better to make sure bpf prog passes 8 bytes instead of 4.