+ channel = zmalloc(sizeof(*channel));
+ if (!channel) {
+ goto error;
+ }
+
+ extended = zmalloc(sizeof(*extended));
+ if (!extended) {
+ goto error;
+ }
+
+ channel->attr.extended.ptr = extended;
+
+ lttng_channel_set_default_attr(domain, &channel->attr);
+ return channel;
+error:
+ free(channel);
+ free(extended);
+ return NULL;
+}
+
+void lttng_channel_destroy(struct lttng_channel *channel)
+{
+ if (!channel) {
+ return;
+ }
+
+ if (channel->attr.extended.ptr) {
+ free(channel->attr.extended.ptr);
+ }
+ free(channel);
+}
+
+/*
+ * Enable channel per domain
+ * Returns size of returned session payload data or a negative error code.
+ */
+int lttng_enable_channel(struct lttng_handle *handle,
+ struct lttng_channel *in_chan)
+{
+ struct lttcomm_session_msg lsm;
+ size_t total_buffer_size_needed_per_cpu = 0;
+
+ /* NULL arguments are forbidden. No default values. */
+ if (handle == NULL || in_chan == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ memcpy(&lsm.u.channel.chan, in_chan, sizeof(lsm.u.channel.chan));
+ lsm.u.channel.chan.attr.extended.ptr = NULL;
+
+ if (!in_chan->attr.extended.ptr) {
+ struct lttng_channel *channel;
+ struct lttng_channel_extended *extended;
+
+ channel = lttng_channel_create(&handle->domain);
+ if (!channel) {
+ return -LTTNG_ERR_NOMEM;
+ }
+
+ /*
+ * Create a new channel in order to use default extended
+ * attribute values.
+ */
+ extended = (struct lttng_channel_extended *)
+ channel->attr.extended.ptr;
+ memcpy(&lsm.u.channel.extended, extended, sizeof(*extended));
+ lttng_channel_destroy(channel);
+ } else {
+ struct lttng_channel_extended *extended;
+
+ extended = (struct lttng_channel_extended *)
+ in_chan->attr.extended.ptr;
+ memcpy(&lsm.u.channel.extended, extended, sizeof(*extended));
+ }
+
+ /*
+ * Verify that the amount of memory required to create the requested
+ * buffer is available on the system at the moment.
+ */
+ total_buffer_size_needed_per_cpu = lsm.u.channel.chan.attr.num_subbuf *
+ lsm.u.channel.chan.attr.subbuf_size;
+ if (!check_enough_available_memory(total_buffer_size_needed_per_cpu)) {
+ return -LTTNG_ERR_NOMEM;
+ }
+
+ lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
+/*
+ * All tracing will be stopped for registered events of the channel.
+ * Returns size of returned session payload data or a negative error code.
+ */
+int lttng_disable_channel(struct lttng_handle *handle, const char *name)
+{
+ struct lttcomm_session_msg lsm;
+
+ /* Safety check. Both are mandatory. */
+ if (handle == NULL || name == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+
+ lsm.cmd_type = LTTNG_DISABLE_CHANNEL;
+
+ lttng_ctl_copy_string(lsm.u.disable.channel_name, name,
+ sizeof(lsm.u.disable.channel_name));
+
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
+/*
+ * Add PID to session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_track_pid(struct lttng_handle *handle, int pid)
+{
+ struct lttcomm_session_msg lsm;
+
+ /* NULL arguments are forbidden. No default values. */
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+
+ lsm.cmd_type = LTTNG_TRACK_PID;
+ lsm.u.pid_tracker.pid = pid;
+
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
+/*
+ * Remove PID from session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_untrack_pid(struct lttng_handle *handle, int pid)
+{
+ struct lttcomm_session_msg lsm;
+
+ /* NULL arguments are forbidden. No default values. */
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+
+ lsm.cmd_type = LTTNG_UNTRACK_PID;
+ lsm.u.pid_tracker.pid = pid;
+
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
+/*
+ * Lists all available tracepoints of domain.
+ * Sets the contents of the events array.
+ * Returns the number of lttng_event entries in events;
+ * on error, returns a negative value.
+ */
+int lttng_list_tracepoints(struct lttng_handle *handle,
+ struct lttng_event **events)
+{
+ int ret;
+ struct lttcomm_session_msg lsm;
+
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return ret / sizeof(struct lttng_event);
+}
+
+/*
+ * Lists all available tracepoint fields of domain.
+ * Sets the contents of the event field array.
+ * Returns the number of lttng_event_field entries in events;
+ * on error, returns a negative value.
+ */
+int lttng_list_tracepoint_fields(struct lttng_handle *handle,
+ struct lttng_event_field **fields)
+{
+ int ret;
+ struct lttcomm_session_msg lsm;
+
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS;
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return ret / sizeof(struct lttng_event_field);
+}
+
+/*
+ * Lists all available kernel system calls. Allocates and sets the contents of
+ * the events array.
+ *
+ * Returns the number of lttng_event entries in events; on error, returns a
+ * negative value.
+ */
+int lttng_list_syscalls(struct lttng_event **events)
+{
+ int ret;
+ struct lttcomm_session_msg lsm;
+
+ if (!events) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_LIST_SYSCALLS;
+ /* Force kernel domain for system calls. */
+ lsm.domain.type = LTTNG_DOMAIN_KERNEL;
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return ret / sizeof(struct lttng_event);
+}
+
+/*
+ * Returns a human readable string describing
+ * the error code (a negative value).
+ */
+const char *lttng_strerror(int code)
+{
+ return error_get_str(code);
+}
+
+enum lttng_error_code lttng_create_session_ext(
+ struct lttng_session_descriptor *session_descriptor)
+{
+ enum lttng_error_code ret_code;
+ struct lttcomm_session_msg lsm = {
+ .cmd_type = LTTNG_CREATE_SESSION_EXT,
+ };
+ void *reply = NULL;
+ struct lttng_buffer_view reply_view;
+ int reply_ret;
+ bool sessiond_must_generate_ouput;
+ struct lttng_dynamic_buffer payload;
+ int ret;
+ size_t descriptor_size;
+ struct lttng_session_descriptor *descriptor_reply = NULL;
+
+ lttng_dynamic_buffer_init(&payload);
+ if (!session_descriptor) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ sessiond_must_generate_ouput =
+ !lttng_session_descriptor_is_output_destination_initialized(
+ session_descriptor);
+ if (sessiond_must_generate_ouput) {
+ const char *home_dir = utils_get_home_dir();
+ size_t home_dir_len = home_dir ? strlen(home_dir) + 1 : 0;
+
+ if (!home_dir || home_dir_len > LTTNG_PATH_MAX) {
+ ret_code = LTTNG_ERR_FATAL;
+ goto end;
+ }
+
+ lsm.u.create_session.home_dir_size = (uint16_t) home_dir_len;
+ ret = lttng_dynamic_buffer_append(&payload, home_dir,
+ home_dir_len);
+ if (ret) {
+ ret_code = LTTNG_ERR_NOMEM;
+ goto end;
+ }
+ }
+
+ descriptor_size = payload.size;
+ ret = lttng_session_descriptor_serialize(session_descriptor,
+ &payload);
+ if (ret) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ descriptor_size = payload.size - descriptor_size;
+ lsm.u.create_session.session_descriptor_size = descriptor_size;
+
+ /* Command returns a session descriptor on success. */
+ reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, payload.data,
+ payload.size, &reply);
+ if (reply_ret < 0) {
+ ret_code = -reply_ret;
+ goto end;
+ } else if (reply_ret == 0) {
+ /* Socket unexpectedly closed by the session daemon. */
+ ret_code = LTTNG_ERR_FATAL;
+ goto end;
+ }
+
+ reply_view = lttng_buffer_view_init(reply, 0, reply_ret);
+ ret = lttng_session_descriptor_create_from_buffer(&reply_view,
+ &descriptor_reply);
+ if (ret < 0) {
+ ret_code = LTTNG_ERR_FATAL;
+ goto end;
+ }
+ ret_code = LTTNG_OK;
+ lttng_session_descriptor_assign(session_descriptor, descriptor_reply);
+end:
+ free(reply);
+ lttng_dynamic_buffer_reset(&payload);
+ lttng_session_descriptor_destroy(descriptor_reply);
+ return ret_code;
+}
+
+/*
+ * Create a new session using name and url for destination.
+ *
+ * Returns LTTNG_OK on success or a negative error code.
+ */
+int lttng_create_session(const char *name, const char *url)
+{
+ int ret;
+ ssize_t size;
+ struct lttng_uri *uris = NULL;
+ struct lttng_session_descriptor *descriptor = NULL;
+ enum lttng_error_code ret_code;
+
+ if (!name) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ size = uri_parse_str_urls(url, NULL, &uris);
+ if (size < 0) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+ switch (size) {
+ case 0:
+ descriptor = lttng_session_descriptor_create(name);
+ break;
+ case 1:
+ if (uris[0].dtype != LTTNG_DST_PATH) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+ descriptor = lttng_session_descriptor_local_create(name,
+ uris[0].dst.path);
+ break;
+ case 2:
+ descriptor = lttng_session_descriptor_network_create(name, url,
+ NULL);
+ break;
+ default:
+ ret = -LTTNG_ERR_INVALID;
+ goto end;