Remove inappropriate \n from easy-ust sample

[lttng-ust.git] / liblttng-ust / lttng-ust-comm.c

diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c
index 798c10a36c47bc1e7257227ba57dc46945fac853..e3afe6af562cb8a22207ca90210b3450b8d2453d 100644 (file)
--- a/liblttng-ust/lttng-ust-comm.c
+++ b/liblttng-ust/lttng-ust-comm.c
@@ -46,6 +46,7 @@
 #include <usterr-signal-safe.h>
 #include "tracepoint-internal.h"
 #include "ltt-tracer-core.h"
+#include "../libringbuffer/tlsfixup.h"
 
 /*
  * Has lttng ust comm constructor been called ?
@@ -289,28 +290,30 @@ end:
                //lur.ret_code = USTCOMM_SESSION_FAIL;
                lur.ret_code = ret;
        }
-       switch (lum->cmd) {
-       case LTTNG_UST_STREAM:
-               /*
-                * Special-case reply to send stream info.
-                * Use lum.u output.
-                */
-               lur.u.stream.memory_map_size = *args.stream.memory_map_size;
-               shm_fd = *args.stream.shm_fd;
-               wait_fd = *args.stream.wait_fd;
-               break;
-       case LTTNG_UST_METADATA:
-       case LTTNG_UST_CHANNEL:
-               lur.u.channel.memory_map_size = *args.channel.memory_map_size;
-               shm_fd = *args.channel.shm_fd;
-               wait_fd = *args.channel.wait_fd;
-               break;
-       case LTTNG_UST_TRACER_VERSION:
-               lur.u.version = lum->u.version;
-               break;
-       case LTTNG_UST_TRACEPOINT_LIST_GET:
-               memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
-               break;
+       if (ret >= 0) {
+               switch (lum->cmd) {
+               case LTTNG_UST_STREAM:
+                       /*
+                        * Special-case reply to send stream info.
+                        * Use lum.u output.
+                        */
+                       lur.u.stream.memory_map_size = *args.stream.memory_map_size;
+                       shm_fd = *args.stream.shm_fd;
+                       wait_fd = *args.stream.wait_fd;
+                       break;
+               case LTTNG_UST_METADATA:
+               case LTTNG_UST_CHANNEL:
+                       lur.u.channel.memory_map_size = *args.channel.memory_map_size;
+                       shm_fd = *args.channel.shm_fd;
+                       wait_fd = *args.channel.wait_fd;
+                       break;
+               case LTTNG_UST_TRACER_VERSION:
+                       lur.u.version = lum->u.version;
+                       break;
+               case LTTNG_UST_TRACEPOINT_LIST_GET:
+                       memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
+                       break;
+               }
        }
        ret = send_reply(sock, &lur);
        if (ret < 0) {
@@ -388,12 +391,12 @@ error:
 }
 
 static
-void cleanup_sock_info(struct sock_info *sock_info)
+void cleanup_sock_info(struct sock_info *sock_info, int exiting)
 {
        int ret;
 
        if (sock_info->socket != -1) {
-               ret = close(sock_info->socket);
+               ret = ustcomm_close_unix_sock(sock_info->socket);
                if (ret) {
                        ERR("Error closing apps socket");
                }
@@ -407,7 +410,13 @@ void cleanup_sock_info(struct sock_info *sock_info)
                sock_info->root_handle = -1;
        }
        sock_info->constructor_sem_posted = 0;
-       if (sock_info->wait_shm_mmap) {
+       /*
+        * wait_shm_mmap is used by listener threads outside of the
+        * ust lock, so we cannot tear it down ourselves, because we
+        * cannot join on these threads. Leave this task to the OS
+        * process exit.
+        */
+       if (!exiting && sock_info->wait_shm_mmap) {
                ret = munmap(sock_info->wait_shm_mmap, sysconf(_SC_PAGE_SIZE));
                if (ret) {
                        ERR("Error unmapping wait shm");
@@ -667,7 +676,7 @@ restart:
        }
 
        if (sock_info->socket != -1) {
-               ret = close(sock_info->socket);
+               ret = ustcomm_close_unix_sock(sock_info->socket);
                if (ret) {
                        ERR("Error closing %s apps socket", sock_info->name);
                }
@@ -824,6 +833,15 @@ void __attribute__((constructor)) lttng_ust_init(void)
        if (uatomic_xchg(&initialized, 1) == 1)
                return;
 
+       /*
+        * Fixup interdependency between TLS fixup mutex (which happens
+        * to be the dynamic linker mutex) and ust_lock, taken within
+        * the ust lock.
+        */
+       lttng_fixup_event_tls();
+       lttng_fixup_ringbuffer_tls();
+       lttng_fixup_vtid_tls();
+
        /*
         * We want precise control over the order in which we construct
         * our sub-libraries vs starting to receive commands from
@@ -881,10 +899,17 @@ void __attribute__((constructor)) lttng_ust_init(void)
 static
 void lttng_ust_cleanup(int exiting)
 {
-       cleanup_sock_info(&global_apps);
+       cleanup_sock_info(&global_apps, exiting);
        if (local_apps.allowed) {
-               cleanup_sock_info(&local_apps);
+               cleanup_sock_info(&local_apps, exiting);
        }
+       /*
+        * The teardown in this function all affect data structures
+        * accessed under the UST lock by the listener thread. This
+        * lock, along with the lttng_ust_comm_should_quit flag, ensure
+        * that none of these threads are accessing this data at this
+        * point.
+        */
        lttng_ust_abi_exit();
        lttng_ust_events_exit();
        ltt_ring_buffer_client_discard_exit();
@@ -918,6 +943,7 @@ void __attribute__((destructor)) lttng_ust_exit(void)
        lttng_ust_comm_should_quit = 1;
        ust_unlock();
 
+       /* cancel threads */
        ret = pthread_cancel(global_apps.ust_listener);
        if (ret) {
                ERR("Error cancelling global ust listener thread");
@@ -928,6 +954,14 @@ void __attribute__((destructor)) lttng_ust_exit(void)
                        ERR("Error cancelling local ust listener thread");
                }
        }
+       /*
+        * Do NOT join threads: use of sys_futex makes it impossible to
+        * join the threads without using async-cancel, but async-cancel
+        * is delivered by a signal, which could hit the target thread
+        * anywhere in its code path, including while the ust_lock() is
+        * held, causing a deadlock for the other thread. Let the OS
+        * cleanup the threads if there are stalled in a syscall.
+        */
        lttng_ust_cleanup(1);
 }