Release 8.2.11204

Change how the timers are handled. Instead of spawning a new
thread every time a timer is fired, use a dedicated thread to
handle all timer signals (SIGRTMIN).

Signed-off-by: Brian Bian <brian.bian@intel.com>

Author: bbian

Common/Ver.h

@@ -20,5 +20,5 @@
 
 #define VER_MAJOR        8
 #define VER_MINOR        2
-#define VER_HOTFIX       11203
+#define VER_HOTFIX       11204
 #define VER_BUILD        9999

Common/esif_ccb_timer_lin_user.h

@@ -27,6 +27,7 @@
 
 #include <signal.h>
 
+typedef void (*esif_ccb_tmrm_cb_t)(esif_ccb_timer_handle_t cb_handle);
 
 #pragma pack(push, 1)
 
@@ -49,25 +50,17 @@ struct esif_timer_obj {
 	esif_ccb_timer_handle_t timer_cb_handle;
 };
 
+struct esif_tmrm_cb_obj {
+	esif_ccb_tmrm_cb_t func;
+	esif_ccb_timer_handle_t cb_handle;
+};
+
 #pragma pack(pop)
 
 static ESIF_INLINE void esif_ccb_timer_obj_disable_timer(
 	struct esif_timer_obj *self
 	);
 
-
-static ESIF_INLINE void esif_ccb_tmrm_cb_wrapper(
-	const union sigval sv
-	)
-{
-	esif_ccb_timer_handle_t cb_handle = {0};
-
-	cb_handle = (esif_ccb_timer_handle_t) sv.sival_int;
-
-	esif_ccb_tmrm_callback(cb_handle);
-}
-
-
 static ESIF_INLINE enum esif_rc esif_ccb_timer_obj_create_timer(
 	struct esif_timer_obj *self
 	)
@@ -77,7 +70,6 @@ static ESIF_INLINE enum esif_rc esif_ccb_timer_obj_create_timer(
 	return ESIF_OK;
 }
 
-
 static ESIF_INLINE enum esif_rc esif_ccb_timer_obj_enable_timer(
 	struct esif_timer_obj *self,
 	const esif_ccb_time_t timeout	/* Timeout in msec */
@@ -86,19 +78,24 @@ static ESIF_INLINE enum esif_rc esif_ccb_timer_obj_enable_timer(
 	enum esif_rc rc = ESIF_OK;
 	struct sigevent se;
 	struct itimerspec its;
-	pthread_attr_t attr;
 	u64 freq_nanosecs = timeout * 1000 * 1000; /* convert msec to nsec */
+	struct esif_tmrm_cb_obj *cb_object_ptr = NULL;
 
 	ESIF_ASSERT(self != NULL);
 
-	pthread_attr_init(&attr);
-
 	esif_ccb_timer_obj_disable_timer(self);
 
-	se.sigev_notify = SIGEV_THREAD;
-	se.sigev_notify_function   = esif_ccb_tmrm_cb_wrapper;
-	se.sigev_value.sival_int   = self->timer_cb_handle;
-	se.sigev_notify_attributes = &attr;
+	cb_object_ptr = (struct esif_tmrm_cb_obj *) esif_ccb_malloc(sizeof(*cb_object_ptr));
+	if (NULL == cb_object_ptr) {
+		rc = ESIF_E_NO_MEMORY;
+		goto exit;
+	}
+	cb_object_ptr->func = esif_ccb_tmrm_callback;
+	cb_object_ptr->cb_handle = self->timer_cb_handle;
+
+	se.sigev_notify = SIGEV_SIGNAL;
+	se.sigev_signo = SIGRTMIN;
+	se.sigev_value.sival_ptr = cb_object_ptr;
 
 	if (0 != timer_create(CLOCK_REALTIME,
 		&se,
@@ -117,7 +114,6 @@ static ESIF_INLINE enum esif_rc esif_ccb_timer_obj_enable_timer(
 		goto exit;
 	}
 exit:
-	pthread_attr_destroy(&attr);
 	return rc;
 }
 

ESIF/Products/ESIF_UF/Sources/lin/main.c

@@ -53,6 +53,9 @@ static esif_thread_t g_udev_thread;
 static Bool g_udev_quit = ESIF_TRUE;
 static char *g_udev_target = NULL;
 
+/* Dedicated thread to handle SIGRTMIN timer signals */
+static esif_thread_t g_sigrtmin_thread;
+
 #define MAX_PAYLOAD 1024 /* max message size*/
 
 static struct sockaddr_nl sock_addr_src, sock_addr_dest;
@@ -378,6 +381,52 @@ static void sigusr1_enable()
 	sigaction(SIGUSR1, &action, NULL);
 }
 
+static void sigrtmin_block(void)
+{
+	/* Block SIGRTMIN; other threads created from the main thread
+	 * will inherit a copy of the signal mask.
+	 */
+	sigset_t set = {0};
+	sigemptyset(&set);
+	sigaddset(&set, SIGRTMIN);
+	if (pthread_sigmask(SIG_BLOCK, &set, NULL)) {
+		ESIF_TRACE_ERROR("Fail to block SIGRTMIN\n");
+	}
+}
+
+static void *sigrtmin_worker_thread(void *ptr)
+{
+	sigset_t set = {0};
+	siginfo_t info = {0};
+	struct esif_tmrm_cb_obj *cb_object_ptr = NULL;
+
+	UNREFERENCED_PARAMETER(ptr);
+	sigemptyset(&set);
+	sigaddset(&set, SIGRTMIN);
+
+	while (1) { /* This thread will be canceled/killed after esif_uf_exit() */
+		if (-1 == sigwaitinfo(&set, &info)) { /* sigwaitinfo is a cancellation point */
+			ESIF_TRACE_ERROR("sigwaitinfo failed\n");
+			continue;
+		}
+
+		if (SIGRTMIN != info.si_signo) {
+			ESIF_TRACE_ERROR("Received signal is not SIGRTMIN, ignore\n");
+			continue;
+		}
+
+		cb_object_ptr = (struct esif_tmrm_cb_obj *) info.si_value.sival_ptr;
+		if (cb_object_ptr && cb_object_ptr->func) {
+			cb_object_ptr->func(cb_object_ptr->cb_handle);
+			cb_object_ptr->func = NULL;
+			esif_ccb_free(cb_object_ptr);
+		} else {
+			ESIF_TRACE_ERROR("Invalid timer callback object: (obj=%p, func=%p)\n",
+				cb_object_ptr, (cb_object_ptr ? cb_object_ptr->func : NULL));
+		}
+	}
+}
+
 #if !defined(ESIF_ATTR_INSTANCE_LOCK)
 // Instance Checking Disabled in Android for now
 
@@ -748,7 +797,10 @@ static int run_as_daemon(int start_with_pipe, int start_with_log, int start_in_b
 			exit(EXIT_SUCCESS);
 	}
 
-	/* 3. Call setsid (if background daemon) */
+	/* 3. Block SIGRTMIN (will re-enable it in a dedicated thread) */
+	sigrtmin_block();
+
+	/* 4. Call setsid (if background daemon) */
 	if (start_in_background && -1 == setsid()) {
 		printf("ESIF_UFD: setsid failed. Error #%d\n", errno);
 		return ESIF_FALSE;
@@ -760,13 +812,13 @@ static int run_as_daemon(int start_with_pipe, int start_with_log, int start_in_b
 	}
 	sigterm_enable();
 
-	/* 4. Change to known directory.  Performed in main */
-	/* 5. Close all file descriptors incuding stdin, stdout, stderr */
+	/* 5. Change to known directory.  Performed in main */
+	/* 6. Close all file descriptors incuding stdin, stdout, stderr */
 	close(STDIN_FILENO); /* stdin */
 	close(STDOUT_FILENO); /* stdout */
 	close(STDERR_FILENO); /* stderr */
 
-	/* 6. Open file descriptors 0, 1, and 2 and redirect */
+	/* 7. Open file descriptors 0, 1, and 2 and redirect */
 	/* stdin */
 	if (ESIF_TRUE == start_with_log) {
 		unlink(cmd_out);
@@ -796,6 +848,9 @@ static int run_as_daemon(int start_with_pipe, int start_with_log, int start_in_b
 		esif_ccb_thread_create(&g_thread, esif_event_worker_thread, "Daemon");
 	}
 
+	/* Start the thread that handles SIGRTMIN */
+	esif_ccb_thread_create(&g_sigrtmin_thread, sigrtmin_worker_thread, NULL);
+
 #ifdef ESIF_FEAT_OPT_ACTION_SYSFS
 	/* uevent listener */
 	esif_udev_start();
@@ -893,6 +948,7 @@ static int run_as_server(FILE* input, char* command, int quit_after_command)
 	if (!instance_lock()) {
 		return ESIF_FALSE;
 	}
+	sigrtmin_block(); /* Block SIGRTMIN (will re-enable it in a dedicated thread) */
 	sigterm_enable();
 
 	g_DataVaultStartScript = ESIF_STARTUP_SCRIPT_SERVER_MODE;
@@ -903,6 +959,9 @@ static int run_as_server(FILE* input, char* command, int quit_after_command)
 		esif_ccb_sleep_msec(10);
 	}
 
+	/* Start the thread that handles SIGRTMIN */
+	esif_ccb_thread_create(&g_sigrtmin_thread, sigrtmin_worker_thread, NULL);
+
 #ifdef ESIF_FEAT_OPT_ACTION_SYSFS
 	/* uevent listener */
 	esif_udev_start();
@@ -1167,6 +1226,18 @@ int main (int argc, char **argv)
 	/* Exit ESIF */
 	esif_uf_exit();
 
+	/* Stop and join the SIGRTMIN worker thread.
+	 * All ESIF timers should have been canceled
+	 * after esif_uf_exit() call, so it is safe
+	 * to terminate the g_sigrtmin_thread now.
+	 */
+#ifdef ESIF_ATTR_OS_ANDROID
+	pthread_kill(g_sigrtmin_thread, SIGRTMIN);
+#else
+	pthread_cancel(g_sigrtmin_thread);
+#endif
+	esif_ccb_thread_join(&g_sigrtmin_thread);
+
 	/* Release Instance Lock and exit*/
 	instance_unlock();
 	esif_main_exit();