Skip to contentSkip to conversation

bpf: implement bpf_send_signal_pid/tgid() helpers

PATCH In review Puranjay Mohan 3 participants 8 messages Jul 24, 2024 – Sep 5, 2024

Subsystems (6)
Kselftest BPF Tracing BPF selftests +2 more subsystems
lore
Share & tools
lore
#0 lore raw

PATCH 1/2 bpf: implement bpf_send_signal_pid/tgid() helpers

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

---
 include/uapi/linux/bpf.h       | 37 ++++++++++++++++++++++++
 kernel/trace/bpf_trace.c       | 53 +++++++++++++++++++++++++++++-----
 tools/include/uapi/linux/bpf.h | 37 ++++++++++++++++++++++++
 3 files changed, 120 insertions(+), 7 deletions(-)
include/uapi/linux/bpf.h +37 -0
index 35bcf52dbc65..7b29003c079c 100644
@@ -5792,6 +5792,41 @@ union bpf_attr {
  *		0 on success.
  *
  *		**-ENOENT** if the bpf_local_storage cannot be found.
+ *
+ * long bpf_send_signal_pid(u32 sig, u32 pid)
+ *	Description
+ *		Send signal *sig* to the thread corresponding to the
+ *		process id *pid*.
+ *	Return
+ *		0 on success or successfully queued.
+ *
+ *		**-EBUSY** if work queue under nmi is full.
+ *
+ *		**-EINVAL** if *sig* is invalid.
+ *
+ *		**-EPERM** if no permission to send the *sig*.
+ *
+ *		**-EAGAIN** if bpf program can try again.
+ *
+ *		**-ESRCH** if *pid* is invalid.
+ *
+ * long bpf_send_signal_tgid(u32 sig, u32 tgid)
+ *	Description
+ *		Send signal *sig* to the process corresponding to the
+ *		thread group id *tgid*.
+ *		The signal may be delivered to any of this process's threads.
+ *	Return
+ *		0 on success or successfully queued.
+ *
+ *		**-EBUSY** if work queue under nmi is full.
+ *
+ *		**-EINVAL** if *sig* is invalid.
+ *
+ *		**-EPERM** if no permission to send the *sig*.
+ *
+ *		**-EAGAIN** if bpf program can try again.
+ *
+ *		**-ESRCH** if *tgid* is invalid.
  */
 #define ___BPF_FUNC_MAPPER(FN, ctx...)			\
 	FN(unspec, 0, ##ctx)				\
@@ -6006,6 +6041,8 @@ union bpf_attr {
 	FN(user_ringbuf_drain, 209, ##ctx)		\
 	FN(cgrp_storage_get, 210, ##ctx)		\
 	FN(cgrp_storage_delete, 211, ##ctx)		\
+	FN(send_signal_pid, 212, ##ctx)		\
+	FN(send_signal_tgid, 213, ##ctx)		\
 	/* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +46 -7

105 lines not on this page · raw message

tools/include/uapi/linux/bpf.h +37 -0
index 35bcf52dbc65..7b29003c079c 100644
@@ -5792,6 +5792,41 @@ union bpf_attr {
  *		0 on success.
  *
  *		**-ENOENT** if the bpf_local_storage cannot be found.
+ *
+ * long bpf_send_signal_pid(u32 sig, u32 pid)
+ *	Description
+ *		Send signal *sig* to the thread corresponding to the
+ *		process id *pid*.
+ *	Return
+ *		0 on success or successfully queued.
+ *
+ *		**-EBUSY** if work queue under nmi is full.
+ *
+ *		**-EINVAL** if *sig* is invalid.
+ *
+ *		**-EPERM** if no permission to send the *sig*.
+ *
+ *		**-EAGAIN** if bpf program can try again.
+ *
+ *		**-ESRCH** if *pid* is invalid.
+ *
+ * long bpf_send_signal_tgid(u32 sig, u32 tgid)
+ *	Description
+ *		Send signal *sig* to the process corresponding to the
+ *		thread group id *tgid*.
+ *		The signal may be delivered to any of this process's threads.
+ *	Return
+ *		0 on success or successfully queued.
+ *
+ *		**-EBUSY** if work queue under nmi is full.
+ *
+ *		**-EINVAL** if *sig* is invalid.
+ *
+ *		**-EPERM** if no permission to send the *sig*.
+ *
+ *		**-EAGAIN** if bpf program can try again.
+ *
+ *		**-ESRCH** if *tgid* is invalid.
  */
 #define ___BPF_FUNC_MAPPER(FN, ctx...)			\
 	FN(unspec, 0, ##ctx)				\
@@ -6006,6 +6041,8 @@ union bpf_attr {
 	FN(user_ringbuf_drain, 209, ##ctx)		\
 	FN(cgrp_storage_get, 210, ##ctx)		\
 	FN(cgrp_storage_delete, 211, ##ctx)		\
+	FN(send_signal_pid, 212, ##ctx)		\
+	FN(send_signal_tgid, 213, ##ctx)		\
 	/* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
Signature · 1 line
2.40.1
#1 lore raw

PATCH 2/2 selftests/bpf: Augment send_signal test with remote signaling

Add testcases to test bpf_send_signal_pid/tgid(). In these new test cases, the main process triggers the BPF program and the forked process receives the signals.

---
 .../selftests/bpf/prog_tests/send_signal.c    | 110 +++++++++++++-----
 .../bpf/progs/test_send_signal_kern.c         |  17 ++-
 2 files changed, 95 insertions(+), 32 deletions(-)
tools/testing/selftests/bpf/prog_tests/send_signal.c +83 -27
index 6cc69900b310..a8392dfc69e2 100644
@@ -12,13 +12,15 @@ static void sigusr1_handler(int signum)
 }
 
 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;
 	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,9 +41,6 @@ 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");
 
@@ -52,10 +51,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,9 +67,12 @@ 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';
@@ -79,7 +83,8 @@ static void test_send_signal_common(struct perf_event_attr *attr,
 		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 +98,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 +116,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 +139,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"))
@@ -142,18 +181,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 +204,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 +233,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 +12 -5
index 92354cd72044..fd6c055377ae 100644
@@ -4,7 +4,7 @@
 #include <linux/version.h>
 #include <bpf/bpf_helpers.h>
 
-__u32 sig = 0, pid = 0, status = 0, signal_thread = 0;
+__u32 sig = 0, pid = 0, status = 0, signal_thread = 0, target_pid = 0;
 
 static __always_inline int bpf_send_signal_test(void *ctx)
 {
@@ -14,10 +14,17 @@ static __always_inline int bpf_send_signal_test(void *ctx)
 		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 (signal_thread) {
+			if (target_pid != 0)
+				ret = bpf_send_signal_pid(sig, target_pid);
+			else
+				ret = bpf_send_signal_thread(sig);
+		} else {
+			if (target_pid != 0)
+				ret = bpf_send_signal_tgid(sig, target_pid);
+			else
+				ret = bpf_send_signal(sig);
+		}
 		if (ret == 0)
 			status = 1;
 	}
Signature · 1 line
2.40.1
#2 lore raw
In reply to Puranjay Mohan
Quoted 5 lines · Puranjay Mohan

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 853

Quoted 5 lines
kernel/trace/bpf_trace.c +5 -0
+               if (!tsk)
+                       return -ESRCH;
+       } else {
+               tsk = current;
+       }

pw-bot: cr

#3 lore raw

Alexei Starovoitov <[email protected]> writes:

Hi,
Sorry for the delay on this.

Quoted 44 lines · Puranjay Mohan
Quoted 5 lines

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

Quoted 8 lines

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

So, I will add a single kfunc that can do both pid and tgid and it will take the 'task' parameter received from the call to bpf_task_from_pid() and a 'bool' to select pid/tgid.

Quoted 6 lines

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 853

Quoted 6 lines
kernel/trace/bpf_trace.c +5 -0
+               if (!tsk)
+                       return -ESRCH;
+       } else {
+               tsk = current;
+       }

Thanks,
Puranjay

#4 lore raw
Quoted 54 lines · Puranjay Mohan

Alexei Starovoitov <[email protected]> writes:

Hi,
Sorry for the delay on this.

Quoted 48 lines · Puranjay Mohan
Quoted 5 lines

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Quoted 8 lines
Quoted 4 lines

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

So, I will add a single kfunc that can do both pid and tgid and it will take the 'task' parameter received from the call to bpf_task_from_pid() and a 'bool' to select pid/tgid.

why bool ?
enum pid_type is kernel enum that is available to bpf progs via vmlinux.h. The prog can just pass that directly. Do you see any safety issue that it will pass PIDTYPE_MAX ? If so that can be an additional check inside kfunc.

#5 lore raw
In reply to Puranjay Mohan
Quoted 54 lines · Puranjay Mohan

Alexei Starovoitov <[email protected]> writes:

Hi,
Sorry for the delay on this.

Quoted 48 lines · Puranjay Mohan
Quoted 5 lines

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Quoted 8 lines
Quoted 4 lines

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

So, I will add a single kfunc that can do both pid and tgid and it will take the 'task' parameter received from the call to bpf_task_from_pid() and a 'bool' to select pid/tgid.

Can you please also investigate passing an extra u64 of "context" to the signal handler? It's been requested before, and at least for some signals the kernel seems to support this functionality. Would be best to avoid proliferation of kfuncs, if we can handle all this in one.

Quoted 10 lines
Quoted 7 lines

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 853

Quoted 7 lines
kernel/trace/bpf_trace.c +5 -0
+               if (!tsk)
+                       return -ESRCH;
+       } else {
+               tsk = current;
+       }

Thanks,
Puranjay

#6 lore raw
Quoted 60 lines · Andrii Nakryiko
Quoted 59 lines · Puranjay Mohan

Alexei Starovoitov <[email protected]> writes:

Hi,
Sorry for the delay on this.

Quoted 52 lines · Puranjay Mohan
Quoted 5 lines

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

Quoted 9 lines
Quoted 3 lines

So, I will add a single kfunc that can do both pid and tgid and it will take the 'task' parameter received from the call to bpf_task_from_pid() and a 'bool' to select pid/tgid.

Can you please also investigate passing an extra u64 of "context" to the signal handler? It's been requested before, and at least for some signals the kernel seems to support this functionality. Would be best to avoid proliferation of kfuncs, if we can handle all this in one.

Yes, I will look into that. Are you referring to the 'void *context' that is passed to the handlers registered with sigaction()? like:

--- 8< ---

void handle_prof_signal(int signal, siginfo_t * info, void * context) {
}

struct sigaction sig_action;
struct sigaction old_action;

memset(&sig_action, 0, sizeof(sig_action));

sig_action.sa_sigaction = handle_prof_signal;
sig_action.sa_flags = SA_RESTART | SA_SIGINFO;
sigemptyset(&sig_action.sa_mask);

sigaction(SIGPROF, &sig_action, &old_action);

--- >8 ---

And we want to the BPF program to also be able to pass a custom context to the signal handler like above? is there an existing mechanism to do that in the kernel?

Thanks,
Puranjay

#7 lore raw
Quoted 91 lines · Puranjay Mohan
Quoted 60 lines · Andrii Nakryiko
Quoted 59 lines · Puranjay Mohan

Alexei Starovoitov <[email protected]> writes:

Hi,
Sorry for the delay on this.

Quoted 52 lines · Puranjay Mohan
Quoted 5 lines

Implement bpf_send_signal_pid and bpf_send_signal_tgid helpers which are similar to bpf_send_signal_thread and bpf_send_signal helpers respectively but can be used to send signals to other threads and processes.

Thanks for working on this!
But it needs more homework.

include/uapi/linux/bpf.h union bpf_attr { · line 6045

Quoted 8 lines
 #define ___BPF_FUNC_MAPPER(FN, ctx...)                 \
        FN(unspec, 0, ##ctx)                            \
include/uapi/linux/bpf.h +2 -0
@@ -6006,6 +6041,8 @@ union bpf_attr {
        FN(user_ringbuf_drain, 209, ##ctx)              \
        FN(cgrp_storage_get, 210, ##ctx)                \
        FN(cgrp_storage_delete, 211, ##ctx)             \
+       FN(send_signal_pid, 212, ##ctx)         \
+       FN(send_signal_tgid, 213, ##ctx)                \

We stopped adding helpers long ago. They need to be kfuncs.

Quoted 9 lines
include/uapi/linux/bpf.h +0 -0
        /* */
 
 /* backwards-compatibility macros for users of __BPF_FUNC_MAPPER that don't
kernel/trace/bpf_trace.c +0 -0
index cd098846e251..f1e58122600d 100644
@@ -839,21 +839,30 @@ static void do_bpf_send_signal(struct irq_work *entry)
        put_task_struct(work->task);

kernel/trace/bpf_trace.c static void do_bpf_send_signal(struct irq_work *entry) · line 848

Quoted 10 lines
kernel/trace/bpf_trace.c +5 -1
 }
 
-static int bpf_send_signal_common(u32 sig, enum pid_type type)
+static int bpf_send_signal_common(u32 sig, enum pid_type type, u32 pid)
 {
        struct send_signal_irq_work *work = NULL;
+       struct task_struct *tsk;
+
+       if (pid) {
+               tsk = find_task_by_vpid(pid);

by vpid ?

tracing bpf prog will have "random" current and "random" pidns.

Should it be find_get_task vs find_task too ?

Should kfunc take 'task' parameter instead received from bpf_task_from_pid() ?

two kfuncs for pid/tgid is overkill. Combine into one?

Quoted 9 lines
Quoted 3 lines

So, I will add a single kfunc that can do both pid and tgid and it will take the 'task' parameter received from the call to bpf_task_from_pid() and a 'bool' to select pid/tgid.

Can you please also investigate passing an extra u64 of "context" to the signal handler? It's been requested before, and at least for some signals the kernel seems to support this functionality. Would be best to avoid proliferation of kfuncs, if we can handle all this in one.

Yes, I will look into that. Are you referring to the 'void *context' that is passed to the handlers registered with sigaction()? like:

--- 8< ---

void handle_prof_signal(int signal, siginfo_t * info, void * context) {
}

struct sigaction sig_action;
struct sigaction old_action;

memset(&sig_action, 0, sizeof(sig_action));

sig_action.sa_sigaction = handle_prof_signal;
sig_action.sa_flags = SA_RESTART | SA_SIGINFO;
sigemptyset(&sig_action.sa_mask);

Quoted 7 lines

sigaction(SIGPROF, &sig_action, &old_action);

--- >8 ---

And we want to the BPF program to also be able to pass a custom context to the signal handler like above? is there an existing mechanism to do that in the kernel?

There must be. I think last time I looked at this, I found this (from [0]):

• If the signal is sent using sigqueue(3), an accompanying value (either an integer or a pointer) can be sent with the signal. If the receiving process establishes a handler for this signal using the SA_SIGINFO flag to sigaction(2), then it can obtain this data via the si_value field of the siginfo_t structure passed as the second argument to the handler. Furthermore, the si_pid and si_uid fields of this structure can be used to obtain the PID and real user ID of the process sending the signal.

And there were some kernel-side parts related to that, yes. But please take a look yourself and check if it's all sane.

[0] https://man7.org/linux/man-pages/man7/signal.7.html

Quoted 3 lines

Thanks,
Puranjay