X-Git-Url: http://git.lttng.org/?p=lttng-ust.git;a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-abi.c;h=77bb90db02d24d42ccdf6c996a3d1c82e9266e70;hp=25f213bbc1ce1bf72fd09194459177f9bfce5064;hb=118c051e465a0bffe22bb5bc57943f54c4afdc86;hpb=574a6217af27f0e1ca8998790ce7744684d83168 diff --git a/liblttng-ust/lttng-ust-abi.c b/liblttng-ust/lttng-ust-abi.c index 25f213bb..77bb90db 100644 --- a/liblttng-ust/lttng-ust-abi.c +++ b/liblttng-ust/lttng-ust-abi.c @@ -1,10 +1,25 @@ /* * lttng-ust-abi.c * - * Copyright 2010-2011 (c) - Mathieu Desnoyers - * * LTTng UST ABI * + * Copyright (C) 2010-2012 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; only + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * * Mimic system calls for: * - session creation, returns an object descriptor or failure. * - channel creation, returns an object descriptor or failure. @@ -20,24 +35,41 @@ * - Takes an instrumentation source as parameter * - e.g. tracepoints, dynamic_probes... * - Takes instrumentation source specific arguments. - * - * Dual LGPL v2.1/GPL v2 license. */ -#include +#define _LGPL_SOURCE +#include +#include +#include + #include #include + +#include +#include +#include +#include #include #include +#include #include -#include -#include "ltt-tracer.h" + +#include "../libringbuffer/frontend_types.h" +#include "../libringbuffer/shm.h" +#include "../libcounter/counter.h" #include "tracepoint-internal.h" +#include "lttng-tracer.h" +#include "string-utils.h" +#include "ust-events-internal.h" + +#define OBJ_NAME_LEN 16 static int lttng_ust_abi_close_in_progress; static -int lttng_abi_tracepoint_list(void); +int lttng_abi_tracepoint_list(void *owner); +static +int lttng_abi_tracepoint_field_list(void *owner); /* * Object descriptor table. Should be protected from concurrent access @@ -50,6 +82,9 @@ struct lttng_ust_obj { void *private_data; const struct lttng_ust_objd_ops *ops; int f_count; + int owner_ref; /* has ref from owner */ + void *owner; + char name[OBJ_NAME_LEN]; } s; int freelist_next; /* offset freelist. end is -1. */ } u; @@ -66,7 +101,8 @@ static struct lttng_ust_objd_table objd_table = { }; static -int objd_alloc(void *private_data, const struct lttng_ust_objd_ops *ops) +int objd_alloc(void *private_data, const struct lttng_ust_objd_ops *ops, + void *owner, const char *name) { struct lttng_ust_obj *obj; @@ -102,6 +138,10 @@ end: obj->u.s.ops = ops; obj->u.s.f_count = 2; /* count == 1 : object is allocated */ /* count == 2 : allocated + hold ref */ + obj->u.s.owner_ref = 1; /* One owner reference */ + obj->u.s.owner = owner; + strncpy(obj->u.s.name, name, OBJ_NAME_LEN); + obj->u.s.name[OBJ_NAME_LEN - 1] = '\0'; return obj - objd_table.array; } @@ -156,10 +196,11 @@ static void objd_ref(int id) { struct lttng_ust_obj *obj = _objd_get(id); + assert(obj != NULL); obj->u.s.f_count++; } -int lttng_ust_objd_unref(int id) +int lttng_ust_objd_unref(int id, int is_owner) { struct lttng_ust_obj *obj = _objd_get(id); @@ -169,9 +210,16 @@ int lttng_ust_objd_unref(int id) ERR("Reference counting error\n"); return -EINVAL; } + if (is_owner) { + if (!obj->u.s.owner_ref) { + ERR("Error decrementing owner reference"); + return -EINVAL; + } + obj->u.s.owner_ref--; + } if ((--obj->u.s.f_count) == 1) { const struct lttng_ust_objd_ops *ops = objd_ops(id); - + if (ops->release) ops->release(id); objd_free(id); @@ -184,8 +232,16 @@ void objd_table_destroy(void) { int i; - for (i = 0; i < objd_table.allocated_len; i++) - (void) lttng_ust_objd_unref(i); + for (i = 0; i < objd_table.allocated_len; i++) { + struct lttng_ust_obj *obj; + + obj = _objd_get(i); + if (!obj) + continue; + if (!obj->u.s.owner_ref) + continue; /* only unref owner ref. */ + (void) lttng_ust_objd_unref(i, 1); + } free(objd_table.array); objd_table.array = NULL; objd_table.len = 0; @@ -193,52 +249,89 @@ void objd_table_destroy(void) objd_table.freelist_head = -1; } +const char *lttng_ust_obj_get_name(int id) +{ + struct lttng_ust_obj *obj = _objd_get(id); + + if (!obj) + return NULL; + return obj->u.s.name; +} + +void lttng_ust_objd_table_owner_cleanup(void *owner) +{ + int i; + + for (i = 0; i < objd_table.allocated_len; i++) { + struct lttng_ust_obj *obj; + + obj = _objd_get(i); + if (!obj) + continue; + if (!obj->u.s.owner) + continue; /* skip root handles */ + if (!obj->u.s.owner_ref) + continue; /* only unref owner ref. */ + if (obj->u.s.owner == owner) + (void) lttng_ust_objd_unref(i, 1); + } +} + /* * This is LTTng's own personal way to create an ABI for sessiond. * We send commands over a socket. */ static const struct lttng_ust_objd_ops lttng_ops; +static const struct lttng_ust_objd_ops lttng_event_notifier_group_ops; static const struct lttng_ust_objd_ops lttng_session_ops; static const struct lttng_ust_objd_ops lttng_channel_ops; -static const struct lttng_ust_objd_ops lttng_metadata_ops; -static const struct lttng_ust_objd_ops lttng_event_ops; -static const struct lttng_ust_objd_ops lttng_loglevel_ops; -static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops; +static const struct lttng_ust_objd_ops lttng_event_enabler_ops; +static const struct lttng_ust_objd_ops lttng_event_notifier_enabler_ops; static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops; - -enum channel_type { - PER_CPU_CHANNEL, - METADATA_CHANNEL, -}; +static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops; int lttng_abi_create_root_handle(void) { int root_handle; - root_handle = objd_alloc(NULL, <tng_ops); + /* root handles have NULL owners */ + root_handle = objd_alloc(NULL, <tng_ops, NULL, "root"); return root_handle; } static -int lttng_abi_create_session(void) +int lttng_is_channel_ready(struct lttng_channel *lttng_chan) +{ + struct channel *chan; + unsigned int nr_streams, exp_streams; + + chan = lttng_chan->chan; + nr_streams = channel_handle_get_nr_streams(lttng_chan->handle); + exp_streams = chan->nr_streams; + return nr_streams == exp_streams; +} + +static +int lttng_abi_create_session(void *owner) { - struct ltt_session *session; + struct lttng_session *session; int session_objd, ret; - session = ltt_session_create(); + session = lttng_session_create(); if (!session) return -ENOMEM; - session_objd = objd_alloc(session, <tng_session_ops); + session_objd = objd_alloc(session, <tng_session_ops, owner, "session"); if (session_objd < 0) { ret = session_objd; goto objd_error; } session->objd = session_objd; + session->owner = owner; return session_objd; objd_error: - ltt_session_destroy(session); + lttng_session_destroy(session); return ret; } @@ -252,26 +345,60 @@ long lttng_abi_tracer_version(int objd, return 0; } +static +int lttng_abi_event_notifier_send_fd(void *owner, int event_notifier_notif_fd) +{ + struct lttng_event_notifier_group *event_notifier_group; + int event_notifier_group_objd, ret, fd_flag, close_ret; + + event_notifier_group = lttng_event_notifier_group_create(); + if (!event_notifier_group) + return -ENOMEM; + + /* + * Set this file descriptor as NON-BLOCKING. + */ + fd_flag = fcntl(event_notifier_notif_fd, F_GETFL); + + fd_flag |= O_NONBLOCK; + + ret = fcntl(event_notifier_notif_fd, F_SETFL, fd_flag); + if (ret) { + ret = -errno; + goto fd_error; + } + + event_notifier_group_objd = objd_alloc(event_notifier_group, + <tng_event_notifier_group_ops, owner, "event_notifier_group"); + if (event_notifier_group_objd < 0) { + ret = event_notifier_group_objd; + goto objd_error; + } + + event_notifier_group->objd = event_notifier_group_objd; + event_notifier_group->owner = owner; + event_notifier_group->notification_fd = event_notifier_notif_fd; + + return event_notifier_group_objd; + +objd_error: + lttng_event_notifier_group_destroy(event_notifier_group); +fd_error: + close_ret = close(event_notifier_notif_fd); + if (close_ret) { + PERROR("close"); + } + + return ret; +} + static long lttng_abi_add_context(int objd, struct lttng_ust_context *context_param, - struct lttng_ctx **ctx, struct ltt_session *session) -{ - if (session->been_active) - return -EPERM; - - switch (context_param->ctx) { - case LTTNG_UST_CONTEXT_PTHREAD_ID: - return lttng_add_pthread_id_to_ctx(ctx); - case LTTNG_UST_CONTEXT_VTID: - return lttng_add_vtid_to_ctx(ctx); - case LTTNG_UST_CONTEXT_VPID: - return lttng_add_vpid_to_ctx(ctx); - case LTTNG_UST_CONTEXT_PROCNAME: - return lttng_add_procname_to_ctx(ctx); - default: - return -EINVAL; - } + union ust_args *uargs, + struct lttng_ctx **ctx, struct lttng_session *session) +{ + return lttng_attach_context(context_param, uargs, ctx, session); } /** @@ -280,6 +407,8 @@ long lttng_abi_add_context(int objd, * @objd: the object descriptor * @cmd: the command * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner * * This descriptor implements lttng commands: * LTTNG_UST_SESSION @@ -288,25 +417,33 @@ long lttng_abi_add_context(int objd, * Returns the LTTng kernel tracer version * LTTNG_UST_TRACEPOINT_LIST * Returns a file descriptor listing available tracepoints + * LTTNG_UST_TRACEPOINT_FIELD_LIST + * Returns a file descriptor listing available tracepoint fields * LTTNG_UST_WAIT_QUIESCENT * Returns after all previously running probes have completed * * The returned session will be deleted when its file descriptor is closed. */ static -long lttng_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { switch (cmd) { case LTTNG_UST_SESSION: - return lttng_abi_create_session(); + return lttng_abi_create_session(owner); case LTTNG_UST_TRACER_VERSION: return lttng_abi_tracer_version(objd, (struct lttng_ust_tracer_version *) arg); case LTTNG_UST_TRACEPOINT_LIST: - return lttng_abi_tracepoint_list(); + return lttng_abi_tracepoint_list(owner); + case LTTNG_UST_TRACEPOINT_FIELD_LIST: + return lttng_abi_tracepoint_field_list(owner); case LTTNG_UST_WAIT_QUIESCENT: - synchronize_trace(); + lttng_ust_synchronize_trace(); return 0; + case LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE: + return lttng_abi_event_notifier_send_fd(owner, + uargs->event_notifier_handle.event_notifier_notif_fd); default: return -EINVAL; } @@ -316,115 +453,141 @@ static const struct lttng_ust_objd_ops lttng_ops = { .cmd = lttng_cmd, }; -/* - * We tolerate no failure in this function (if one happens, we print a dmesg - * error, but cannot return any error, because the channel information is - * invariant. - */ static -void lttng_metadata_create_events(int channel_objd) +int lttng_abi_map_channel(int session_objd, + struct lttng_ust_channel *ust_chan, + union ust_args *uargs, + void *owner) { - struct ltt_channel *channel = objd_private(channel_objd); - static struct lttng_ust_event metadata_params = { - .instrumentation = LTTNG_UST_TRACEPOINT, - .name = "lttng_ust:metadata", - }; - struct ltt_event *event; + struct lttng_session *session = objd_private(session_objd); + const char *transport_name; + const struct lttng_transport *transport; + const char *chan_name; + int chan_objd; + struct lttng_ust_shm_handle *channel_handle; + struct lttng_channel *lttng_chan; + struct channel *chan; + struct lttng_ust_lib_ring_buffer_config *config; + void *chan_data; + int wakeup_fd; + uint64_t len; int ret; + enum lttng_ust_chan_type type; - /* - * We tolerate no failure path after event creation. It will stay - * invariant for the rest of the session. - */ - ret = ltt_event_create(channel, &metadata_params, NULL, &event); - if (ret < 0) { - goto create_error; + chan_data = uargs->channel.chan_data; + wakeup_fd = uargs->channel.wakeup_fd; + len = ust_chan->len; + type = ust_chan->type; + + switch (type) { + case LTTNG_UST_CHAN_PER_CPU: + break; + default: + ret = -EINVAL; + goto invalid; } - return; -create_error: - WARN_ON(1); - return; /* not allowed to return error */ -} + if (session->been_active) { + ret = -EBUSY; + goto active; /* Refuse to add channel to active session */ + } -int lttng_abi_create_channel(int session_objd, - struct lttng_ust_channel *chan_param, - enum channel_type channel_type) -{ - struct ltt_session *session = objd_private(session_objd); - const struct lttng_ust_objd_ops *ops; - const char *transport_name; - struct ltt_channel *chan; - int chan_objd; - int ret = 0; - struct ltt_channel chan_priv_init; - - switch (channel_type) { - case PER_CPU_CHANNEL: - if (chan_param->output == LTTNG_UST_MMAP) { - transport_name = chan_param->overwrite ? - "relay-overwrite-mmap" : "relay-discard-mmap"; + channel_handle = channel_handle_create(chan_data, len, wakeup_fd); + if (!channel_handle) { + ret = -EINVAL; + goto handle_error; + } + + /* Ownership of chan_data and wakeup_fd taken by channel handle. */ + uargs->channel.chan_data = NULL; + uargs->channel.wakeup_fd = -1; + + chan = shmp(channel_handle, channel_handle->chan); + assert(chan); + chan->handle = channel_handle; + config = &chan->backend.config; + lttng_chan = channel_get_private(chan); + if (!lttng_chan) { + ret = -EINVAL; + goto alloc_error; + } + + /* Lookup transport name */ + switch (type) { + case LTTNG_UST_CHAN_PER_CPU: + if (config->output == RING_BUFFER_MMAP) { + if (config->mode == RING_BUFFER_OVERWRITE) { + if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) { + transport_name = "relay-overwrite-mmap"; + } else { + transport_name = "relay-overwrite-rt-mmap"; + } + } else { + if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) { + transport_name = "relay-discard-mmap"; + } else { + transport_name = "relay-discard-rt-mmap"; + } + } } else { - return -EINVAL; + ret = -EINVAL; + goto notransport; } - ops = <tng_channel_ops; - break; - case METADATA_CHANNEL: - if (chan_param->output == LTTNG_UST_MMAP) - transport_name = "relay-metadata-mmap"; - else - return -EINVAL; - ops = <tng_metadata_ops; + chan_name = "channel"; break; default: - transport_name = ""; - return -EINVAL; + ret = -EINVAL; + goto notransport; + } + transport = lttng_transport_find(transport_name); + if (!transport) { + DBG("LTTng transport %s not found\n", + transport_name); + ret = -EINVAL; + goto notransport; } - chan_objd = objd_alloc(NULL, ops); + + chan_objd = objd_alloc(NULL, <tng_channel_ops, owner, chan_name); 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) */ - memcpy(chan_priv_init.uuid, session->uuid, sizeof(session->uuid)); - + + /* Initialize our lttng chan */ + lttng_chan->chan = chan; + lttng_chan->tstate = 1; + lttng_chan->enabled = 1; + lttng_chan->ctx = NULL; + lttng_chan->session = session; + lttng_chan->ops = &transport->ops; + memcpy(<tng_chan->chan->backend.config, + transport->client_config, + sizeof(lttng_chan->chan->backend.config)); + cds_list_add(<tng_chan->node, &session->chan_head); + lttng_chan->header_type = 0; + lttng_chan->handle = channel_handle; + lttng_chan->type = type; + /* * We tolerate no failure path after channel creation. It will stay * invariant for the rest of the session. */ - chan = ltt_channel_create(session, transport_name, NULL, - chan_param->subbuf_size, - chan_param->num_subbuf, - chan_param->switch_timer_interval, - chan_param->read_timer_interval, - &chan_param->shm_fd, - &chan_param->wait_fd, - &chan_param->memory_map_size, - &chan_priv_init); - if (!chan) { - ret = -EINVAL; - goto chan_error; - } - objd_set_private(chan_objd, chan); - chan->objd = chan_objd; - if (channel_type == METADATA_CHANNEL) { - session->metadata = chan; - lttng_metadata_create_events(chan_objd); - } + objd_set_private(chan_objd, lttng_chan); + lttng_chan->objd = chan_objd; /* The channel created holds a reference on the session */ objd_ref(session_objd); - return chan_objd; -chan_error: - { - int err; - - err = lttng_ust_objd_unref(chan_objd); - assert(!err); - } + /* error path after channel was created */ objd_error: +notransport: +alloc_error: + channel_destroy(chan, channel_handle, 0); + return ret; + +handle_error: +active: +invalid: return ret; } @@ -434,6 +597,8 @@ objd_error: * @obj: the object * @cmd: the command * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner * * This descriptor implements lttng commands: * LTTNG_UST_CHANNEL @@ -442,31 +607,33 @@ objd_error: * Enables tracing for a session (weak enable) * LTTNG_UST_DISABLE * Disables tracing for a session (strong disable) - * LTTNG_UST_METADATA - * Returns a LTTng metadata object descriptor * * The returned channel will be deleted when its file descriptor is closed. */ static -long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { - struct ltt_session *session = objd_private(objd); + struct lttng_session *session = objd_private(objd); switch (cmd) { case LTTNG_UST_CHANNEL: - return lttng_abi_create_channel(objd, + return lttng_abi_map_channel(objd, (struct lttng_ust_channel *) arg, - PER_CPU_CHANNEL); + uargs, owner); case LTTNG_UST_SESSION_START: case LTTNG_UST_ENABLE: - return ltt_session_enable(session); + return lttng_session_enable(session); case LTTNG_UST_SESSION_STOP: case LTTNG_UST_DISABLE: - return ltt_session_disable(session); - case LTTNG_UST_METADATA: - return lttng_abi_create_channel(objd, - (struct lttng_ust_channel *) arg, - METADATA_CHANNEL); + return lttng_session_disable(session); + case LTTNG_UST_SESSION_STATEDUMP: + return lttng_session_statedump(session); + case LTTNG_UST_COUNTER: + case LTTNG_UST_COUNTER_GLOBAL: + case LTTNG_UST_COUNTER_CPU: + /* Not implemented yet. */ + return -EINVAL; default: return -EINVAL; } @@ -483,10 +650,10 @@ long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg) static int lttng_release_session(int objd) { - struct ltt_session *session = objd_private(objd); + struct lttng_session *session = objd_private(objd); if (session) { - ltt_session_destroy(session); + lttng_session_destroy(session); return 0; } else { return -EINVAL; @@ -498,8 +665,279 @@ static const struct lttng_ust_objd_ops lttng_session_ops = { .cmd = lttng_session_cmd, }; +static int lttng_ust_event_notifier_enabler_create(int event_notifier_group_obj, + void *owner, struct lttng_ust_event_notifier *event_notifier_param, + enum lttng_enabler_format_type type) +{ + struct lttng_event_notifier_group *event_notifier_group = + objd_private(event_notifier_group_obj); + struct lttng_event_notifier_enabler *event_notifier_enabler; + int event_notifier_objd, ret; + + event_notifier_param->event.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + event_notifier_objd = objd_alloc(NULL, <tng_event_notifier_enabler_ops, owner, + "event_notifier enabler"); + if (event_notifier_objd < 0) { + ret = event_notifier_objd; + goto objd_error; + } + + event_notifier_enabler = lttng_event_notifier_enabler_create( + event_notifier_group, type, event_notifier_param); + if (!event_notifier_enabler) { + ret = -ENOMEM; + goto event_notifier_error; + } + + objd_set_private(event_notifier_objd, event_notifier_enabler); + /* The event_notifier holds a reference on the event_notifier group. */ + objd_ref(event_notifier_enabler->group->objd); + + return event_notifier_objd; + +event_notifier_error: + { + int err; + + err = lttng_ust_objd_unref(event_notifier_objd, 1); + assert(!err); + } +objd_error: + return ret; +} + +static +long lttng_event_notifier_enabler_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) +{ + struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd); + switch (cmd) { + case LTTNG_UST_FILTER: + return lttng_event_notifier_enabler_attach_filter_bytecode( + event_notifier_enabler, + (struct lttng_ust_bytecode_node *) arg); + case LTTNG_UST_EXCLUSION: + return lttng_event_notifier_enabler_attach_exclusion(event_notifier_enabler, + (struct lttng_ust_excluder_node *) arg); + case LTTNG_UST_CAPTURE: + return lttng_event_notifier_enabler_attach_capture_bytecode( + event_notifier_enabler, + (struct lttng_ust_bytecode_node *) arg); + case LTTNG_UST_ENABLE: + return lttng_event_notifier_enabler_enable(event_notifier_enabler); + case LTTNG_UST_DISABLE: + return lttng_event_notifier_enabler_disable(event_notifier_enabler); + default: + return -EINVAL; + } +} + +/** + * lttng_event_notifier_group_error_counter_cmd - lttng event_notifier group error counter object command + * + * @obj: the object + * @cmd: the command + * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner + * + * This descriptor implements lttng commands: + * LTTNG_UST_COUNTER_GLOBAL + * Return negative error code on error, 0 on success. + * LTTNG_UST_COUNTER_CPU + * Return negative error code on error, 0 on success. + */ +static +long lttng_event_notifier_group_error_counter_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) +{ + struct lttng_counter *counter = objd_private(objd); + + switch (cmd) { + case LTTNG_UST_COUNTER_GLOBAL: + return -EINVAL; /* Unimplemented. */ + case LTTNG_UST_COUNTER_CPU: + { + struct lttng_ust_counter_cpu *counter_cpu = + (struct lttng_ust_counter_cpu *)arg; + return lttng_counter_set_cpu_shm(counter->counter, + counter_cpu->cpu_nr, uargs->counter_shm.shm_fd); + } + default: + return -EINVAL; + } +} + +int lttng_release_event_notifier_group_error_counter(int objd) +{ + struct lttng_counter *counter = objd_private(objd); + + if (counter) { + return lttng_ust_objd_unref(counter->event_notifier_group->objd, 0); + } else { + return -EINVAL; + } +} + +static const struct lttng_ust_objd_ops lttng_event_notifier_group_error_counter_ops = { + .release = lttng_release_event_notifier_group_error_counter, + .cmd = lttng_event_notifier_group_error_counter_cmd, +}; + +static +int lttng_ust_event_notifier_group_create_error_counter(int event_notifier_group_objd, void *owner, + struct lttng_ust_counter_conf *error_counter_conf) +{ + const char *counter_transport_name; + struct lttng_event_notifier_group *event_notifier_group = + objd_private(event_notifier_group_objd); + struct lttng_counter *counter; + int counter_objd, ret; + struct lttng_counter_dimension dimensions[1]; + size_t counter_len; + + if (event_notifier_group->error_counter) + return -EBUSY; + + if (error_counter_conf->arithmetic != LTTNG_UST_COUNTER_ARITHMETIC_MODULAR) + return -EINVAL; + + if (error_counter_conf->number_dimensions != 1) + return -EINVAL; + + switch (error_counter_conf->bitness) { + case LTTNG_UST_COUNTER_BITNESS_64: + counter_transport_name = "counter-per-cpu-64-modular"; + break; + case LTTNG_UST_COUNTER_BITNESS_32: + counter_transport_name = "counter-per-cpu-32-modular"; + break; + default: + return -EINVAL; + } + + counter_objd = objd_alloc(NULL, <tng_event_notifier_group_error_counter_ops, owner, + "event_notifier group error counter"); + if (counter_objd < 0) { + ret = counter_objd; + goto objd_error; + } + + counter_len = error_counter_conf->dimensions[0].size; + dimensions[0].size = counter_len; + dimensions[0].underflow_index = 0; + dimensions[0].overflow_index = 0; + dimensions[0].has_underflow = 0; + dimensions[0].has_overflow = 0; + + counter = lttng_ust_counter_create(counter_transport_name, 1, dimensions); + if (!counter) { + ret = -EINVAL; + goto create_error; + } + + event_notifier_group->error_counter_len = counter_len; + /* + * store-release to publish error counter matches load-acquire + * in record_error. Ensures the counter is created and the + * error_counter_len is set before they are used. + * Currently a full memory barrier is used, which could be + * turned into acquire-release barriers. + */ + cmm_smp_mb(); + CMM_STORE_SHARED(event_notifier_group->error_counter, counter); + + counter->objd = counter_objd; + counter->event_notifier_group = event_notifier_group; /* owner */ + + objd_set_private(counter_objd, counter); + /* The error counter holds a reference on the event_notifier group. */ + objd_ref(event_notifier_group->objd); + + return counter_objd; + +create_error: + { + int err; + + err = lttng_ust_objd_unref(counter_objd, 1); + assert(!err); + } +objd_error: + return ret; +} + +static +long lttng_event_notifier_group_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) +{ + switch (cmd) { + case LTTNG_UST_EVENT_NOTIFIER_CREATE: + { + struct lttng_ust_event_notifier *event_notifier_param = + (struct lttng_ust_event_notifier *) arg; + if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) { + /* + * If the event name is a star globbing pattern, + * we create the special star globbing enabler. + */ + return lttng_ust_event_notifier_enabler_create(objd, + owner, event_notifier_param, + LTTNG_ENABLER_FORMAT_STAR_GLOB); + } else { + return lttng_ust_event_notifier_enabler_create(objd, + owner, event_notifier_param, + LTTNG_ENABLER_FORMAT_EVENT); + } + } + case LTTNG_UST_COUNTER: + { + struct lttng_ust_counter_conf *counter_conf = + (struct lttng_ust_counter_conf *) uargs->counter.counter_data; + return lttng_ust_event_notifier_group_create_error_counter( + objd, owner, counter_conf); + } + default: + return -EINVAL; + } +} + +static +int lttng_event_notifier_enabler_release(int objd) +{ + struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd); + + if (event_notifier_enabler) + return lttng_ust_objd_unref(event_notifier_enabler->group->objd, 0); + return 0; +} + +static const struct lttng_ust_objd_ops lttng_event_notifier_enabler_ops = { + .release = lttng_event_notifier_enabler_release, + .cmd = lttng_event_notifier_enabler_cmd, +}; + +static +int lttng_release_event_notifier_group(int objd) +{ + struct lttng_event_notifier_group *event_notifier_group = objd_private(objd); + + if (event_notifier_group) { + lttng_event_notifier_group_destroy(event_notifier_group); + return 0; + } else { + return -EINVAL; + } +} + +static const struct lttng_ust_objd_ops lttng_event_notifier_group_ops = { + .release = lttng_release_event_notifier_group, + .cmd = lttng_event_notifier_group_cmd, +}; + static -long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { struct lttng_ust_tracepoint_list *list = objd_private(objd); struct lttng_ust_tracepoint_iter *tp = @@ -509,12 +947,9 @@ long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg) switch (cmd) { case LTTNG_UST_TRACEPOINT_LIST_GET: { - retry: iter = lttng_ust_tracepoint_list_get_iter_next(list); if (!iter) - return -ENOENT; - if (!strcmp(iter->name, "lttng_ust:metadata")) - goto retry; + return -LTTNG_UST_ERR_NOENT; memcpy(tp, iter, sizeof(*tp)); return 0; } @@ -524,12 +959,12 @@ long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg) } static -int lttng_abi_tracepoint_list(void) +int lttng_abi_tracepoint_list(void *owner) { int list_objd, ret; struct lttng_ust_tracepoint_list *list; - list_objd = objd_alloc(NULL, <tng_tracepoint_list_ops); + list_objd = objd_alloc(NULL, <tng_tracepoint_list_ops, owner, "tp_list"); if (list_objd < 0) { ret = list_objd; goto objd_error; @@ -542,7 +977,7 @@ int lttng_abi_tracepoint_list(void) objd_set_private(list_objd, list); /* populate list by walking on all registered probes. */ - ret = ltt_probes_get_event_list(list); + ret = lttng_probes_get_event_list(list); if (ret) { goto list_error; } @@ -554,7 +989,7 @@ alloc_error: { int err; - err = lttng_ust_objd_unref(list_objd); + err = lttng_ust_objd_unref(list_objd, 1); assert(!err); } objd_error: @@ -567,7 +1002,7 @@ int lttng_release_tracepoint_list(int objd) struct lttng_ust_tracepoint_list *list = objd_private(objd); if (list) { - ltt_probes_prune_event_list(list); + lttng_probes_prune_event_list(list); free(list); return 0; } else { @@ -580,79 +1015,61 @@ static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops = { .cmd = lttng_tracepoint_list_cmd, }; -struct stream_priv_data { - struct lttng_ust_lib_ring_buffer *buf; - struct ltt_channel *ltt_chan; -}; - static -int lttng_abi_open_stream(int channel_objd, struct lttng_ust_stream *info) +long lttng_tracepoint_field_list_cmd(int objd, unsigned int cmd, + unsigned long arg, union ust_args *uargs, void *owner) { - struct ltt_channel *channel = objd_private(channel_objd); - struct lttng_ust_lib_ring_buffer *buf; - struct stream_priv_data *priv; - int stream_objd, ret; + struct lttng_ust_field_list *list = objd_private(objd); + struct lttng_ust_field_iter *tp = &uargs->field_list.entry; + struct lttng_ust_field_iter *iter; - buf = channel->ops->buffer_read_open(channel->chan, channel->handle, - &info->shm_fd, &info->wait_fd, &info->memory_map_size); - if (!buf) - return -ENOENT; - - priv = zmalloc(sizeof(*priv)); - if (!priv) { - ret = -ENOMEM; - goto alloc_error; + switch (cmd) { + case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET: + { + iter = lttng_ust_field_list_get_iter_next(list); + if (!iter) + return -LTTNG_UST_ERR_NOENT; + memcpy(tp, iter, sizeof(*tp)); + return 0; } - priv->buf = buf; - priv->ltt_chan = channel; - stream_objd = objd_alloc(priv, &lib_ring_buffer_objd_ops); - if (stream_objd < 0) { - ret = stream_objd; - goto objd_error; + default: + return -EINVAL; } - /* Hold a reference on the channel object descriptor */ - objd_ref(channel_objd); - return stream_objd; - -objd_error: - free(priv); -alloc_error: - channel->ops->buffer_read_close(buf, channel->handle); - return ret; } static -int lttng_abi_create_event(int channel_objd, - struct lttng_ust_event *event_param) +int lttng_abi_tracepoint_field_list(void *owner) { - struct ltt_channel *channel = objd_private(channel_objd); - struct ltt_event *event; - int event_objd, ret; + int list_objd, ret; + struct lttng_ust_field_list *list; - event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; - event_objd = objd_alloc(NULL, <tng_event_ops); - if (event_objd < 0) { - ret = event_objd; + list_objd = objd_alloc(NULL, <tng_tracepoint_field_list_ops, owner, + "tp_field_list"); + if (list_objd < 0) { + ret = list_objd; goto objd_error; } - /* - * We tolerate no failure path after event creation. It will stay - * invariant for the rest of the session. - */ - ret = ltt_event_create(channel, event_param, NULL, &event); - if (ret < 0) { - goto event_error; + list = zmalloc(sizeof(*list)); + if (!list) { + ret = -ENOMEM; + goto alloc_error; } - objd_set_private(event_objd, event); - /* The event holds a reference on the channel */ - objd_ref(channel_objd); - return event_objd; + objd_set_private(list_objd, list); -event_error: + /* populate list by walking on all registered probes. */ + ret = lttng_probes_get_field_list(list); + if (ret) { + goto list_error; + } + return list_objd; + +list_error: + free(list); +alloc_error: { int err; - err = lttng_ust_objd_unref(event_objd); + err = lttng_ust_objd_unref(list_objd, 1); assert(!err); } objd_error: @@ -660,37 +1077,82 @@ objd_error: } static -int lttng_abi_create_loglevel(int channel_objd, - struct lttng_ust_event *event_param) +int lttng_release_tracepoint_field_list(int objd) { - struct ltt_channel *channel = objd_private(channel_objd); - struct session_loglevel *loglevel; - int loglevel_objd, ret; + struct lttng_ust_field_list *list = objd_private(objd); + + if (list) { + lttng_probes_prune_field_list(list); + free(list); + return 0; + } else { + return -EINVAL; + } +} + +static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops = { + .release = lttng_release_tracepoint_field_list, + .cmd = lttng_tracepoint_field_list_cmd, +}; + +static +int lttng_abi_map_stream(int channel_objd, struct lttng_ust_stream *info, + union ust_args *uargs, void *owner) +{ + struct lttng_channel *channel = objd_private(channel_objd); + int ret; + + ret = channel_handle_add_stream(channel->handle, + uargs->stream.shm_fd, uargs->stream.wakeup_fd, + info->stream_nr, info->len); + if (ret) + goto error_add_stream; + /* Take ownership of shm_fd and wakeup_fd. */ + uargs->stream.shm_fd = -1; + uargs->stream.wakeup_fd = -1; + + return 0; + +error_add_stream: + return ret; +} + +static +int lttng_abi_create_event_enabler(int channel_objd, + struct lttng_ust_event *event_param, + void *owner, + enum lttng_enabler_format_type format_type) +{ + struct lttng_channel *channel = objd_private(channel_objd); + struct lttng_event_enabler *enabler; + int event_objd, ret; event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; - loglevel_objd = objd_alloc(NULL, <tng_loglevel_ops); - if (loglevel_objd < 0) { - ret = loglevel_objd; + event_objd = objd_alloc(NULL, <tng_event_enabler_ops, owner, + "event enabler"); + if (event_objd < 0) { + ret = event_objd; goto objd_error; } /* - * We tolerate no failure path after loglevel creation. It will - * stay invariant for the rest of the session. + * We tolerate no failure path after event creation. It will stay + * invariant for the rest of the session. */ - ret = ltt_loglevel_create(channel, event_param, &loglevel); - if (ret < 0) { - goto loglevel_error; + enabler = lttng_event_enabler_create(format_type, event_param, channel); + if (!enabler) { + ret = -ENOMEM; + goto event_error; } - objd_set_private(loglevel_objd, loglevel); - /* The loglevel holds a reference on the channel */ + objd_set_private(event_objd, enabler); + /* The event holds a reference on the channel */ objd_ref(channel_objd); - return loglevel_objd; + return event_objd; -loglevel_error: +event_error: { int err; - err = lttng_ust_objd_unref(loglevel_objd); + err = lttng_ust_objd_unref(event_objd, 1); assert(!err); } objd_error: @@ -703,6 +1165,8 @@ objd_error: * @objd: the object descriptor * @cmd: the command * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner * * This object descriptor implements lttng commands: * LTTNG_UST_STREAM @@ -720,9 +1184,18 @@ objd_error: * Channel and event file descriptors also hold a reference on the session. */ static -long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { - struct ltt_channel *channel = objd_private(objd); + struct lttng_channel *channel = objd_private(objd); + + if (cmd != LTTNG_UST_STREAM) { + /* + * Check if channel received all streams. + */ + if (!lttng_is_channel_ready(channel)) + return -EPERM; + } switch (cmd) { case LTTNG_UST_STREAM: @@ -731,26 +1204,33 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg) stream = (struct lttng_ust_stream *) arg; /* stream used as output */ - return lttng_abi_open_stream(objd, stream); + return lttng_abi_map_stream(objd, stream, uargs, owner); } case LTTNG_UST_EVENT: { struct lttng_ust_event *event_param = (struct lttng_ust_event *) arg; - if (event_param->instrumentation == LTTNG_UST_TRACEPOINT_LOGLEVEL) { - return lttng_abi_create_loglevel(objd, event_param); + + if (strutils_is_star_glob_pattern(event_param->name)) { + /* + * If the event name is a star globbing pattern, + * we create the special star globbing enabler. + */ + return lttng_abi_create_event_enabler(objd, event_param, + owner, LTTNG_ENABLER_FORMAT_STAR_GLOB); } else { - return lttng_abi_create_event(objd, event_param); + return lttng_abi_create_event_enabler(objd, event_param, + owner, LTTNG_ENABLER_FORMAT_EVENT); } } case LTTNG_UST_CONTEXT: return lttng_abi_add_context(objd, - (struct lttng_ust_context *) arg, + (struct lttng_ust_context *) arg, uargs, &channel->ctx, channel->session); case LTTNG_UST_ENABLE: - return ltt_channel_enable(channel); + return lttng_channel_enable(channel); case LTTNG_UST_DISABLE: - return ltt_channel_disable(channel); + return lttng_channel_disable(channel); case LTTNG_UST_FLUSH_BUFFER: return channel->ops->flush_buffer(channel->chan, channel->handle); default: @@ -758,254 +1238,98 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg) } } -/** - * lttng_metadata_cmd - lttng control through object descriptors - * - * @objd: the object descriptor - * @cmd: the command - * @arg: command arg - * - * This object descriptor implements lttng commands: - * LTTNG_UST_STREAM - * Returns an event stream file descriptor or failure. - * - * Channel and event file descriptors also hold a reference on the session. - */ -static -long lttng_metadata_cmd(int objd, unsigned int cmd, unsigned long arg) -{ - struct ltt_channel *channel = objd_private(objd); - - switch (cmd) { - case LTTNG_UST_STREAM: - { - struct lttng_ust_stream *stream; - - stream = (struct lttng_ust_stream *) arg; - /* stream used as output */ - return lttng_abi_open_stream(objd, stream); - } - case LTTNG_UST_FLUSH_BUFFER: - return channel->ops->flush_buffer(channel->chan, channel->handle); - default: - return -EINVAL; - } -} - -#if 0 -/** - * lttng_channel_poll - lttng stream addition/removal monitoring - * - * @file: the file - * @wait: poll table - */ -unsigned int lttng_channel_poll(struct file *file, poll_table *wait) -{ - struct ltt_channel *channel = file->private_data; - unsigned int mask = 0; - - if (file->f_mode & FMODE_READ) { - poll_wait_set_exclusive(wait); - poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan), - wait); - - if (channel->ops->is_disabled(channel->chan)) - return POLLERR; - if (channel->ops->is_finalized(channel->chan)) - return POLLHUP; - if (channel->ops->buffer_has_read_closed_stream(channel->chan)) - return POLLIN | POLLRDNORM; - return 0; - } - return mask; - -} -#endif //0 - static int lttng_channel_release(int objd) { - struct ltt_channel *channel = objd_private(objd); + struct lttng_channel *channel = objd_private(objd); if (channel) - return lttng_ust_objd_unref(channel->session->objd); + return lttng_ust_objd_unref(channel->session->objd, 0); return 0; } static const struct lttng_ust_objd_ops lttng_channel_ops = { .release = lttng_channel_release, - //.poll = lttng_channel_poll, .cmd = lttng_channel_cmd, }; -static const struct lttng_ust_objd_ops lttng_metadata_ops = { - .release = lttng_channel_release, - .cmd = lttng_metadata_cmd, -}; - -/** - * lttng_rb_cmd - lttng ring buffer control through object descriptors - * - * @objd: the object descriptor - * @cmd: the command - * @arg: command arg - * - * This object descriptor implements lttng commands: - * (None for now. Access is done directly though shm.) - */ -static -long lttng_rb_cmd(int objd, unsigned int cmd, unsigned long arg) -{ - switch (cmd) { - default: - return -EINVAL; - } -} - -static -int lttng_rb_release(int objd) -{ - struct stream_priv_data *priv = objd_private(objd); - struct lttng_ust_lib_ring_buffer *buf; - struct ltt_channel *channel; - - if (priv) { - buf = priv->buf; - channel = priv->ltt_chan; - free(priv); - /* - * 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); - } - return 0; -} - -static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops = { - .release = lttng_rb_release, - .cmd = lttng_rb_cmd, -}; - /** - * lttng_event_cmd - lttng control through object descriptors - * - * @objd: the object descriptor - * @cmd: the command - * @arg: command arg - * - * This object descriptor implements lttng commands: - * LTTNG_UST_CONTEXT - * Prepend a context field to each record of this event - * LTTNG_UST_ENABLE - * Enable recording for this event (weak enable) - * LTTNG_UST_DISABLE - * Disable recording for this event (strong disable) - */ -static -long lttng_event_cmd(int objd, unsigned int cmd, unsigned long arg) -{ - struct ltt_event *event = objd_private(objd); - - switch (cmd) { - case LTTNG_UST_CONTEXT: - return lttng_abi_add_context(objd, - (struct lttng_ust_context *) arg, - &event->ctx, event->chan->session); - case LTTNG_UST_ENABLE: - return ltt_event_enable(event); - case LTTNG_UST_DISABLE: - return ltt_event_disable(event); - default: - return -EINVAL; - } -} - -static -int lttng_event_release(int objd) -{ - struct ltt_event *event = objd_private(objd); - - if (event) - return lttng_ust_objd_unref(event->chan->objd); - return 0; -} - -/* TODO: filter control ioctl */ -static const struct lttng_ust_objd_ops lttng_event_ops = { - .release = lttng_event_release, - .cmd = lttng_event_cmd, -}; - -/** - * lttng_loglevel_cmd - lttng control through object descriptors + * lttng_enabler_cmd - lttng control through object descriptors * * @objd: the object descriptor * @cmd: the command * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner * * This object descriptor implements lttng commands: * LTTNG_UST_CONTEXT * Prepend a context field to each record of events of this - * loglevel. + * enabler. * LTTNG_UST_ENABLE - * Enable recording for these loglevel events (weak enable) + * Enable recording for this enabler * LTTNG_UST_DISABLE - * Disable recording for these loglevel events (strong disable) + * Disable recording for this enabler + * LTTNG_UST_FILTER + * Attach a filter to an enabler. + * LTTNG_UST_EXCLUSION + * Attach exclusions to an enabler. */ static -long lttng_loglevel_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_event_enabler_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { - struct session_loglevel *loglevel = objd_private(objd); + struct lttng_event_enabler *enabler = objd_private(objd); switch (cmd) { case LTTNG_UST_CONTEXT: - return -ENOSYS; /* not implemented yet */ -#if 0 - return lttng_abi_add_context(objd, - (struct lttng_ust_context *) arg, - &loglevel->ctx, loglevel->chan->session); -#endif + return lttng_event_enabler_attach_context(enabler, + (struct lttng_ust_context *) arg); case LTTNG_UST_ENABLE: - return ltt_loglevel_enable(loglevel); + return lttng_event_enabler_enable(enabler); case LTTNG_UST_DISABLE: - return ltt_loglevel_disable(loglevel); + return lttng_event_enabler_disable(enabler); + case LTTNG_UST_FILTER: + { + int ret; + + ret = lttng_event_enabler_attach_filter_bytecode(enabler, + (struct lttng_ust_bytecode_node *) arg); + if (ret) + return ret; + return 0; + } + case LTTNG_UST_EXCLUSION: + { + return lttng_event_enabler_attach_exclusion(enabler, + (struct lttng_ust_excluder_node *) arg); + } default: return -EINVAL; } } static -int lttng_loglevel_release(int objd) +int lttng_event_enabler_release(int objd) { - struct session_loglevel *loglevel = objd_private(objd); + struct lttng_event_enabler *event_enabler = objd_private(objd); + + if (event_enabler) + return lttng_ust_objd_unref(event_enabler->chan->objd, 0); - if (loglevel) - return lttng_ust_objd_unref(loglevel->chan->objd); return 0; } -/* TODO: filter control ioctl */ -static const struct lttng_ust_objd_ops lttng_loglevel_ops = { - .release = lttng_loglevel_release, - .cmd = lttng_loglevel_cmd, +static const struct lttng_ust_objd_ops lttng_event_enabler_ops = { + .release = lttng_event_enabler_release, + .cmd = lttng_event_enabler_cmd, }; void lttng_ust_abi_exit(void) { lttng_ust_abi_close_in_progress = 1; + ust_lock_nocheck(); objd_table_destroy(); + ust_unlock(); lttng_ust_abi_close_in_progress = 0; }