X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;ds=sidebyside;f=liblttng-ust-ctl%2Fustctl.c;h=964a5586677a3dc4c68d9046a8fa9a51bac1b39c;hb=5cbd73b809f24c435cc4b4523e8add1fda3acfb5;hp=13100aebdcda0ba4f3b7aacc4242846e9e9c0937;hpb=f1fffc5728684ddf7ec3c674515c313e693bd3c4;p=lttng-ust.git diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c index 13100aeb..964a5586 100644 --- a/liblttng-ust-ctl/ustctl.c +++ b/liblttng-ust-ctl/ustctl.c @@ -17,6 +17,7 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#define _GNU_SOURCE #include #include #include @@ -40,14 +41,29 @@ void init_object(struct lttng_ust_object_data *data) data->memory_map_size = 0; } +int ustctl_release_handle(int sock, int handle) +{ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret; + + if (sock >= 0) { + memset(&lum, 0, sizeof(lum)); + lum.handle = handle; + lum.cmd = LTTNG_UST_RELEASE; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret < 0) { + return ret; + } + } + return 0; +} /* * If sock is negative, it means we don't have to notify the other side * (e.g. application has already vanished). */ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) { - struct ustcomm_ust_msg lum; - struct ustcomm_ust_reply lur; int ret; if (data->shm_fd >= 0) { @@ -62,16 +78,7 @@ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) return ret; } } - if (sock >= 0) { - memset(&lum, 0, sizeof(lum)); - lum.handle = data->handle; - lum.cmd = LTTNG_UST_RELEASE; - ret = ustcomm_send_app_cmd(sock, &lum, &lur); - if (ret < 0) { - return ret; - } - } - return 0; + return ustctl_release_handle(sock, data->handle); } /* @@ -129,7 +136,7 @@ int ustctl_open_metadata(int sock, int session_handle, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *metadata_data; - int ret; + int ret, err = 0; metadata_data = malloc(sizeof(*metadata_data)); if (!metadata_data) @@ -160,13 +167,21 @@ int ustctl_open_metadata(int sock, int session_handle, /* get shm fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) - goto error; - metadata_data->shm_fd = ret; + err = 1; + else + metadata_data->shm_fd = ret; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) + err = 1; + else + metadata_data->wait_fd = ret; + if (err) goto error; - metadata_data->wait_fd = ret; *_metadata_data = metadata_data; return 0; @@ -183,7 +198,7 @@ int ustctl_create_channel(int sock, int session_handle, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *channel_data; - int ret; + int ret, err = 0; channel_data = malloc(sizeof(*channel_data)); if (!channel_data) @@ -214,13 +229,21 @@ int ustctl_create_channel(int sock, int session_handle, /* get shm fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) - goto error; - channel_data->shm_fd = ret; + err = 1; + else + channel_data->shm_fd = ret; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) + err = 1; + else + channel_data->wait_fd = ret; + if (err) goto error; - channel_data->wait_fd = ret; *_channel_data = channel_data; return 0; @@ -241,7 +264,7 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *stream_data; - int ret, fd; + int ret, fd, err = 0; stream_data = malloc(sizeof(*stream_data)); if (!stream_data) @@ -266,13 +289,21 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, /* get shm fd */ fd = ustcomm_recv_fd(sock); if (fd < 0) - goto error; - stream_data->shm_fd = fd; + err = 1; + else + stream_data->shm_fd = fd; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ fd = ustcomm_recv_fd(sock); if (fd < 0) + err = 1; + else + stream_data->wait_fd = fd; + if (err) goto error; - stream_data->wait_fd = fd; *_stream_data = stream_data; return ret; @@ -301,6 +332,8 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev, strncpy(lum.u.event.name, ev->name, LTTNG_UST_SYM_NAME_LEN); lum.u.event.instrumentation = ev->instrumentation; + lum.u.event.loglevel_type = ev->loglevel_type; + lum.u.event.loglevel = ev->loglevel; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) { free(event_data); @@ -420,10 +453,9 @@ int ustctl_tracepoint_list_get(int sock, int tp_list_handle, ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; - DBG("received tracepoint list entry name %s loglevel %s loglevel_value %lld", + DBG("received tracepoint list entry name %s loglevel %d", lur.u.tracepoint.name, - lur.u.tracepoint.loglevel, - (unsigned long long) lur.u.tracepoint.loglevel_value); + lur.u.tracepoint.loglevel); memcpy(iter, &lur.u.tracepoint, sizeof(*iter)); return 0; } @@ -501,12 +533,24 @@ struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *ch return NULL; } /* - * Set to -1 because the lttng_ust_shm_handle destruction will take care - * of closing shm_fd and wait_fd. + * Set to -1, and then close the shm fd, and set the handle shm + * fd to -1 too. We don't need the shm fds after they have been + * mapped. + * The wait_fd is set to -1 in chan_data because it is now owned + * by the handle. */ chan_data->shm_fd = -1; chan_data->wait_fd = -1; + /* chan is object 0. This is hardcoded. */ + if (handle->table->objects[0].shm_fd >= 0) { + ret = close(handle->table->objects[0].shm_fd); + if (ret) { + perror("Error closing shm_fd"); + } + handle->table->objects[0].shm_fd = -1; + } + /* * TODO: add consistency checks to be resilient if the * application try to feed us with incoherent channel structure @@ -590,12 +634,15 @@ void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle) channel_destroy(chan, handle, 1); } +/* + * ustctl closes the shm_fd fds after mapping it. + */ struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_handle *handle, int cpu) { struct channel *chan = handle->shadow_chan; - int shm_fd, wait_fd; - uint64_t memory_map_size; + int *shm_fd, *wait_fd; + uint64_t *memory_map_size; struct lttng_ust_lib_ring_buffer *buf; int ret; @@ -606,6 +653,16 @@ struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_h ret = lib_ring_buffer_open_read(buf, handle, 1); if (ret) return NULL; + /* + * We can close shm_fd early, right after is has been mapped. + */ + if (*shm_fd >= 0) { + ret = close(*shm_fd); + if (ret) { + perror("Error closing shm_fd"); + } + *shm_fd = -1; + } return buf; }