[zombie issue] Update workqueue shutdown and sigaction

Change-Id: Ibe4a3dccaea5923c443486d9fea1ca49dad7363f

diff --git a/include/mmsvc_core_workqueue.h b/include/mmsvc_core_workqueue.h
index 07bb9be..655b11f 100644 (file)
--- a/include/mmsvc_core_workqueue.h
+++ b/include/mmsvc_core_workqueue.h
@@ -27,13 +27,14 @@ typedef struct mmsvc_core_workqueue_workqueue {
        struct mmsvc_core_workqueue_job *waiting_jobs;
        pthread_mutex_t jobs_mutex;
        pthread_cond_t jobs_cond;
-       pthread_t thread;
        void (*shutdown)(void);
        void (*add_job)(mmsvc_core_workqueue_job_t *);
 } mmsvc_core_workqueue_workqueue_t;
 
 typedef struct mmsvc_core_workqueue_worker {
+       pthread_t thread;
        int terminate;
+       struct mmsvc_core_workqueue_workqueue *workqueue;
        struct mmsvc_core_workqueue_worker *prev;
        struct mmsvc_core_workqueue_worker *next;
 } mmsvc_core_workqueue_worker_t;

diff --git a/src/mmsvc_core.c b/src/mmsvc_core.c
index d80b05c..5df46ea 100644 (file)
--- a/src/mmsvc_core.c
+++ b/src/mmsvc_core.c
@@ -470,8 +470,8 @@ int mmsvc_core_client_get_capi(Client client)
 
 void mmsvc_core_connection_close(int sock_fd)
 {
-       LOGD("Enter");
        if (sock_fd > 0) {
+               LOGD("[%d] shutdown", sock_fd);
                shutdown(sock_fd, SHUT_RDWR);
                close(sock_fd);
        }

diff --git a/src/mmsvc_core_ipc.c b/src/mmsvc_core_ipc.c
index 7ae243c..c12bef3 100644 (file)
--- a/src/mmsvc_core_ipc.c
+++ b/src/mmsvc_core_ipc.c
@@ -52,6 +52,7 @@ static void _mmsvc_core_ipc_client_cleanup(Client client)
        client->ch[MUSED_CHANNEL_DATA].queue = NULL;
        g_cond_broadcast(&client->ch[MUSED_CHANNEL_DATA].cond);
        g_thread_join(client->ch[MUSED_CHANNEL_DATA].p_gthread);
+       g_thread_unref(client->ch[MUSED_CHANNEL_DATA].p_gthread);
        g_mutex_clear(&client->ch[MUSED_CHANNEL_DATA].mutex);
        g_cond_clear(&client->ch[MUSED_CHANNEL_DATA].cond);
        LOGD("worker exit");
@@ -188,9 +189,8 @@ static gpointer _mmsvc_core_ipc_data_worker(gpointer data)
                                if (mmsvc_core_msg_json_deserialize_type("client_addr",
                                                        recvBuff, &client_addr, NULL, MUSED_TYPE_POINTER)) {
                                        client = (Client) client_addr;
-                                       if (client) {
+                                       if (client)
                                                client->ch[MUSED_CHANNEL_DATA].p_gthread = g_thread_self();
-                                       }
                                }
                                MMSVC_FREE(recvBuff);
                                recvBuff = NULL;

diff --git a/src/mmsvc_core_log.c b/src/mmsvc_core_log.c
index 4e92291..9dc2209 100644 (file)
--- a/src/mmsvc_core_log.c
+++ b/src/mmsvc_core_log.c
@@ -48,11 +48,7 @@
 static mmsvc_core_log_t *g_mused_log = NULL;
 volatile unsigned int received_signal_flags = 0;
 
-static void _mmsvc_core_log_sig_child(int signo);
 static void _mmsvc_core_log_sig_abort(int signo);
-static void _mmsvc_core_log_sig_terminate(int signo);
-static void _mmsvc_core_log_sig_restart(int signo);
-static int _mmsvc_core_log_init_signal_set(void);
 static void _mmsvc_core_log_init_signals(void);
 static int _mmsvc_core_log_fd_set_block(int fd);
 static void _mmsvc_core_log_sigaction(int signo, siginfo_t *si, void *arg);
@@ -61,27 +57,18 @@ static void _mmsvc_core_log_init_instance(void (*log)(char *), void (*fatal)(cha
        gboolean(*get_module_opened) (int), GModule * (*get_module_value) (int), void (*set_msg) (char *), char * (*get_msg) (void));
 static void _mmsvc_core_log_monitor(char *msg);
 static void _mmsvc_core_log_fatal(char *msg);
-static int _mmsvc_core_log_init_signal_set(void);
 static void _mmsvc_core_log_set_module_value(int index, GModule *module, gboolean value);
 static void _mmsvc_core_log_set_msg(char *msg);
 static char *_mmsvc_core_log_get_msg(void);
 static gboolean _mmsvc_core_log_get_module_opened(int index);
 static GModule *_mmsvc_core_log_get_module_value(int index);
 
-static void _mmsvc_core_log_sig_child(int signo)
-{
-       received_signal_flags |= RECEIVED_SIG_CHLD;
-
-       if (SIG_ERR == signal(SIGCHLD, _mmsvc_core_log_sig_child))
-               LOGE("SIGCHLD handler: %s", strerror(errno));
-}
-
 static void _mmsvc_core_log_sig_abort(int signo)
 {
        received_signal_flags |= RECEIVED_SIG_ABORT;
 
        if (SIG_ERR == signal(SIGABRT, SIG_DFL))
-               LOGE("SIGABRT andler: %s", strerror(errno));
+               LOGE("SIGABRT handler: %s", strerror(errno));
 
        static char client_name[256];
        memset(client_name, '\0', sizeof(client_name));
@@ -110,95 +97,22 @@ static void _mmsvc_core_log_sig_abort(int signo)
 
        mmsvc_core_workqueue_get_instance()->shutdown();
 
+       LOGD("abort signal");
        abort();
 }
 
-static void _mmsvc_core_log_sig_terminate(int signo)
-{
-       if (signo == SIGSEGV || signo == SIGXCPU || signo == SIGBUS) {
-               if (signo == SIGXCPU) {
-                       received_signal_flags |= RECEIVED_SIG_XCPU;
-               } else {
-                       received_signal_flags |= RECEIVED_SIG_SEGV;
-               }
-
-               LOGD("mused terminating (%d)", signo);
-
-       } else if (signo == SIGTERM) {
-               received_signal_flags |= RECEIVED_SIG_TERMINATE;
-
-       } else {
-               received_signal_flags |= RECEIVED_SIG_TERM_OTHER;
-       }
-
-       if (SIG_ERR == signal(signo, SIG_IGN))
-               LOGE("handler for %d: %s", signo, strerror(errno));
-}
-
-static void _mmsvc_core_log_sig_restart(int signo)
-{
-       received_signal_flags |= RECEIVED_SIG_RESTART;
-
-       if (SIG_ERR == signal(SIGHUP, _mmsvc_core_log_sig_restart))
-               LOGE("SIGHUP andler: %s", strerror(errno));
-}
-
-static void _mmsvc_core_log_signals_handle_event(int signo)
-{
-       received_signal_flags |= RECEIVED_SIG_EVENT;
-
-       if (SIG_ERR == signal(SIGUSR2, _mmsvc_core_log_signals_handle_event))
-               LOGE(" SIGUSR2 handler: %s", strerror(errno));
-}
-
-static int _mmsvc_core_log_init_signal_set(void)
-{
-       sigset_t mmsvc_core_log_sig_set;
-
-       sigemptyset(&mmsvc_core_log_sig_set);
-
-       sigaddset(&mmsvc_core_log_sig_set, SIGCHLD);
-       sigaddset(&mmsvc_core_log_sig_set, SIGINT);
-       sigaddset(&mmsvc_core_log_sig_set, SIGQUIT);
-       sigaddset(&mmsvc_core_log_sig_set, SIGILL);
-       sigaddset(&mmsvc_core_log_sig_set, SIGABRT);
-       sigaddset(&mmsvc_core_log_sig_set, SIGFPE);
-       sigaddset(&mmsvc_core_log_sig_set, SIGSEGV);
-       sigaddset(&mmsvc_core_log_sig_set, SIGALRM);
-       sigaddset(&mmsvc_core_log_sig_set, SIGTERM);
-       sigaddset(&mmsvc_core_log_sig_set, SIGHUP);
-       sigaddset(&mmsvc_core_log_sig_set, SIGUSR2);
-       sigaddset(&mmsvc_core_log_sig_set, SIGSTKFLT);
-       sigaddset(&mmsvc_core_log_sig_set, SIGIO);
-       sigaddset(&mmsvc_core_log_sig_set, SIGBUS);
-
-       if (SIG_ERR == signal(SIGCHLD, _mmsvc_core_log_sig_child) || SIG_ERR == signal(SIGHUP, _mmsvc_core_log_sig_restart)
-               || SIG_ERR == signal(SIGINT, _mmsvc_core_log_sig_terminate) || SIG_ERR == signal(SIGQUIT, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGILL, _mmsvc_core_log_sig_terminate) || SIG_ERR == signal(SIGFPE, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGABRT, _mmsvc_core_log_sig_abort) || SIG_ERR == signal(SIGSEGV, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGXCPU, _mmsvc_core_log_sig_terminate) || SIG_ERR == signal(SIGBUS, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGALRM, SIG_IGN) || SIG_ERR == signal(SIGTERM, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGURG, SIG_IGN) || SIG_ERR == signal(SIGSTKFLT, _mmsvc_core_log_sig_terminate)
-               || SIG_ERR == signal(SIGIO, SIG_IGN) || SIG_ERR == signal(SIGUSR2, _mmsvc_core_log_signals_handle_event)
-               || 0 > sigprocmask(SIG_UNBLOCK, &mmsvc_core_log_sig_set, NULL)) {
-                       LOGE("signal : %s", strerror(errno));
-               }
-
-       return 0;
-}
-
 static void _mmsvc_core_log_init_signals(void)
 {
        struct sigaction action;
 
-       _mmsvc_core_log_init_signal_set();
-
        memset(&action, 0, sizeof(sigaction));
        sigemptyset(&action.sa_mask);
        action.sa_sigaction = _mmsvc_core_log_sigaction;
        action.sa_flags = SA_RESTART | SA_SIGINFO;
 
        sigaction(SIGSEGV, &action, NULL);
+       sigaction(SIGABRT, &action, NULL);
+       sigaction(SIGTERM, &action, NULL);
        sigaction(SIGBUS, &action, NULL);
        sigaction(SIGXCPU, &action, NULL);
        sigaction(SIGUSR1, &action, NULL);
@@ -226,8 +140,6 @@ static void _mmsvc_core_log_sigaction(int signo, siginfo_t *si, void *arg)
        g_return_if_fail(si != NULL);
        g_return_if_fail(arg != NULL);
 
-       _mmsvc_core_log_sig_terminate(signo);
-
        LOGE("----------BEGIN MUSED DYING MESSAGE----------");
 
        tracesize = backtrace(trace, TUNABLE_CALLER_DEPTH);

diff --git a/src/mmsvc_core_server.c b/src/mmsvc_core_server.c
index 5bb826c..dea129d 100644 (file)
--- a/src/mmsvc_core_server.c
+++ b/src/mmsvc_core_server.c
@@ -112,7 +112,7 @@ int main(int argc, char **argv)
        /* create new session */
        sid = setsid();
        if (sid < 0) {
-               LOGE("sid SID : %d, PID CLOSE!!", pid);
+               LOGE("SID : %d, PID CLOSE!!", sid);
                exit(0);
        }
 

diff --git a/src/mmsvc_core_workqueue.c b/src/mmsvc_core_workqueue.c
index 5681978..6b671fb 100644 (file)
--- a/src/mmsvc_core_workqueue.c
+++ b/src/mmsvc_core_workqueue.c
@@ -34,15 +34,15 @@ static void *_mmsvc_core_workqueue_worker_function(void *ptr)
 
        while (1) {
                /* Wait until we get notified. */
-               pthread_mutex_lock(&g_workqueue->jobs_mutex);
-               while (g_workqueue->waiting_jobs == NULL) {
+               pthread_mutex_lock(&worker->workqueue->jobs_mutex);
+               while (worker->workqueue->waiting_jobs == NULL) {
                        /* If we're supposed to terminate, break out of our continuous loop. */
                        if (worker->terminate) {
                                LOGD("worker is terminated");
                                break;
                        }
 
-                       pthread_cond_wait(&g_workqueue->jobs_cond, &g_workqueue->jobs_mutex);
+                       pthread_cond_wait(&worker->workqueue->jobs_cond, &worker->workqueue->jobs_mutex);
                }
 
                /* If we're supposed to terminate, break out of our continuous loop. */
@@ -51,11 +51,11 @@ static void *_mmsvc_core_workqueue_worker_function(void *ptr)
                        break;
                }
 
-               job = g_workqueue->waiting_jobs;
+               job = worker->workqueue->waiting_jobs;
                if (job != NULL)
-                       LL_REMOVE(job, g_workqueue->waiting_jobs);
+                       LL_REMOVE(job, worker->workqueue->waiting_jobs);
 
-               pthread_mutex_unlock(&g_workqueue->jobs_mutex);
+               pthread_mutex_unlock(&worker->workqueue->jobs_mutex);
 
                /* If we didn't get a job, then there's nothing to do at this time. */
                if (job == NULL)
@@ -65,7 +65,7 @@ static void *_mmsvc_core_workqueue_worker_function(void *ptr)
                job->job_function(job);
        }
 
-       pthread_mutex_unlock(&g_workqueue->jobs_mutex);
+       pthread_mutex_unlock(&worker->workqueue->jobs_mutex);
        MMSVC_FREE(worker);
 
        pthread_exit(NULL);
@@ -80,14 +80,11 @@ static void _mmsvc_core_workqueue_shutdown(void)
 
        /* Set all workers to terminate. */
        for (worker = g_workqueue->workers; worker != NULL; worker = worker->next)
-               worker->terminate = 1; /* shutdown notification */
+               worker->terminate = 1;
 
-       /* Remove all workers and jobs from the work queue. Wake up all workers so that they will terminate. */
+       pthread_mutex_lock(&g_workqueue->jobs_mutex);
        g_workqueue->workers = NULL;
        g_workqueue->waiting_jobs = NULL;
-       pthread_mutex_lock(&g_workqueue->jobs_mutex);
-       LOGD("pthread_join(workqueue)");
-       pthread_join(g_workqueue->thread, NULL);
        pthread_cond_broadcast(&g_workqueue->jobs_cond);
        pthread_mutex_unlock(&g_workqueue->jobs_mutex);
        LOGD("Leave");
@@ -96,7 +93,7 @@ static void _mmsvc_core_workqueue_shutdown(void)
 static void _mmsvc_core_workqueue_add_job(mmsvc_core_workqueue_job_t *job)
 {
        LOGD("Enter");
-       /* Add the job to the job queue, and notify a worker. */
+
        pthread_mutex_lock(&g_workqueue->jobs_mutex);
        LL_ADD(job, g_workqueue->waiting_jobs);
        pthread_cond_signal(&g_workqueue->jobs_cond);
@@ -116,16 +113,15 @@ static void _mmsvc_core_workqueue_init_instance(void (*shutdown)(void), void (*a
 
 mmsvc_core_workqueue_workqueue_t *mmsvc_core_workqueue_get_instance(void)
 {
-       LOGD("Enter");
        if (g_workqueue == NULL)
                mmsvc_core_workqueue_init(WORK_THREAD_NUM);
 
-       LOGD("Leave");
        return g_workqueue;
 }
 
 int mmsvc_core_workqueue_init(int numWorkers)
 {
+       mmsvc_core_workqueue_worker_t *worker;
        int i;
        pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
        pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -138,19 +134,24 @@ int mmsvc_core_workqueue_init(int numWorkers)
 
        if (numWorkers < 1)
                numWorkers = 1;
+       memset(g_workqueue, 0, sizeof(*g_workqueue));
        memcpy(&g_workqueue->jobs_mutex, &blank_mutex, sizeof(g_workqueue->jobs_mutex));
        memcpy(&g_workqueue->jobs_cond, &blank_cond, sizeof(g_workqueue->jobs_cond));
 
        for (i = 0; i < numWorkers; i++) {
-               g_workqueue->workers = calloc(1, sizeof(mmsvc_core_workqueue_worker_t));
-               g_return_val_if_fail(g_workqueue->workers != NULL, 1);
-
-               if (pthread_create(&g_workqueue->thread, NULL, _mmsvc_core_workqueue_worker_function, (void *)g_workqueue->workers)) {
+               worker = malloc(sizeof(mmsvc_core_workqueue_worker_t));
+               if (worker == NULL) {
+                       LOGE("Failed to allocate all workers");
+                       return 1;
+               }
+               memset(worker, 0, sizeof(*worker));
+               worker->workqueue = g_workqueue;
+               if (pthread_create(&worker->thread, NULL, _mmsvc_core_workqueue_worker_function, (void *)worker)) {
                        LOGE("Failed to start all worker threads");
-                       MMSVC_FREE(g_workqueue->workers);
+                       MMSVC_FREE(worker);
                        return 1;
                }
-               LL_ADD(g_workqueue->workers, g_workqueue->workers);
+               LL_ADD(worker, worker->workqueue->workers);
        }
 
        _mmsvc_core_workqueue_init_instance(_mmsvc_core_workqueue_shutdown, _mmsvc_core_workqueue_add_job);