X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-abi.c;h=d0b1e4f9d90a1a04864e8e63297aa68e81781966;hb=f59ed768f82d44110167a267d67145a60fe7e532;hp=e7ef1579a575ff1212735b9f3f3c03cde46b7ed1;hpb=d028eddb5959160ef6ec4b09f786730910d0f8f8;p=lttng-ust.git diff --git a/liblttng-ust/lttng-ust-abi.c b/liblttng-ust/lttng-ust-abi.c index e7ef1579..d0b1e4f9 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,18 +35,27 @@ * - Takes an instrumentation source as parameter * - e.g. tracepoints, dynamic_probes... * - Takes instrumentation source specific arguments. - * - * Dual LGPL v2.1/GPL v2 license. */ #include +#include #include #include #include -#include -#include "lttng/core.h" +#include +#include +#include "tracepoint-internal.h" +#include +#include #include "ltt-tracer.h" +static int lttng_ust_abi_close_in_progress; + +static +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 * by the caller. @@ -43,6 +67,7 @@ struct lttng_ust_obj { void *private_data; const struct lttng_ust_objd_ops *ops; int f_count; + void *owner; } s; int freelist_next; /* offset freelist. end is -1. */ } u; @@ -59,7 +84,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) { struct lttng_ust_obj *obj; @@ -95,6 +121,7 @@ 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 = owner; return obj - objd_table.array; } @@ -186,6 +213,23 @@ void objd_table_destroy(void) objd_table.freelist_head = -1; } +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 == owner) + (void) lttng_ust_objd_unref(i); + } +} + /* * This is LTTng's own personal way to create an ABI for sessiond. * We send commands over a socket. @@ -196,7 +240,10 @@ 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_wildcard_ops; static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops; +static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops; +static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops; enum channel_type { PER_CPU_CHANNEL, @@ -207,12 +254,13 @@ 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); return root_handle; } static -int lttng_abi_create_session(void) +int lttng_abi_create_session(void *owner) { struct ltt_session *session; int session_objd, ret; @@ -220,7 +268,7 @@ int lttng_abi_create_session(void) session = ltt_session_create(); if (!session) return -ENOMEM; - session_objd = objd_alloc(session, <tng_session_ops); + session_objd = objd_alloc(session, <tng_session_ops, owner); if (session_objd < 0) { ret = session_objd; goto objd_error; @@ -233,33 +281,13 @@ objd_error: return ret; } -#if 0 -static -int lttng_abi_tracepoint_list(void) -{ - int list_objd, ret; - - /* TODO: Create list private data */ - list_objd = objd_alloc(NULL, <tng_tracepoint_list_ops); - if (list_objd < 0) { - ret = list_objd; - goto objd_error; - } - - return list_objd; - -objd_error: - return ret; -} -#endif //0 - 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_INTERNAL_MAJOR_VERSION; + v->minor = LTTNG_UST_INTERNAL_MINOR_VERSION; + v->patchlevel = LTTNG_UST_INTERNAL_PATCHLEVEL_VERSION; return 0; } @@ -291,6 +319,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 @@ -299,23 +329,27 @@ 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 -ENOSYS; //TODO - //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(); return 0; @@ -339,7 +373,9 @@ 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", + .loglevel_type = LTTNG_UST_LOGLEVEL_ALL, + .loglevel = TRACE_DEFAULT, }; struct ltt_event *event; int ret; @@ -348,9 +384,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, &event); + if (ret < 0) { goto create_error; } return; @@ -362,7 +397,9 @@ create_error: int lttng_abi_create_channel(int session_objd, struct lttng_ust_channel *chan_param, - enum channel_type channel_type) + enum channel_type channel_type, + union ust_args *uargs, + void *owner) { struct ltt_session *session = objd_private(session_objd); const struct lttng_ust_objd_ops *ops; @@ -372,11 +409,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) { @@ -396,7 +428,12 @@ int lttng_abi_create_channel(int session_objd, break; default: transport_name = ""; - break; + return -EINVAL; + } + chan_objd = objd_alloc(NULL, ops, owner); + 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) */ @@ -411,9 +448,9 @@ int lttng_abi_create_channel(int session_objd, 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, + &uargs->channel.shm_fd, + &uargs->channel.wait_fd, + &uargs->channel.memory_map_size, &chan_priv_init); if (!chan) { ret = -EINVAL; @@ -447,6 +484,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 @@ -461,7 +500,8 @@ objd_error: * 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); @@ -469,7 +509,7 @@ long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg) case LTTNG_UST_CHANNEL: return lttng_abi_create_channel(objd, (struct lttng_ust_channel *) arg, - PER_CPU_CHANNEL); + PER_CPU_CHANNEL, uargs, owner); case LTTNG_UST_SESSION_START: case LTTNG_UST_ENABLE: return ltt_session_enable(session); @@ -479,7 +519,7 @@ long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg) case LTTNG_UST_METADATA: return lttng_abi_create_channel(objd, (struct lttng_ust_channel *) arg, - METADATA_CHANNEL); + METADATA_CHANNEL, uargs, owner); default: return -EINVAL; } @@ -511,13 +551,179 @@ static const struct lttng_ust_objd_ops lttng_session_ops = { .cmd = lttng_session_cmd, }; +static +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 = + (struct lttng_ust_tracepoint_iter *) arg; + struct lttng_ust_tracepoint_iter *iter; + + switch (cmd) { + case LTTNG_UST_TRACEPOINT_LIST_GET: + { + retry: + iter = lttng_ust_tracepoint_list_get_iter_next(list); + if (!iter) + return -LTTNG_UST_ERR_NOENT; + if (!strcmp(iter->name, "lttng_ust:metadata")) + goto retry; + memcpy(tp, iter, sizeof(*tp)); + return 0; + } + default: + return -EINVAL; + } +} + +static +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, owner); + if (list_objd < 0) { + ret = list_objd; + goto objd_error; + } + list = zmalloc(sizeof(*list)); + if (!list) { + ret = -ENOMEM; + goto alloc_error; + } + objd_set_private(list_objd, list); + + /* populate list by walking on all registered probes. */ + ret = ltt_probes_get_event_list(list); + if (ret) { + goto list_error; + } + return list_objd; + +list_error: + free(list); +alloc_error: + { + int err; + + err = lttng_ust_objd_unref(list_objd); + assert(!err); + } +objd_error: + return ret; +} + +static +int lttng_release_tracepoint_list(int objd) +{ + struct lttng_ust_tracepoint_list *list = objd_private(objd); + + if (list) { + ltt_probes_prune_event_list(list); + free(list); + return 0; + } else { + return -EINVAL; + } +} + +static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops = { + .release = lttng_release_tracepoint_list, + .cmd = lttng_tracepoint_list_cmd, +}; + +static +long lttng_tracepoint_field_list_cmd(int objd, unsigned int cmd, + unsigned long arg, union ust_args *uargs, void *owner) +{ + 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; + + switch (cmd) { + case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET: + { + retry: + iter = lttng_ust_field_list_get_iter_next(list); + if (!iter) + return -LTTNG_UST_ERR_NOENT; + if (!strcmp(iter->event_name, "lttng_ust:metadata")) + goto retry; + memcpy(tp, iter, sizeof(*tp)); + return 0; + } + default: + return -EINVAL; + } +} + +static +int lttng_abi_tracepoint_field_list(void *owner) +{ + int list_objd, ret; + struct lttng_ust_field_list *list; + + list_objd = objd_alloc(NULL, <tng_tracepoint_field_list_ops, owner); + if (list_objd < 0) { + ret = list_objd; + goto objd_error; + } + list = zmalloc(sizeof(*list)); + if (!list) { + ret = -ENOMEM; + goto alloc_error; + } + objd_set_private(list_objd, list); + + /* populate list by walking on all registered probes. */ + ret = ltt_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(list_objd); + assert(!err); + } +objd_error: + return ret; +} + +static +int lttng_release_tracepoint_field_list(int objd) +{ + struct lttng_ust_field_list *list = objd_private(objd); + + if (list) { + ltt_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, +}; + 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) +int lttng_abi_open_stream(int channel_objd, struct lttng_ust_stream *info, + union ust_args *uargs, void *owner) { struct ltt_channel *channel = objd_private(channel_objd); struct lttng_ust_lib_ring_buffer *buf; @@ -525,7 +731,9 @@ int lttng_abi_open_stream(int channel_objd, struct lttng_ust_stream *info) int stream_objd, ret; buf = channel->ops->buffer_read_open(channel->chan, channel->handle, - &info->shm_fd, &info->wait_fd, &info->memory_map_size); + &uargs->stream.shm_fd, + &uargs->stream.wait_fd, + &uargs->stream.memory_map_size); if (!buf) return -ENOENT; @@ -536,7 +744,7 @@ int lttng_abi_open_stream(int channel_objd, struct lttng_ust_stream *info) } priv->buf = buf; priv->ltt_chan = channel; - stream_objd = objd_alloc(priv, &lib_ring_buffer_objd_ops); + stream_objd = objd_alloc(priv, &lib_ring_buffer_objd_ops, owner); if (stream_objd < 0) { ret = stream_objd; goto objd_error; @@ -554,14 +762,15 @@ alloc_error: static int lttng_abi_create_event(int channel_objd, - struct lttng_ust_event *event_param) + struct lttng_ust_event *event_param, + void *owner) { struct ltt_channel *channel = objd_private(channel_objd); struct ltt_event *event; int event_objd, ret; event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; - event_objd = objd_alloc(NULL, <tng_event_ops); + event_objd = objd_alloc(NULL, <tng_event_ops, owner); if (event_objd < 0) { ret = event_objd; goto objd_error; @@ -570,9 +779,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, &event); + if (ret < 0) { goto event_error; } objd_set_private(event_objd, event); @@ -591,12 +799,53 @@ objd_error: return ret; } +static +int lttng_abi_create_wildcard(int channel_objd, + struct lttng_ust_event *event_param, + void *owner) +{ + struct ltt_channel *channel = objd_private(channel_objd); + struct session_wildcard *wildcard; + int wildcard_objd, ret; + + event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + wildcard_objd = objd_alloc(NULL, <tng_wildcard_ops, owner); + if (wildcard_objd < 0) { + ret = wildcard_objd; + goto objd_error; + } + /* + * We tolerate no failure path after wildcard creation. It will + * stay invariant for the rest of the session. + */ + ret = ltt_wildcard_create(channel, event_param, &wildcard); + if (ret < 0) { + goto wildcard_error; + } + objd_set_private(wildcard_objd, wildcard); + /* The wildcard holds a reference on the channel */ + objd_ref(channel_objd); + return wildcard_objd; + +wildcard_error: + { + int err; + + err = lttng_ust_objd_unref(wildcard_objd); + assert(!err); + } +objd_error: + return ret; +} + /** * lttng_channel_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_STREAM @@ -614,7 +863,8 @@ 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); @@ -625,10 +875,21 @@ 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_open_stream(objd, stream, uargs, owner); } case LTTNG_UST_EVENT: - return lttng_abi_create_event(objd, (struct lttng_ust_event *) arg); + { + struct lttng_ust_event *event_param = + (struct lttng_ust_event *) arg; + if (event_param->name[strlen(event_param->name) - 1] == '*') { + /* If ends with wildcard, create wildcard. */ + return lttng_abi_create_wildcard(objd, event_param, + owner); + } else { + return lttng_abi_create_event(objd, event_param, + owner); + } + } case LTTNG_UST_CONTEXT: return lttng_abi_add_context(objd, (struct lttng_ust_context *) arg, @@ -650,6 +911,8 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg) * @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 @@ -658,7 +921,8 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg) * 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) +long lttng_metadata_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { struct ltt_channel *channel = objd_private(objd); @@ -669,7 +933,7 @@ long lttng_metadata_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_open_stream(objd, stream, uargs, owner); } case LTTNG_UST_FLUSH_BUFFER: return channel->ops->flush_buffer(channel->chan, channel->handle); @@ -735,12 +999,15 @@ static const struct lttng_ust_objd_ops lttng_metadata_ops = { * @objd: the object descriptor * @cmd: the command * @arg: command arg + * @uargs: UST arguments (internal) + * @owner: objd owner * * 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) +long lttng_rb_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { switch (cmd) { default: @@ -759,7 +1026,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); } @@ -777,6 +1058,8 @@ static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops = { * @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 @@ -785,9 +1068,12 @@ static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops = { * Enable recording for this event (weak enable) * LTTNG_UST_DISABLE * Disable recording for this event (strong disable) + * LTTNG_UST_FILTER + * Attach a filter to an event. */ static -long lttng_event_cmd(int objd, unsigned int cmd, unsigned long arg) +long lttng_event_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) { struct ltt_event *event = objd_private(objd); @@ -800,6 +1086,17 @@ long lttng_event_cmd(int objd, unsigned int cmd, unsigned long arg) return ltt_event_enable(event); case LTTNG_UST_DISABLE: return ltt_event_disable(event); + case LTTNG_UST_FILTER: + { + int ret; + ret = lttng_filter_event_attach_bytecode(event, + (struct lttng_ust_filter_bytecode *) arg); + if (ret) + return ret; + lttng_filter_event_link_bytecode(event, + event->filter_bytecode); + return 0; + } default: return -EINVAL; } @@ -821,7 +1118,79 @@ static const struct lttng_ust_objd_ops lttng_event_ops = { .cmd = lttng_event_cmd, }; +/** + * lttng_wildcard_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 + * wildcard. + * LTTNG_UST_ENABLE + * Enable recording for these wildcard events (weak enable) + * LTTNG_UST_DISABLE + * Disable recording for these wildcard events (strong disable) + * LTTNG_UST_FILTER + * Attach a filter to a wildcard. + */ +static +long lttng_wildcard_cmd(int objd, unsigned int cmd, unsigned long arg, + union ust_args *uargs, void *owner) +{ + struct session_wildcard *wildcard = 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, + &wildcard->ctx, wildcard->chan->session); +#endif + case LTTNG_UST_ENABLE: + return ltt_wildcard_enable(wildcard); + case LTTNG_UST_DISABLE: + return ltt_wildcard_disable(wildcard); + case LTTNG_UST_FILTER: + { + int ret; + + ret = lttng_filter_wildcard_attach_bytecode(wildcard, + (struct lttng_ust_filter_bytecode *) arg); + if (ret) + return ret; + lttng_filter_wildcard_link_bytecode(wildcard); + return 0; + } + default: + return -EINVAL; + } +} + +static +int lttng_wildcard_release(int objd) +{ + struct session_wildcard *wildcard = objd_private(objd); + + if (wildcard) + return lttng_ust_objd_unref(wildcard->chan->objd); + return 0; +} + +/* TODO: filter control ioctl */ +static const struct lttng_ust_objd_ops lttng_wildcard_ops = { + .release = lttng_wildcard_release, + .cmd = lttng_wildcard_cmd, +}; + void lttng_ust_abi_exit(void) { + lttng_ust_abi_close_in_progress = 1; objd_table_destroy(); + lttng_ust_abi_close_in_progress = 0; }