X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fchannel.c;h=fda679c78f3ebacfbee3ff9d52b4aabb25228cdc;hp=ab9bf6c6d4fcbafbbe48d085b0143de0949e76f4;hb=48842b309b2000205367409c0f29ca40ec3e251c;hpb=54d01ffb43587b221dc50ec42b6070fad89bd255 diff --git a/ltt-sessiond/channel.c b/ltt-sessiond/channel.c index ab9bf6c6d..fda679c78 100644 --- a/ltt-sessiond/channel.c +++ b/ltt-sessiond/channel.c @@ -15,20 +15,30 @@ * Place - Suite 330, Boston, MA 02111-1307, USA. */ +#include #include #include #include #include +#ifdef CONFIG_LTTNG_TOOLS_HAVE_UST +#include +#include +#else +#include "lttng-ust-ctl.h" +#include "lttng-ust-abi.h" +#endif #include "channel.h" +#include "hashtable.h" #include "kernel-ctl.h" +#include "ust-ctl.h" #include "utils.h" /* * Return allocated channel attributes. */ -static struct lttng_channel *init_default_attr(int dom, char *name) +struct lttng_channel *channel_new_default_attr(int dom) { struct lttng_channel *chan; @@ -38,8 +48,9 @@ static struct lttng_channel *init_default_attr(int dom, char *name) goto error_alloc; } - if (snprintf(chan->name, sizeof(chan->name), "%s", name) < 0) { - perror("snprintf channel name"); + if (snprintf(chan->name, sizeof(chan->name), "%s", + DEFAULT_CHANNEL_NAME) < 0) { + perror("snprintf default channel name"); goto error; } @@ -53,7 +64,12 @@ static struct lttng_channel *init_default_attr(int dom, char *name) chan->attr.num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM; chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT; break; - /* TODO: add UST */ + case LTTNG_DOMAIN_UST: + case LTTNG_DOMAIN_UST_PID: + chan->attr.subbuf_size = DEFAULT_UST_CHANNEL_SUBBUF_SIZE; + chan->attr.num_subbuf = DEFAULT_UST_CHANNEL_SUBBUF_NUM; + chan->attr.output = DEFAULT_UST_CHANNEL_OUTPUT; + break; default: goto error; /* Not implemented */ } @@ -66,6 +82,37 @@ error_alloc: return NULL; } +/* + * Copy two ltt ust channel. Dst and src must be already allocated. + */ +int channel_ust_copy(struct ltt_ust_channel *dst, + struct ltt_ust_channel *src) +{ + //struct ltt_ust_event *uevent, *new_uevent; + + memcpy(dst, src, sizeof(struct ltt_ust_channel)); + dst->events = hashtable_new_str(0); + + /* + cds_list_for_each_entry(uevent, &src->events.head, list) { + new_uevent = malloc(sizeof(struct ltt_ust_event)); + if (new_uevent == NULL) { + perror("malloc ltt_ust_event"); + goto error; + } + + memcpy(new_uevent, uevent, sizeof(struct ltt_ust_event)); + cds_list_add(&new_uevent->list, &dst->events.head); + dst->events.count++; + } + */ + + return 0; + +//error: +// return -1; +} + /* * Disable kernel channel of the kernel session. */ @@ -121,14 +168,15 @@ error: * Create kernel channel of the kernel session and notify kernel thread. */ int channel_kernel_create(struct ltt_kernel_session *ksession, - char *channel_name, struct lttng_channel *chan, int kernel_pipe) + struct lttng_channel *chan, int kernel_pipe) { int ret; struct lttng_channel *attr = chan; /* Creating channel attributes if needed */ if (attr == NULL) { - attr = init_default_attr(LTTNG_DOMAIN_KERNEL, channel_name); + /* FIXME: this appears to be a memory leak */ + attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL); if (attr == NULL) { ret = LTTCOMM_FATAL; goto error; @@ -154,3 +202,115 @@ int channel_kernel_create(struct ltt_kernel_session *ksession, error: return ret; } + +/* + * Create UST channel and enable it on the tracer. + */ +int channel_ust_create(struct ltt_ust_session *usess, + struct lttng_channel *attr) +{ + int ret; + struct ltt_ust_channel *uchan; + //struct lttng_ust_channel_attr uattr; + //struct object_data *obj; + + uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, + attr->name); + if (uchan == NULL) { + uchan = trace_ust_create_channel(attr, usess->pathname); + if (uchan == NULL) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto error; + } + rcu_read_lock(); + hashtable_add_unique(usess->domain_global.channels, &uchan->node); + rcu_read_unlock(); + } else { + ret = LTTCOMM_UST_CHAN_EXIST; + goto error; + } + + /* TODO: NOTIFY ust application to update */ + /* + ret = ustctl_create_channel(sock, usession->handle, &uattr, &obj); + if (ret < 0) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto error; + } + */ + + /* + uchan->attr.overwrite = uattr.overwrite; + uchan->attr.subbuf_size = uattr.subbuf_size; + uchan->attr.num_subbuf = uattr.num_subbuf; + uchan->attr.switch_timer_interval = uattr.switch_timer_interval; + uchan->attr.read_timer_interval = uattr.read_timer_interval; + uchan->attr.output = uattr.output; + uchan->handle = obj->handle; + uchan->attr.shm_fd = obj->shm_fd; + uchan->attr.wait_fd = obj->wait_fd; + uchan->attr.memory_map_size = obj->memory_map_size; + uchan->obj = obj; + */ + + /* Add channel to session */ + //rcu_read_lock(); + //cds_list_add(&uchan->list, &usession->channels.head); + //usession->channels.count++; + //rcu_read_unlock(); + + //DBG2("Channel %s UST create successfully for sock:%d", uchan->name, sock); + + ret = LTTCOMM_OK; + +error: + return ret; +} + +/* + * Enable UST channel on the tracer. + */ +int channel_ust_enable(struct ltt_ust_session *usession, + struct ltt_ust_channel *uchan, int sock) +{ + int ret = LTTCOMM_OK; +#ifdef DISABLE + struct object_data obj; + + obj.shm_fd = uchan->attr.shm_fd; + obj.wait_fd = uchan->attr.wait_fd; + obj.memory_map_size = uchan->attr.memory_map_size; + ret = ustctl_enable(sock, &obj); + if (ret < 0) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto end; + } + ret = LTTCOMM_OK; +end: +#endif + return ret; +} + +/* + * Disable UST channel on the tracer. + */ +int channel_ust_disable(struct ltt_ust_session *usession, + struct ltt_ust_channel *uchan, int sock) +{ + int ret = LTTCOMM_OK; +#ifdef DISABLE + struct object_data obj; + + obj.shm_fd = uchan->attr.shm_fd; + obj.wait_fd = uchan->attr.wait_fd; + obj.memory_map_size = uchan->attr.memory_map_size; + ret = ustctl_disable(sock, &obj); + if (ret < 0) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto end; + } + ret = LTTCOMM_OK; +end: +#endif + return ret; +}