X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fchannel.c;h=3870af4beb5ae407fd1d2ee527f41cd54cf2df03;hp=ab9bf6c6d4fcbafbbe48d085b0143de0949e76f4;hb=f6a9efaa0fe496b7fa4850daa2eae98a240433e1;hpb=54d01ffb43587b221dc50ec42b6070fad89bd255 diff --git a/ltt-sessiond/channel.c b/ltt-sessiond/channel.c index ab9bf6c6d..3870af4be 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 *usession, + struct lttng_channel *chan, int sock) +{ + int ret; + struct lttng_channel *attr = chan; + struct ltt_ust_channel *suchan; + struct lttng_ust_channel_attr uattr; + struct object_data *obj; + + /* Creating channel attributes if needed */ + if (attr == NULL) { + /* FIXME: this appears to be a memory leak */ + /* TODO: get default for other UST domains */ + attr = channel_new_default_attr(LTTNG_DOMAIN_UST); + if (attr == NULL) { + ret = LTTCOMM_FATAL; + goto error; + } + } + + suchan = trace_ust_create_channel(attr, usession->path); + if (suchan == NULL) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto error; + } + + uattr.overwrite = attr->attr.overwrite; + uattr.subbuf_size = attr->attr.subbuf_size; + uattr.num_subbuf = attr->attr.num_subbuf; + uattr.switch_timer_interval = attr->attr.switch_timer_interval; + uattr.read_timer_interval = attr->attr.read_timer_interval; + uattr.output = attr->attr.output; + ret = ustctl_create_channel(sock, usession->handle, + &uattr, &obj); + if (ret < 0) { + ret = LTTCOMM_UST_CHAN_FAIL; + goto error; + } + + suchan->attr.overwrite = uattr.overwrite; + suchan->attr.subbuf_size = uattr.subbuf_size; + suchan->attr.num_subbuf = uattr.num_subbuf; + suchan->attr.switch_timer_interval = uattr.switch_timer_interval; + suchan->attr.read_timer_interval = uattr.read_timer_interval; + suchan->attr.output = uattr.output; + suchan->handle = obj->handle; + suchan->attr.shm_fd = obj->shm_fd; + suchan->attr.wait_fd = obj->wait_fd; + suchan->attr.memory_map_size = obj->memory_map_size; + suchan->obj = obj; + + /* Add channel to session */ + cds_list_add(&suchan->list, &usession->channels.head); + usession->channels.count++; + + DBG2("Channel %s UST create successfully for sock:%d", suchan->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; + struct object_data obj; + + obj.handle = uchan->handle; + 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: + 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; + struct object_data obj; + + obj.handle = uchan->handle; + 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: + return ret; +}