static
int run_command_wait(struct notification_thread_handle *handle,
struct notification_thread_command *cmd)
{
int ret;
uint64_t notification_counter = 1;
pthread_mutex_lock(&handle->cmd_queue.lock);
/* Add to queue. */
cds_list_add_tail(&cmd->cmd_list_node,
&handle->cmd_queue.list);
/* Wake-up thread. */
ret = write(lttng_pipe_get_writefd(handle->cmd_queue.event_pipe),
¬ification_counter, sizeof(notification_counter));
if (ret < 0) {
PERROR("write to notification thread's queue event fd");
/*
* Remove the command from the list so the notification
* thread does not process it.
*/
cds_list_del(&cmd->cmd_list_node);
goto error_unlock_queue;
}
pthread_mutex_unlock(&handle->cmd_queue.lock);
lttng_waiter_wait(&cmd->reply_waiter);
return 0;
error_unlock_queue:
pthread_mutex_unlock(&handle->cmd_queue.lock);
return -1;
}
void deq_push_l(struct cds_list_head *e, struct deq *p)
{
cds_list_add_tail(e, &p->chain);
}
/*
* Send a get channel command to consumer using the given channel key. The
* channel object is populated and the stream list.
*
* Return 0 on success else a negative value.
*/
int ust_consumer_get_channel(struct consumer_socket *socket,
struct ust_app_channel *ua_chan)
{
int ret;
struct lttcomm_consumer_msg msg;
assert(ua_chan);
assert(socket);
memset(&msg, 0, sizeof(msg));
msg.cmd_type = LTTNG_CONSUMER_GET_CHANNEL;
msg.u.get_channel.key = ua_chan->key;
pthread_mutex_lock(socket->lock);
health_code_update();
/* Send command and wait for OK reply. */
ret = consumer_send_msg(socket, &msg);
if (ret < 0) {
goto error;
}
/* First, get the channel from consumer. */
ret = ustctl_recv_channel_from_consumer(*socket->fd_ptr, &ua_chan->obj);
if (ret < 0) {
if (ret != -EPIPE) {
ERR("Error recv channel from consumer %d with ret %d",
*socket->fd_ptr, ret);
} else {
DBG3("UST app recv channel from consumer. Consumer is dead.");
}
goto error;
}
/* Next, get all streams. */
while (1) {
struct ust_app_stream *stream;
/* Create UST stream */
stream = ust_app_alloc_stream();
if (stream == NULL) {
ret = -ENOMEM;
goto error;
}
/* Stream object is populated by this call if successful. */
ret = ustctl_recv_stream_from_consumer(*socket->fd_ptr, &stream->obj);
if (ret < 0) {
free(stream);
if (ret == -LTTNG_UST_ERR_NOENT) {
DBG3("UST app consumer has no more stream available");
ret = 0;
break;
}
if (ret != -EPIPE) {
ERR("Recv stream from consumer %d with ret %d",
*socket->fd_ptr, ret);
} else {
DBG3("UST app recv stream from consumer. Consumer is dead.");
}
goto error;
}
/* Order is important this is why a list is used. */
cds_list_add_tail(&stream->list, &ua_chan->streams.head);
ua_chan->streams.count++;
DBG2("UST app stream %d received successfully", ua_chan->streams.count);
}
/* This MUST match or else we have a synchronization problem. */
assert(ua_chan->expected_stream_count == ua_chan->streams.count);
/* Wait for confirmation that we can proceed with the streams. */
ret = consumer_recv_status_reply(socket);
if (ret < 0) {
goto error;
}
error:
health_code_update();
pthread_mutex_unlock(socket->lock);
return ret;
}
void deq_push_l(struct cds_list_head *e, struct deq *p)
{
spin_lock(&p->lock);
cds_list_add_tail(e, &p->chain);
spin_unlock(&p->lock);
}
