Implement mechanism to signal other threads
Subsystems (6)
v4 cover Implement mechanism to signal other threads
This set implements a kfunc called bpf_send_signal_task() 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 v4:
v3: https://lore.kernel.org/all/[email protected]/
- Fix the selftest to make it work for big-endian archs.
- Fix a build warning on 32-bit archs.
- Some style changes and code refactors suggested by Andrii
Changes in v3:
v2: https://lore.kernel.org/all/[email protected]/
- make the cookie u64 instead of int.
- re use code from bpf_send_signal_common
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_task() kfunc selftests/bpf: Augment send_signal test with remote signaling
kernel/bpf/helpers.c | 1 + kernel/trace/bpf_trace.c | 52 +++++-- .../selftests/bpf/prog_tests/send_signal.c | 133 +++++++++++++----- .../bpf/progs/test_send_signal_kern.c | 35 ++++- 4 files changed, 175 insertions(+), 46 deletions(-)
Signature · 1 line
2.40.1
PATCH v4 1/2 bpf: implement bpf_send_signal_task() kfunc
Implement bpf_send_signal_task 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/bpf/helpers.c | 1 + kernel/trace/bpf_trace.c | 52 +++++++++++++++++++++++++++++++++------- 2 files changed, 45 insertions(+), 8 deletions(-)
kernel/bpf/helpers.c +1 -0
@@ -3035,6 +3035,7 @@ BTF_ID_FLAGS(func, bpf_task_get_cgroup1, KF_ACQUIRE | KF_RCU | KF_RET_NULL)#endif BTF_ID_FLAGS(func, bpf_task_from_pid, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_throw) +BTF_ID_FLAGS(func, bpf_send_signal_task, KF_TRUSTED_ARGS)BTF_KFUNCS_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = {
kernel/trace/bpf_trace.c +44 -8
106 lines not on this page · raw message
Signature · 1 line
2.40.1
Re: [PATCH bpf-next v4 1/2] bpf: implement bpf_send_signal_task() kfunc
Quoted 94 lines · Puranjay Mohan
Implement
bpf_send_signal_taskkfunc 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/bpf/helpers.c | 1 + kernel/trace/bpf_trace.c | 52 +++++++++++++++++++++++++++++++++------- 2 files changed, 45 insertions(+), 8 deletions(-)kernel/bpf/helpers.c +1
-0@@ -3035,6 +3035,7 @@ BTF_ID_FLAGS(func, bpf_task_get_cgroup1, KF_ACQUIRE | KF_RCU | KF_RET_NULL)#endif BTF_ID_FLAGS(func, bpf_task_from_pid, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_throw) +BTF_ID_FLAGS(func, bpf_send_signal_task, KF_TRUSTED_ARGS)BTF_KFUNCS_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = {kernel/trace/bpf_trace.c +25
-4@@ -802,6 +802,8 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool has_siginfo; +struct kernel_siginfo info; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -809,27 +811,46 @@ static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);static void do_bpf_send_signal (struct irq_work *entry) {struct send_signal_irq_work *work; +struct kernel_siginfo *siginfo; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); + siginfo = work->has_siginfo ? &work->info :SEND_SIG_PRIV ; + +group_send_sig_info (work->sig, siginfo, work->task, work->type);put_task_struct (work->task); } -static int bpf_send_signal_common (u32 sig,enum pid_type type) +static int bpf_send_signal_common (u32 sig,enum pid_type type,struct task_struct *task,u64 value) {struct send_signal_irq_work *work =NULL ; +struct kernel_siginfo info; +struct kernel_siginfo *siginfo; + +if (!task) { + task = current; + siginfo =SEND_SIG_PRIV ; + }else { +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_ptr = (void *)(unsigned long )value; + siginfo = &info; + }/* Similar to bpf_probe_write_user, task needs to be * in a sound condition and kernel memory access be * permitted in order to send signal to the current * task. */ -if (unlikely (current->flags & (PF_KTHREAD |PF_EXITING ))) +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 (current))) +if (unlikely (is_global_init (task)))return -EPERM ;if (irqs_disabled ()) {
kernel/trace/bpf_trace.c static int bpf_send_signal_common(u32 sig, enum pid_type type) · line 873
Quoted 7 lines
kernel/trace/bpf_trace.c +3
-1@@ -847,19 +868,21 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* to the irq_work. The current task may change when queued * irq works get executed. */ - work->task =get_task_struct (current); + work->task =get_task_struct (task); + work->has_siginfo = siginfo == &info; +copy_siginfo (&work->info, &info);
we shouldn't copy_siginfo() if !work->has_siginfo, no?
other than that, lgtm
Quoted 46 lines
kernel/trace/bpf_trace.c +16
-4work->sig = sig; work->type = type;irq_work_queue (&work->irq_work);return 0 ; } -return group_send_sig_info (sig,SEND_SIG_PRIV , current, type); +return group_send_sig_info (sig, siginfo, task, type); } BPF_CALL_1(bpf_send_signal, u32, sig) { -return bpf_send_signal_common (sig,PIDTYPE_TGID ); +return bpf_send_signal_common (sig,PIDTYPE_TGID ,NULL ,0 ); }static const struct bpf_func_proto bpf_send_signal_proto = {@@ -871,7 +894,7 @@ static const struct bpf_func_proto bpf_send_signal_proto = { BPF_CALL_1(bpf_send_signal_thread, u32, sig) { -return bpf_send_signal_common (sig,PIDTYPE_PID ); +return bpf_send_signal_common (sig,PIDTYPE_PID ,NULL ,0 ); }static const struct bpf_func_proto bpf_send_signal_thread_proto = {@@ -3484,3 +3507,16 @@ 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_task(struct task_struct *task, int sig, enum pid_type type, +u64 value) +{ +if (type !=PIDTYPE_PID && type !=PIDTYPE_TGID ) +return -EINVAL ; + +return bpf_send_signal_common (sig, type, task, value); +} + +__bpf_kfunc_end_defs (); --2.40.1
Re: [PATCH bpf-next v4 1/2] bpf: implement bpf_send_signal_task() kfunc
Quoted 93 lines · Andrii Nakryiko
Quoted 92 lines · Puranjay Mohan
Implement
bpf_send_signal_taskkfunc 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/bpf/helpers.c | 1 + kernel/trace/bpf_trace.c | 52 +++++++++++++++++++++++++++++++++------- 2 files changed, 45 insertions(+), 8 deletions(-)kernel/bpf/helpers.c +1
-0@@ -3035,6 +3035,7 @@ BTF_ID_FLAGS(func, bpf_task_get_cgroup1, KF_ACQUIRE | KF_RCU | KF_RET_NULL)#endif BTF_ID_FLAGS(func, bpf_task_from_pid, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_throw) +BTF_ID_FLAGS(func, bpf_send_signal_task, KF_TRUSTED_ARGS)BTF_KFUNCS_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = {kernel/trace/bpf_trace.c +25
-4@@ -802,6 +802,8 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool has_siginfo; +struct kernel_siginfo info; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -809,27 +811,46 @@ static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);static void do_bpf_send_signal (struct irq_work *entry) {struct send_signal_irq_work *work; +struct kernel_siginfo *siginfo; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); + siginfo = work->has_siginfo ? &work->info :SEND_SIG_PRIV ; + +group_send_sig_info (work->sig, siginfo, work->task, work->type);put_task_struct (work->task); } -static int bpf_send_signal_common (u32 sig,enum pid_type type) +static int bpf_send_signal_common (u32 sig,enum pid_type type,struct task_struct *task,u64 value) {struct send_signal_irq_work *work =NULL ; +struct kernel_siginfo info; +struct kernel_siginfo *siginfo; + +if (!task) { + task = current; + siginfo =SEND_SIG_PRIV ; + }else { +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_ptr = (void *)(unsigned long )value; + siginfo = &info; + }/* Similar to bpf_probe_write_user, task needs to be * in a sound condition and kernel memory access be * permitted in order to send signal to the current * task. */ -if (unlikely (current->flags & (PF_KTHREAD |PF_EXITING ))) +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 (current))) +if (unlikely (is_global_init (task)))return -EPERM ;
Quoted 11 lines
kernel/trace/bpf_trace.c static int bpf_send_signal_common(u32 sig, enum pid_type type) · line 873
Quoted 9 lines
kernel/trace/bpf_trace.c +3
-1if (irqs_disabled ()) {@@ -847,19 +868,21 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* to the irq_work. The current task may change when queued * irq works get executed. */ - work->task =get_task_struct (current); + work->task =get_task_struct (task); + work->has_siginfo = siginfo == &info; +copy_siginfo (&work->info, &info);we shouldn't
copy_siginfo()if !work->has_siginfo, no?
Yes, but it is only used when has_siginfo is true, so copying it doesn't cause any problems. I just didn't want to add another check here.
Quoted 3 lines
other than that, lgtm
Acked-by Andrii Nakryiko <[email protected]>
Thanks for the Ack. I hope this can go in now!
Thanks,
Puranjay Mohan
Re: [PATCH bpf-next v4 1/2] bpf: implement bpf_send_signal_task() kfunc
Quoted 108 lines · Puranjay Mohan
Quoted 93 lines · Andrii Nakryiko
Quoted 92 lines · Puranjay Mohan
Implement
bpf_send_signal_taskkfunc 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/bpf/helpers.c | 1 + kernel/trace/bpf_trace.c | 52 +++++++++++++++++++++++++++++++++------- 2 files changed, 45 insertions(+), 8 deletions(-)kernel/bpf/helpers.c +1
-0@@ -3035,6 +3035,7 @@ BTF_ID_FLAGS(func, bpf_task_get_cgroup1, KF_ACQUIRE | KF_RCU | KF_RET_NULL)#endif BTF_ID_FLAGS(func, bpf_task_from_pid, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_throw) +BTF_ID_FLAGS(func, bpf_send_signal_task, KF_TRUSTED_ARGS)BTF_KFUNCS_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = {kernel/trace/bpf_trace.c +25
-4@@ -802,6 +802,8 @@ struct send_signal_irq_work {struct task_struct *task;u32 sig;enum pid_type type; +bool has_siginfo; +struct kernel_siginfo info; }; static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);@@ -809,27 +811,46 @@ static DEFINE_PER_CPU(struct send_signal_irq_work, send_signal_work);static void do_bpf_send_signal (struct irq_work *entry) {struct send_signal_irq_work *work; +struct kernel_siginfo *siginfo; work = container_of(entry, struct send_signal_irq_work, irq_work); -group_send_sig_info (work->sig,SEND_SIG_PRIV , work->task, work->type); + siginfo = work->has_siginfo ? &work->info :SEND_SIG_PRIV ; + +group_send_sig_info (work->sig, siginfo, work->task, work->type);put_task_struct (work->task); } -static int bpf_send_signal_common (u32 sig,enum pid_type type) +static int bpf_send_signal_common (u32 sig,enum pid_type type,struct task_struct *task,u64 value) {struct send_signal_irq_work *work =NULL ; +struct kernel_siginfo info; +struct kernel_siginfo *siginfo; + +if (!task) { + task = current; + siginfo =SEND_SIG_PRIV ; + }else { +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_ptr = (void *)(unsigned long )value; + siginfo = &info; + }/* Similar to bpf_probe_write_user, task needs to be * in a sound condition and kernel memory access be * permitted in order to send signal to the current * task. */ -if (unlikely (current->flags & (PF_KTHREAD |PF_EXITING ))) +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 (current))) +if (unlikely (is_global_init (task)))return -EPERM ;Quoted 11 lines
kernel/trace/bpf_trace.c static int bpf_send_signal_common(u32 sig, enum pid_type type) · line 873
Quoted 9 lines
kernel/trace/bpf_trace.c +3
-1if (irqs_disabled ()) {@@ -847,19 +868,21 @@ static int bpf_send_signal_common(u32 sig, enum pid_type type)* to the irq_work. The current task may change when queued * irq works get executed. */ - work->task =get_task_struct (current); + work->task =get_task_struct (task); + work->has_siginfo = siginfo == &info; +copy_siginfo (&work->info, &info);we shouldn't
copy_siginfo()if !work->has_siginfo, no?
Quoted 2 lines
Yes, but it is only used when
has_siginfois true, so copying it doesn't cause any problems. I just didn't want to add another check here.
Still, let's avoid a pointless copy.
If I'm reading it correctly it will copy uninitialized memory and sanitizers won't be happy.
Pls respin.
PATCH v4 2/2 selftests/bpf: Augment send_signal test with remote signaling
In reply to Puranjay MohanAdd testcases to test bpf_send_signal_task(). 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 = (int )(long long )i->si_value.sival_ptr; }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_task(struct task_struct *task, int sig, enum pid_type type, u64 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; +u64 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_task (target_task, sig,PIDTYPE_PID , value); +else + ret =bpf_send_signal_thread (sig); + }else { +if (target_pid) + ret =bpf_send_signal_task (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