X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-abi.c;h=d146e1023efda3c70ee21db5be17a61d63070dc5;hb=cbef69018acdeb52d27529e80126b43f3733e233;hp=ccdfcfad83bb8f5ab3f7c611bb6178ed63ff179a;hpb=b115631f8ae20c4261491c20a88af496f6341e60;p=lttng-ust.git diff --git a/liblttng-ust/lttng-ust-abi.c b/liblttng-ust/lttng-ust-abi.c index ccdfcfad..d146e102 100644 --- a/liblttng-ust/lttng-ust-abi.c +++ b/liblttng-ust/lttng-ust-abi.c @@ -28,9 +28,18 @@ #include #include #include -#include -#include "lttng/core.h" +#include +#include +#include #include "ltt-tracer.h" +#include "tracepoint-internal.h" + +struct ltt_tracepoint_list { + struct tracepoint_iter iter; + int got_first; +}; + +static int lttng_ust_abi_close_in_progress; static int lttng_abi_tracepoint_list(void); @@ -241,9 +250,9 @@ static long lttng_abi_tracer_version(int objd, struct lttng_ust_tracer_version *v) { - v->version = LTTNG_UST_VERSION; - v->patchlevel = LTTNG_UST_PATCHLEVEL; - v->sublevel = LTTNG_UST_SUBLEVEL; + v->major = LTTNG_UST_MAJOR_VERSION; + v->minor = LTTNG_UST_MINOR_VERSION; + v->patchlevel = LTTNG_UST_PATCHLEVEL_VERSION; return 0; } @@ -322,7 +331,7 @@ void lttng_metadata_create_events(int channel_objd) struct ltt_channel *channel = objd_private(channel_objd); static struct lttng_ust_event metadata_params = { .instrumentation = LTTNG_UST_TRACEPOINT, - .name = "lttng_metadata", + .name = "lttng_ust:metadata", }; struct ltt_event *event; int ret; @@ -331,9 +340,8 @@ void lttng_metadata_create_events(int channel_objd) * We tolerate no failure path after event creation. It will stay * invariant for the rest of the session. */ - event = ltt_event_create(channel, &metadata_params, NULL); - if (!event) { - ret = -EINVAL; + ret = ltt_event_create(channel, &metadata_params, NULL, &event); + if (ret < 0) { goto create_error; } return; @@ -355,11 +363,6 @@ int lttng_abi_create_channel(int session_objd, int ret = 0; struct ltt_channel chan_priv_init; - chan_objd = objd_alloc(NULL, <tng_channel_ops); - if (chan_objd < 0) { - ret = chan_objd; - goto objd_error; - } switch (channel_type) { case PER_CPU_CHANNEL: if (chan_param->output == LTTNG_UST_MMAP) { @@ -379,7 +382,12 @@ int lttng_abi_create_channel(int session_objd, break; default: transport_name = ""; - break; + return -EINVAL; + } + chan_objd = objd_alloc(NULL, ops); + if (chan_objd < 0) { + ret = chan_objd; + goto objd_error; } memset(&chan_priv_init, 0, sizeof(chan_priv_init)); /* Copy of session UUID for consumer (availability through shm) */ @@ -502,8 +510,9 @@ static const struct lttng_ust_objd_ops lttng_session_ops = { */ static void ltt_tracepoint_list_get(struct ltt_tracepoint_list *list, - char *tp_list_entry) + struct lttng_ust_tracepoint_iter *tracepoint) { +next: if (!list->got_first) { tracepoint_iter_start(&list->iter); list->got_first = 1; @@ -512,10 +521,27 @@ void ltt_tracepoint_list_get(struct ltt_tracepoint_list *list, tracepoint_iter_next(&list->iter); copy: if (!list->iter.tracepoint) { - tp_list_entry[0] = '\0'; /* end of list */ + tracepoint->name[0] = '\0'; /* end of list */ } else { - memcpy(tp_list_entry, (*list->iter.tracepoint)->name, + if (!strcmp((*list->iter.tracepoint)->name, + "lttng_ust:metadata")) + goto next; + memcpy(tracepoint->name, (*list->iter.tracepoint)->name, LTTNG_UST_SYM_NAME_LEN); +#if 0 + if ((*list->iter.tracepoint)->loglevel) { + memcpy(tracepoint->loglevel, + (*list->iter.tracepoint)->loglevel->identifier, + LTTNG_UST_SYM_NAME_LEN); + tracepoint->loglevel_value = + (*list->iter.tracepoint)->loglevel->value; + } else { +#endif + tracepoint->loglevel[0] = '\0'; + tracepoint->loglevel_value = 0; +#if 0 + } +#endif } } @@ -523,12 +549,13 @@ static long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg) { struct ltt_tracepoint_list *list = objd_private(objd); - char *str = (char *) arg; + struct lttng_ust_tracepoint_iter *tp = + (struct lttng_ust_tracepoint_iter *) arg; switch (cmd) { case LTTNG_UST_TRACEPOINT_LIST_GET: - ltt_tracepoint_list_get(list, str); - if (str[0] == '\0') + ltt_tracepoint_list_get(list, tp); + if (tp->name[0] == '\0') return -ENOENT; return 0; default: @@ -645,9 +672,8 @@ int lttng_abi_create_event(int channel_objd, * We tolerate no failure path after event creation. It will stay * invariant for the rest of the session. */ - event = ltt_event_create(channel, event_param, NULL); - if (!event) { - ret = -EINVAL; + ret = ltt_event_create(channel, event_param, NULL, &event); + if (ret < 0) { goto event_error; } objd_set_private(event_objd, event); @@ -834,7 +860,21 @@ int lttng_rb_release(int objd) buf = priv->buf; channel = priv->ltt_chan; free(priv); - channel->ops->buffer_read_close(buf, channel->handle); + /* + * If we are at ABI exit, we don't want to close the + * buffer opened for read: it is being shared between + * the parent and child (right after fork), and we don't + * want the child to close it for the parent. For a real + * exit, we don't care about marking it as closed, as + * the consumer daemon (if there is one) will do fine + * even if we don't mark it as "closed" for reading on + * our side. + * We only mark it as closed if it is being explicitely + * released by the session daemon with an explicit + * release command. + */ + if (!lttng_ust_abi_close_in_progress) + channel->ops->buffer_read_close(buf, channel->handle); return lttng_ust_objd_unref(channel->objd); } @@ -898,5 +938,7 @@ static const struct lttng_ust_objd_ops lttng_event_ops = { void lttng_ust_abi_exit(void) { + lttng_ust_abi_close_in_progress = 1; objd_table_destroy(); + lttng_ust_abi_close_in_progress = 0; }