* file exists but no sessiond is listening.
*/
if (errno != ECONNREFUSED && errno != ECONNRESET
- && errno != ENOENT)
+ && errno != ENOENT && errno != EACCES)
PERROR("connect");
ret = -errno;
if (ret == -ECONNREFUSED || ret == -ECONNRESET)
{
struct msghdr msg;
struct iovec iov[1];
- ssize_t ret;
+ ssize_t ret = -1;
+ size_t len_last;
memset(&msg, 0, sizeof(msg));
msg.msg_iovlen = 1;
do {
+ len_last = iov[0].iov_len;
ret = recvmsg(sock, &msg, 0);
- } while (ret < 0 && errno == EINTR);
+ if (ret > 0) {
+ iov[0].iov_base += ret;
+ iov[0].iov_len -= ret;
+ assert(ret <= len_last);
+ }
+ } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
if (ret < 0) {
int shutret;
shutret = shutdown(sock, SHUT_RDWR);
if (shutret)
ERR("Socket shutdown error");
+ } else if (ret > 0) {
+ ret = len;
}
+ /* ret = 0 means an orderly shutdown. */
return ret;
}
* expected var_len.
*/
ssize_t ustcomm_recv_channel_from_sessiond(int sock,
- void **_chan_data, uint64_t var_len)
+ void **_chan_data, uint64_t var_len,
+ int *_wakeup_fd)
{
void *chan_data;
- ssize_t len;
+ ssize_t len, nr_fd;
+ int wakeup_fd;
if (var_len > LTTNG_UST_CHANNEL_DATA_MAX_LEN) {
len = -EINVAL;
if (len != var_len) {
goto error_recv;
}
+ /* recv wakeup fd */
+ nr_fd = ustcomm_recv_fds_unix_sock(sock, &wakeup_fd, 1);
+ if (nr_fd <= 0) {
+ if (nr_fd < 0) {
+ len = nr_fd;
+ goto error_recv;
+ } else {
+ len = -EIO;
+ goto error_recv;
+ }
+ }
+ *_wakeup_fd = wakeup_fd;
*_chan_data = chan_data;
return len;
return 0;
}
+static
+int serialize_string_encoding(enum ustctl_string_encodings *ue,
+ enum lttng_string_encodings le)
+{
+ switch (le) {
+ case lttng_encode_none:
+ *ue = ustctl_encode_none;
+ break;
+ case lttng_encode_UTF8:
+ *ue = ustctl_encode_UTF8;
+ break;
+ case lttng_encode_ASCII:
+ *ue = ustctl_encode_ASCII;
+ break;
+ default:
+ return -EINVAL;
+ }
+ return 0;
+}
+
static
int serialize_basic_type(enum ustctl_abstract_types *uatype,
enum lttng_abstract_types atype,
uit->signedness = lit->signedness;
uit->reverse_byte_order = lit->reverse_byte_order;
uit->base = lit->base;
- uit->encoding = lit->encoding;
+ if (serialize_string_encoding(&uit->encoding, lit->encoding))
+ return -EINVAL;
uit->alignment = lit->alignment;
*uatype = ustctl_atype_integer;
break;
}
case atype_string:
{
- ubt->string.encoding = lbt->string.encoding;
+ if (serialize_string_encoding(&ubt->string.encoding,
+ lbt->string.encoding))
+ return -EINVAL;
*uatype = ustctl_atype_string;
break;
}
return ret;
}
+static
+int serialize_ctx_fields(size_t *_nr_write_fields,
+ struct ustctl_field **ustctl_fields,
+ size_t nr_fields,
+ const struct lttng_ctx_field *lttng_fields)
+{
+ struct ustctl_field *fields;
+ int i, ret;
+ size_t nr_write_fields = 0;
+
+ fields = zmalloc(nr_fields * sizeof(*fields));
+ if (!fields)
+ return -ENOMEM;
+
+ for (i = 0; i < nr_fields; i++) {
+ struct ustctl_field *f;
+ const struct lttng_event_field *lf;
+
+ f = &fields[nr_write_fields];
+ lf = <tng_fields[i].event_field;
+
+ /* skip 'nowrite' fields */
+ if (lf->nowrite)
+ continue;
+ strncpy(f->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
+ f->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ ret = serialize_one_type(&f->type, &lf->type);
+ if (ret)
+ goto error_type;
+ nr_write_fields++;
+ }
+
+ *_nr_write_fields = nr_write_fields;
+ *ustctl_fields = fields;
+ return 0;
+
+error_type:
+ free(fields);
+ return ret;
+}
+
/*
* Returns 0 on success, negative error value on error.
*/
struct ustcomm_notify_event_reply r;
} reply;
size_t signature_len, fields_len, model_emf_uri_len;
- struct ustctl_field *fields;
+ struct ustctl_field *fields = NULL;
size_t nr_write_fields = 0;
int ret;
if (len < 0) {
return len;
}
+ } else {
+ free(fields);
}
if (model_emf_uri_len) {
int session_objd, /* session descriptor */
int channel_objd, /* channel descriptor */
size_t nr_ctx_fields,
- const struct lttng_event_field *ctx_fields,
+ const struct lttng_ctx_field *ctx_fields,
uint32_t *chan_id, /* channel id (output) */
int *header_type) /* header type (output) */
{
struct ustcomm_notify_channel_reply r;
} reply;
size_t fields_len;
- struct ustctl_field *fields;
+ struct ustctl_field *fields = NULL;
int ret;
size_t nr_write_fields = 0;
/* Calculate fields len, serialize fields. */
if (nr_ctx_fields > 0) {
- ret = serialize_fields(&nr_write_fields, &fields,
+ ret = serialize_ctx_fields(&nr_write_fields, &fields,
nr_ctx_fields, ctx_fields);
if (ret)
return ret;
if (len < 0) {
return len;
}
+ } else {
+ free(fields);
}
len = ustcomm_recv_unix_sock(sock, &reply, sizeof(reply));