X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust-ctl%2Fustctl.c;h=bbf47381e538d2021c2f3a57776549bd4de06f82;hb=53569322d40ed45abe0368ddb08eb4a2738afc37;hp=00d9802ee300a1dfc391e08d3f3e9f1cba0e398f;hpb=da57c034d2c49ed1d4339a776859d44603fc7929;p=lttng-ust.git diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c index 00d9802e..bbf47381 100644 --- a/liblttng-ust-ctl/ustctl.c +++ b/liblttng-ust-ctl/ustctl.c @@ -32,6 +32,7 @@ #include "../libringbuffer/frontend.h" #include "../liblttng-ust/wait.h" #include "../liblttng-ust/lttng-rb-clients.h" +#include "../liblttng-ust/clock.h" /* * Number of milliseconds to retry before failing metadata writes on @@ -230,7 +231,7 @@ int ustctl_add_context(int sock, struct lttng_ust_context *ctx, memset(&lum, 0, sizeof(lum)); lum.handle = obj_data->handle; lum.cmd = LTTNG_UST_CONTEXT; - lum.u.context.ctx = ctx->ctx; + lum.u.context = *ctx; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) { free(context_data); @@ -294,7 +295,7 @@ int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion, return ret; } - /* send var len bytecode */ + /* send var len exclusion names */ ret = ustcomm_send_unix_sock(sock, exclusion->names, exclusion->count * LTTNG_UST_SYM_NAME_LEN); @@ -942,8 +943,14 @@ error: /* Buffer operations */ +int ustctl_get_nr_stream_per_channel(void) +{ + return num_possible_cpus(); +} + struct ustctl_consumer_channel * - ustctl_create_channel(struct ustctl_consumer_channel_attr *attr) + ustctl_create_channel(struct ustctl_consumer_channel_attr *attr, + const int *stream_fds, int nr_stream_fds) { struct ustctl_consumer_channel *chan; const char *transport_name; @@ -995,7 +1002,8 @@ struct ustctl_consumer_channel * attr->subbuf_size, attr->num_subbuf, attr->switch_timer_interval, attr->read_timer_interval, - attr->uuid, attr->chan_id); + attr->uuid, attr->chan_id, + stream_fds, nr_stream_fds); if (!chan->chan) { goto chan_error; } @@ -1012,6 +1020,8 @@ chan_error: void ustctl_destroy_channel(struct ustctl_consumer_channel *chan) { + (void) ustctl_channel_close_wait_fd(chan); + (void) ustctl_channel_close_wakeup_fd(chan); chan->chan->ops->channel_destroy(chan->chan); free(chan); } @@ -1061,7 +1071,7 @@ int ustctl_write_metadata_to_channel( chan->ops->packet_avail_size(chan->chan, chan->handle), len - pos); lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, - sizeof(char), -1, chan->handle); + sizeof(char), -1, chan->handle, NULL); /* * We don't care about metadata buffer's records lost * count, because we always retry here. Report error if @@ -1108,7 +1118,7 @@ ssize_t ustctl_write_one_packet_to_channel( chan->ops->packet_avail_size(chan->chan, chan->handle), len); lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, - sizeof(char), -1, chan->handle); + sizeof(char), -1, chan->handle, NULL); ret = chan->ops->event_reserve(&ctx, 0); if (ret != 0) { DBG("LTTng: event reservation failed"); @@ -1220,6 +1230,8 @@ void ustctl_destroy_stream(struct ustctl_consumer_stream *stream) assert(stream); buf = stream->buf; consumer_chan = stream->chan; + (void) ustctl_stream_close_wait_fd(stream); + (void) ustctl_stream_close_wakeup_fd(stream); lib_ring_buffer_release_read(buf, consumer_chan->chan->handle); free(stream); } @@ -1329,6 +1341,8 @@ int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream, unsigned long sb_bindex; struct lttng_ust_lib_ring_buffer *buf; struct ustctl_consumer_channel *consumer_chan; + struct lttng_ust_lib_ring_buffer_backend_pages_shmp *barray_idx; + struct lttng_ust_lib_ring_buffer_backend_pages *pages; if (!stream) return -EINVAL; @@ -1339,8 +1353,14 @@ int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream, return -EINVAL; sb_bindex = subbuffer_id_get_index(&chan->backend.config, buf->backend.buf_rsb.id); - *off = shmp(consumer_chan->chan->handle, - shmp_index(consumer_chan->chan->handle, buf->backend.array, sb_bindex)->shmp)->mmap_offset; + barray_idx = shmp_index(consumer_chan->chan->handle, buf->backend.array, + sb_bindex); + if (!barray_idx) + return -EINVAL; + pages = shmp(consumer_chan->chan->handle, barray_idx->shmp); + if (!pages) + return -EINVAL; + *off = pages->mmap_offset; return 0; } @@ -1506,6 +1526,8 @@ struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb( struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; chan = shmp(handle, buf->backend.chan); + if (!chan) + return NULL; config = &chan->backend.config; if (!config->cb_ptr) return NULL; @@ -1519,11 +1541,13 @@ int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream, uint64_t *timestamp_begin) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !timestamp_begin) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1534,11 +1558,13 @@ int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream, uint64_t *timestamp_end) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !timestamp_end) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1549,11 +1575,13 @@ int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream, uint64_t *events_discarded) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !events_discarded) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1564,11 +1592,13 @@ int ustctl_get_content_size(struct ustctl_consumer_stream *stream, uint64_t *content_size) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !content_size) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1579,11 +1609,13 @@ int ustctl_get_packet_size(struct ustctl_consumer_stream *stream, uint64_t *packet_size) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !packet_size) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1594,11 +1626,13 @@ int ustctl_get_stream_id(struct ustctl_consumer_stream *stream, uint64_t *stream_id) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !stream_id) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb) return -ENOSYS; @@ -1609,17 +1643,35 @@ int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream, uint64_t *ts) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - struct lttng_ust_lib_ring_buffer *buf = stream->buf; - struct lttng_ust_shm_handle *handle = stream->chan->chan->handle; + struct lttng_ust_lib_ring_buffer *buf; + struct lttng_ust_shm_handle *handle; if (!stream || !ts) return -EINVAL; + buf = stream->buf; + handle = stream->chan->chan->handle; client_cb = get_client_cb(buf, handle); if (!client_cb || !client_cb->current_timestamp) return -ENOSYS; return client_cb->current_timestamp(buf, handle, ts); } +#if defined(__x86_64__) || defined(__i386__) + +int ustctl_has_perf_counters(void) +{ + return 1; +} + +#else + +int ustctl_has_perf_counters(void) +{ + return 0; +} + +#endif + /* * Returns 0 on success, negative error value on error. */ @@ -1707,6 +1759,9 @@ int ustctl_recv_notify(int sock, enum ustctl_notify_cmd *notify_cmd) case 1: *notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL; break; + case 2: + *notify_cmd = USTCTL_NOTIFY_CMD_ENUM; + break; default: return -EINVAL; } @@ -1859,6 +1914,90 @@ int ustctl_reply_register_event(int sock, return 0; } +/* + * Returns 0 on success, negative UST or system error value on error. + */ +int ustctl_recv_register_enum(int sock, + int *session_objd, + char *enum_name, + struct ustctl_enum_entry **entries, + size_t *nr_entries) +{ + ssize_t len; + struct ustcomm_notify_enum_msg msg; + size_t entries_len; + struct ustctl_enum_entry *a_entries = NULL; + + len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg)); + if (len > 0 && len != sizeof(msg)) + return -EIO; + if (len == 0) + return -EPIPE; + if (len < 0) + return len; + + *session_objd = msg.session_objd; + strncpy(enum_name, msg.enum_name, LTTNG_UST_SYM_NAME_LEN); + enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + entries_len = msg.entries_len; + + if (entries_len % sizeof(*a_entries) != 0) { + return -EINVAL; + } + + /* recv entries */ + if (entries_len) { + a_entries = zmalloc(entries_len); + if (!a_entries) + return -ENOMEM; + len = ustcomm_recv_unix_sock(sock, a_entries, entries_len); + if (len > 0 && len != entries_len) { + len = -EIO; + goto entries_error; + } + if (len == 0) { + len = -EPIPE; + goto entries_error; + } + if (len < 0) { + goto entries_error; + } + } + *nr_entries = entries_len / sizeof(*a_entries); + *entries = a_entries; + + return 0; + +entries_error: + free(a_entries); + return len; +} + +/* + * Returns 0 on success, negative error value on error. + */ +int ustctl_reply_register_enum(int sock, + uint64_t id, + int ret_code) +{ + ssize_t len; + struct { + struct ustcomm_notify_hdr header; + struct ustcomm_notify_enum_reply r; + } reply; + + memset(&reply, 0, sizeof(reply)); + reply.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM; + reply.r.ret_code = ret_code; + reply.r.enum_id = id; + len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply)); + if (len > 0 && len != sizeof(reply)) + return -EIO; + if (len < 0) + return len; + return 0; +} + /* * Returns 0 on success, negative UST or system error value on error. */ @@ -1962,6 +2101,7 @@ static __attribute__((constructor)) void ustctl_init(void) { init_usterr(); + lttng_ust_clock_init(); lttng_ring_buffer_metadata_client_init(); lttng_ring_buffer_client_overwrite_init(); lttng_ring_buffer_client_overwrite_rt_init();