fix: prepare ebpf worker threads for crash capture

Route C/eBPF worker creation through monitored thread helpers so covered threads install crash-monitor preparation before running.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: yinjiping

agent/src/ebpf/user/profile/java/jvm_symbol_collect.c

@@ -871,22 +871,16 @@ static int thread_pool_add_task(symbol_collect_thread_pool_t * pool,
 		pool->thread_index = pool->thread_count;
 
 		if ((ret =
-		     pthread_create(&thread, NULL, &worker_thread, pool)) < 0) {
+		     create_monitored_pthread("java-sym-wk", &thread,
+					      worker_thread, pool,
+					      true)) != ETR_OK) {
 			ebpf_warning(JAVA_LOG_TAG
 				     "Create worker thread failed with '%s(%d)'\n",
 				     strerror(errno), errno);
 			pthread_mutex_unlock(&pool->lock);
 			return -2;
 		}
 
-		if (pthread_detach(thread) != 0) {
-			ebpf_warning(JAVA_LOG_TAG
-				     "Failed to detach thread with '%s(%d)'\n",
-				     strerror(errno), errno);
-			pthread_mutex_unlock(&pool->lock);
-			return -1;
-		}
-
 		task_thread_t *new_threads = realloc(pool->threads,
 						     (++pool->thread_count) *
 						     sizeof(task_thread_t));

agent/src/ebpf/user/socket.c

@@ -2362,11 +2362,12 @@ static int dispatch_workers_setup(struct bpf_tracer *tracer,
 
 		pthread_mutex_init(&tracer->queues[i].mutex, NULL);
 		pthread_cond_init(&tracer->queues[i].cond, NULL);
-		ret =
-		    pthread_create(&tracer->dispatch_workers[i], NULL,
-				   (void *)&process_data,
-				   (void *)&tracer->queues[i]);
-		if (ret) {
+		ret = create_monitored_work_thread(name,
+						    &tracer->dispatch_workers[i],
+						    process_data,
+						    (void *)&tracer->queues[i],
+						    true);
+		if (ret != ETR_OK) {
 			ebpf_info
 			    ("<%s> process_data, pthread_create is error:%s\n",
 			     __func__, strerror(errno));
@@ -2729,10 +2730,10 @@ int running_socket_tracer(tracer_callback_t handle,
 
 	if ((ret = sockopt_register(&datadump_sockopts)) != ETR_OK)
 		return ret;
-	ret =
-	    pthread_create(&proc_events_pthread, NULL,
-			   (void *)&process_events_handle_main, (void *)tracer);
-	if (ret) {
+	ret = create_monitored_work_thread("proc-events", &proc_events_pthread,
+					 process_events_handle_main, (void *)tracer,
+					 true);
+	if (ret != ETR_OK) {
 		ebpf_warning
 		    ("proc_events_pthread, pthread_create is error:%s\n",
 		     strerror(errno));

agent/src/ebpf/user/tracer.c

@@ -294,32 +294,17 @@ int enable_tracer_reader_work(const char *prefix_name, int idx,
 {
 	int ret;
 	char name[TASK_COMM_LEN];
+
 	snprintf(name, sizeof(name), "%s-%d", prefix_name, idx);
-	ret = pthread_create(&tracer->perf_workers[idx], NULL, fn,
-			     (void *)(uint64_t) idx);
-	if (ret) {
+	ret = create_monitored_pthread(name, &tracer->perf_workers[idx],
+				       (pthread_thread_func_t)fn,
+				       (void *)(uint64_t)idx, true);
+	if (ret != ETR_OK) {
 		ebpf_warning("tracer reader(%s), pthread_create "
 			     "is error:%s\n", name, strerror(errno));
 		return ETR_INVAL;
 	}
 
-	/* set thread name */
-	pthread_setname_np(tracer->perf_workers[idx], name);
-
-	/*
-	 * Separating threads is to automatically release
-	 * resources after pthread_exit(), without being
-	 * blocked or stuck.
-	 */
-	ret = pthread_detach(tracer->perf_workers[idx]);
-	if (ret != 0) {
-		ebpf_warning("Error detaching thread, error:%s\n",
-			     strerror(errno));
-		return ETR_INVAL;
-	} else {
-		ebpf_info("thread %s, detached successful.", name);
-	}
-
 	return ETR_OK;
 }
 
@@ -1729,12 +1714,18 @@ static void period_process_main(__unused void *arg)
 	pthread_t threads[sys_cpus_count];
 	int i;
 	for (i = 0; i < sys_cpus_count; i++) {
-		if (cpu_online[i])
-			if (pthread_create
-			    (&threads[i], NULL, kick_kern_push_data,
-			     (void *)(uintptr_t) i) != 0) {
-				ebpf_warning("pthread_create failed");
-			}
+		int ret;
+		char name[NAME_LEN];
+
+		if (!cpu_online[i])
+			continue;
+
+		snprintf(name, sizeof(name), "kick-kern.%d", i);
+		ret = create_monitored_pthread(name, &threads[i],
+					       kick_kern_push_data,
+					       (void *)(uintptr_t)i, true);
+		if (ret != ETR_OK)
+			ebpf_warning("pthread_create failed");
 	}
 
 	// Only this unique identifier can be adapted to the kernel
@@ -2279,8 +2270,9 @@ int bpf_tracer_init(const char *log_file, bool is_stdout)
 	if ((err = sockopt_register(&match_pids_sockopts)) != ETR_OK)
 		return err;
 
-	err = pthread_create(&ctrl_pthread, NULL, (void *)&ctrl_main, NULL);
-	if (err) {
+	err = create_monitored_work_thread("ctrl-main", &ctrl_pthread,
+					 ctrl_main, NULL, true);
+	if (err != ETR_OK) {
 		ebpf_info("<%s> ctrl_pthread, pthread_create is error:%s\n",
 			  __func__, strerror(errno));
 		return ETR_INVAL;
@@ -2315,10 +2307,9 @@ int bpf_tracer_init(const char *log_file, bool is_stdout)
 				     SYS_TIME_UPDATE_PERIOD))
 		return ETR_INVAL;
 
-	err =
-	    pthread_create(&cpus_kick_pthread, NULL,
-			   (void *)&period_process_main, NULL);
-	if (err) {
+	err = create_monitored_work_thread("period-process", &cpus_kick_pthread,
+					 period_process_main, NULL, true);
+	if (err != ETR_OK) {
 		ebpf_info
 		    ("<%s> cpus_kick_pthread, pthread_create is error:%s\n",
 		     __func__, strerror(errno));

agent/src/ebpf/user/utils.c

@@ -1639,37 +1639,105 @@ u32 djb2_32bit(const char *str)
 	return hash;		// 32-bit output
 }
 
-#if !defined(AARCH64_MUSL) && !defined(JAVA_AGENT_ATTACH_TOOL)
-int create_work_thread(const char *name, pthread_t * t, void *fn, void *arg)
+#if !defined(JAVA_AGENT_ATTACH_TOOL)
+#include "crash_monitor.h"
+
+enum monitored_thread_kind {
+	MONITORED_THREAD_WORK = 0,
+	MONITORED_THREAD_PTHREAD = 1,
+};
+
+struct monitored_thread_args {
+	enum monitored_thread_kind kind;
+	work_thread_func_t work_fn;
+	pthread_thread_func_t pthread_fn;
+	void *arg;
+};
+
+static void *monitored_thread_main(void *arg)
+{
+	struct monitored_thread_args *thread_args = arg;
+	void *ret = NULL;
+
+	if (thread_args == NULL)
+		return NULL;
+
+	(void)crash_monitor_prepare_thread();
+	if (thread_args->kind == MONITORED_THREAD_WORK) {
+		if (thread_args->work_fn != NULL)
+			thread_args->work_fn(thread_args->arg);
+	} else if (thread_args->pthread_fn != NULL) {
+		ret = thread_args->pthread_fn(thread_args->arg);
+	}
+
+	free(thread_args);
+	return ret;
+}
+
+static int create_monitored_thread_common(const char *name, pthread_t *t,
+					  work_thread_func_t work_fn,
+					  pthread_thread_func_t pthread_fn,
+					  void *arg, bool detached)
 {
 	int ret;
-	ret = pthread_create(t, NULL, fn, arg);
+	struct monitored_thread_args *thread_args;
+
+	thread_args = calloc(1, sizeof(*thread_args));
+	if (thread_args == NULL) {
+		ebpf_warning("worker name %s alloc failed:%s\n",
+			     name, strerror(errno));
+		return ETR_NOMEM;
+	}
+
+	thread_args->kind = (pthread_fn != NULL) ?
+		MONITORED_THREAD_PTHREAD : MONITORED_THREAD_WORK;
+	thread_args->work_fn = work_fn;
+	thread_args->pthread_fn = pthread_fn;
+	thread_args->arg = arg;
+
+	ret = pthread_create(t, NULL, monitored_thread_main, thread_args);
 	if (ret) {
 		ebpf_warning("worker name %s is error:%s\n",
 			     name, strerror(errno));
+		free(thread_args);
 		return ETR_INVAL;
 	}
 
-	/* set thread name */
 	pthread_setname_np(*t, name);
+	if (!detached)
+		return ETR_OK;
 
-	/*
-	 * Separating threads is to automatically release
-	 * resources after pthread_exit(), without being
-	 * blocked or stuck.
-	 */
 	ret = pthread_detach(*t);
 	if (ret != 0) {
 		ebpf_warning("Error detaching thread, error:%s\n",
 			     strerror(errno));
 		return ETR_INVAL;
-	} else {
-		ebpf_info("thread %s, detached successful.", name);
 	}
 
+	ebpf_info("thread %s, detached successful.", name);
 	return ETR_OK;
 }
-#endif /* !defined(AARCH64_MUSL) && !defined(JAVA_AGENT_ATTACH_TOOL) */
+
+int create_monitored_work_thread(const char *name, pthread_t *t,
+				 work_thread_func_t fn, void *arg,
+				 bool detached)
+{
+	return create_monitored_thread_common(name, t, fn, NULL, arg, detached);
+}
+
+int create_monitored_pthread(const char *name, pthread_t *t,
+			     pthread_thread_func_t fn, void *arg,
+			     bool detached)
+{
+	return create_monitored_thread_common(name, t, NULL, fn, arg, detached);
+}
+
+int create_work_thread(const char *name, pthread_t * t, void *fn, void *arg)
+{
+	return create_monitored_work_thread(name, t,
+				    (work_thread_func_t)fn, arg, true);
+}
+#endif /* !defined(JAVA_AGENT_ATTACH_TOOL) */
 
 static inline int compare(const void *a, const void *b)
 {

agent/src/ebpf/user/utils.h

@@ -342,7 +342,16 @@ void format_port_ranges(uint16_t *ports, size_t size, char *ret_str, int str_sz)
  * @return 32-bit hash value computed over the input data.
  */
 uint32_t murmurhash(const void *key, size_t len, uint32_t seed);
-#if !defined(AARCH64_MUSL) && !defined(JAVA_AGENT_ATTACH_TOOL)
+#if !defined(JAVA_AGENT_ATTACH_TOOL)
+typedef void (*work_thread_func_t)(void *);
+typedef void *(*pthread_thread_func_t)(void *);
+
+int create_monitored_work_thread(const char *name, pthread_t *t,
+				 work_thread_func_t fn, void *arg,
+				 bool detached);
+int create_monitored_pthread(const char *name, pthread_t *t,
+			     pthread_thread_func_t fn, void *arg,
+			     bool detached);
 int create_work_thread(const char *name, pthread_t *t, void *fn, void *arg);
-#endif /* !defined(AARCH64_MUSL) && !defined(JAVA_AGENT_ATTACH_TOOL) */
+#endif /* !defined(JAVA_AGENT_ATTACH_TOOL) */
 #endif /* DF_COMMON_H */