Revert "Fix timestamps for slow-paced event rates"

[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 336510003a01006afb722cab4dbb056d89976fbd..798c10a36c47bc1e7257227ba57dc46945fac853 100644 (file)
--- a/liblttng-ust/lttng-ust-comm.c
+++ b/liblttng-ust/lttng-ust-comm.c
@@ -239,6 +239,7 @@ int handle_message(struct sock_info *sock_info,
        const struct lttng_ust_objd_ops *ops;
        struct ustcomm_ust_reply lur;
        int shm_fd, wait_fd;
+       union ust_args args;
 
        ust_lock();
 
@@ -271,7 +272,8 @@ int handle_message(struct sock_info *sock_info,
        default:
                if (ops->cmd)
                        ret = ops->cmd(lum->handle, lum->cmd,
-                                       (unsigned long) &lum->u);
+                                       (unsigned long) &lum->u,
+                                       &args);
                else
                        ret = -ENOSYS;
                break;
@@ -293,23 +295,21 @@ end:
                 * Special-case reply to send stream info.
                 * Use lum.u output.
                 */
-               lur.u.stream.memory_map_size = lum->u.stream.memory_map_size;
-               shm_fd = lum->u.stream.shm_fd;
-               wait_fd = lum->u.stream.wait_fd;
+               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 = lum->u.channel.memory_map_size;
-               shm_fd = lum->u.channel.shm_fd;
-               wait_fd = lum->u.channel.wait_fd;
+               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_list_entry,
-                       lum->u.tracepoint_list_entry,
-                       LTTNG_UST_SYM_NAME_LEN);
+               memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
                break;
        }
        ret = send_reply(sock, &lur);
@@ -338,6 +338,50 @@ end:
                        goto error;
                }
        }
+       /*
+        * We still have the memory map reference, and the fds have been
+        * sent to the sessiond. We can therefore close those fds. Note
+        * that we keep the write side of the wait_fd open, but close
+        * the read side.
+        */
+       if (lur.ret_code == USTCOMM_OK) {
+               switch (lum->cmd) {
+               case LTTNG_UST_STREAM:
+                       if (shm_fd >= 0) {
+                               ret = close(shm_fd);
+                               if (ret) {
+                                       PERROR("Error closing stream shm_fd");
+                               }
+                               *args.stream.shm_fd = -1;
+                       }
+                       if (wait_fd >= 0) {
+                               ret = close(wait_fd);
+                               if (ret) {
+                                       PERROR("Error closing stream wait_fd");
+                               }
+                               *args.stream.wait_fd = -1;
+                       }
+                       break;
+               case LTTNG_UST_METADATA:
+               case LTTNG_UST_CHANNEL:
+                       if (shm_fd >= 0) {
+                               ret = close(shm_fd);
+                               if (ret) {
+                                       PERROR("Error closing channel shm_fd");
+                               }
+                               *args.channel.shm_fd = -1;
+                       }
+                       if (wait_fd >= 0) {
+                               ret = close(wait_fd);
+                               if (ret) {
+                                       PERROR("Error closing channel wait_fd");
+                               }
+                               *args.channel.wait_fd = -1;
+                       }
+                       break;
+               }
+       }
+
 error:
        ust_unlock();
        return ret;
@@ -415,7 +459,7 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size)
                 * shared memory map will have been created.
                 */
                pid = wait(&status);
-               if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+               if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
                        wait_shm_fd = -1;
                        goto end;
                }
@@ -563,14 +607,15 @@ void wait_for_sessiond(struct sock_info *sock_info)
                if (ret < 0) {
                        if (errno == EFAULT) {
                                wait_poll_fallback = 1;
-                               WARN(
+                               DBG(
 "Linux kernels 2.6.33 to 3.0 (with the exception of stable versions) "
 "do not support FUTEX_WAKE on read-only memory mappings correctly. "
 "Please upgrade your kernel "
 "(fix is commit 9ea71503a8ed9184d2d0b8ccc4d269d05f7940ae in Linux kernel "
 "mainline). LTTng-UST will use polling mode fallback.");
+                               if (ust_debug())
+                                       PERROR("futex");
                        }
-                       PERROR("futex");
                }
        }
        return;