lttng/ust-endian.h \
lttng/ringbuffer-config.h \
lttng/align.h \
- lttng/bug.h
+ lttng/bug.h \
+ lttng/ust-error.h
# note: usterr-signal-safe.h, core.h and share.h need namespace cleanup.
#include <lttng/ust-abi.h>
+/*
+ * Error values: all the following functions return:
+ * >= 0: Sucess (LTTNG_UST_OK)
+ * < 0: error code.
+ */
int ustctl_register_done(int sock);
int ustctl_create_session(int sock);
int ustctl_open_metadata(int sock, int session_handle,
int ustctl_tracepoint_list(int sock);
/*
* ustctl_tracepoint_list_get is used to iterate on the tp list
- * handle. End is iteration is reached when -ENOENT is returned.
+ * handle. End is iteration is reached when -LTTNG_UST_ERR_NOENT is
+ * returned.
*/
int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
struct lttng_ust_tracepoint_iter *iter);
/*
* ustctl_tracepoint_field_list_get is used to iterate on the tp field
- * list handle. End is iteration is reached when -ENOENT is returned.
+ * list handle. End is iteration is reached when -LTTNG_UST_ERR_NOENT is
+ * returned.
*/
int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle,
struct lttng_ust_field_iter *iter);
--- /dev/null
+#ifndef _LTTNG_UST_ERROR_H
+#define _LTTNG_UST_ERROR_H
+
+/*
+ * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Julien Desfossez <julien.desfossez@polymtl.ca>
+ * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; only
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * This header is meant for liblttng and libust internal use ONLY.
+ * These declarations should NOT be considered stable API.
+ */
+
+#include <limits.h>
+#include <unistd.h>
+#include <lttng/ust-abi.h>
+
+/*
+ * ustcomm error code.
+ */
+enum lttng_ust_error_code {
+ LTTNG_UST_OK = 0, /* Ok */
+ LTTNG_UST_ERR = 1024, /* Unknown Error */
+ LTTNG_UST_ERR_NOENT, /* No entry */
+
+ /* MUST be last element */
+ LTTNG_UST_ERR_NR, /* Last element */
+};
+
+/*
+ * Return a human-readable error message for an lttng-ust error code.
+ * code must be a positive value (or 0).
+ */
+extern const char *lttng_ust_strerror(int code);
+
+#endif /* _LTTNG_UST_ERROR_H */
#include <limits.h>
#include <unistd.h>
#include <lttng/ust-abi.h>
+#include <lttng/ust-error.h>
/*
* Default timeout the application waits for the sessiond to send its
/* Queue size of listen(2) */
#define LTTNG_UST_COMM_MAX_LISTEN 10
-/* Get the error code index from 0. USTCOMM_ERR starts at 1000.
- */
-#define USTCOMM_ERR_INDEX(code) (code - USTCOMM_ERR)
-
-/*
- * ustcomm error code.
- */
-enum ustcomm_return_code {
- USTCOMM_OK = 0, /* Ok */
- /* Range 1 to 999 used for standard error numbers (errno.h) */
- USTCOMM_ERR = 1000, /* Unknown Error */
- USTCOMM_UND, /* Undefine command */
- USTCOMM_NOT_IMPLEMENTED, /* Command not implemented */
- USTCOMM_UNKNOWN_DOMAIN, /* Tracing domain not known */
- USTCOMM_ALLOC_FAIL, /* Trace allocation fail */
- USTCOMM_NO_SESSION, /* No session found */
- USTCOMM_CREATE_FAIL, /* Create trace fail */
- USTCOMM_SESSION_FAIL, /* Create session fail */
- USTCOMM_START_FAIL, /* Start tracing fail */
- USTCOMM_STOP_FAIL, /* Stop tracing fail */
- USTCOMM_LIST_FAIL, /* Listing apps fail */
- USTCOMM_NO_APPS, /* No traceable application */
- USTCOMM_SESS_NOT_FOUND, /* Session name not found */
- USTCOMM_NO_TRACE, /* No trace exist */
- USTCOMM_FATAL, /* Session daemon had a fatal error */
- USTCOMM_NO_TRACEABLE, /* Error for non traceable app */
- USTCOMM_SELECT_SESS, /* Must select a session */
- USTCOMM_EXIST_SESS, /* Session name already exist */
- USTCOMM_NO_EVENT, /* No event found */
- USTCOMM_KERN_NA, /* Kernel tracer unavalable */
- USTCOMM_KERN_EVENT_EXIST, /* Kernel event already exists */
- USTCOMM_KERN_SESS_FAIL, /* Kernel create session failed */
- USTCOMM_KERN_CHAN_FAIL, /* Kernel create channel failed */
- USTCOMM_KERN_CHAN_NOT_FOUND, /* Kernel channel not found */
- USTCOMM_KERN_CHAN_DISABLE_FAIL, /* Kernel disable channel failed */
- USTCOMM_KERN_CHAN_ENABLE_FAIL, /* Kernel enable channel failed */
- USTCOMM_KERN_CONTEXT_FAIL, /* Kernel add context failed */
- USTCOMM_KERN_ENABLE_FAIL, /* Kernel enable event failed */
- USTCOMM_KERN_DISABLE_FAIL, /* Kernel disable event failed */
- USTCOMM_KERN_META_FAIL, /* Kernel open metadata failed */
- USTCOMM_KERN_START_FAIL, /* Kernel start trace failed */
- USTCOMM_KERN_STOP_FAIL, /* Kernel stop trace failed */
- USTCOMM_KERN_CONSUMER_FAIL, /* Kernel consumer start failed */
- USTCOMM_KERN_STREAM_FAIL, /* Kernel create stream failed */
- USTCOMM_KERN_DIR_FAIL, /* Kernel trace directory creation failed */
- USTCOMM_KERN_DIR_EXIST, /* Kernel trace directory exist */
- USTCOMM_KERN_NO_SESSION, /* No kernel session found */
- USTCOMM_KERN_LIST_FAIL, /* Kernel listing events failed */
- USTCONSUMER_COMMAND_SOCK_READY, /* when kconsumerd command socket ready */
- USTCONSUMER_SUCCESS_RECV_FD, /* success on receiving fds */
- USTCONSUMER_ERROR_RECV_FD, /* error on receiving fds */
- USTCONSUMER_POLL_ERROR, /* Error in polling thread in kconsumerd */
- USTCONSUMER_POLL_NVAL, /* Poll on closed fd */
- USTCONSUMER_POLL_HUP, /* All fds have hungup */
- USTCONSUMER_EXIT_SUCCESS, /* kconsumerd exiting normally */
- USTCONSUMER_EXIT_FAILURE, /* kconsumerd exiting on error */
- USTCONSUMER_OUTFD_ERROR, /* error opening the tracefile */
- USTCONSUMER_SPLICE_EBADF, /* EBADF from splice(2) */
- USTCONSUMER_SPLICE_EINVAL, /* EINVAL from splice(2) */
- USTCONSUMER_SPLICE_ENOMEM, /* ENOMEM from splice(2) */
- USTCONSUMER_SPLICE_ESPIPE, /* ESPIPE from splice(2) */
- /* MUST be last element */
- USTCOMM_NR, /* Last element */
-};
-
/*
* Data structure for the commands sent from sessiond to UST.
*/
#include <fcntl.h>
#include <ust-comm.h>
+#include <lttng/ust-error.h>
+
+#define USTCOMM_CODE_OFFSET(code) \
+ (code == LTTNG_UST_OK ? 0 : (code - LTTNG_UST_ERR + 1))
/*
* Human readable error message.
*/
static const char *ustcomm_readable_code[] = {
- [ USTCOMM_ERR_INDEX(USTCOMM_ERR) ] = "Unknown error",
- [ USTCOMM_ERR_INDEX(USTCOMM_UND) ] = "Undefined command",
- [ USTCOMM_ERR_INDEX(USTCOMM_NOT_IMPLEMENTED) ] = "Not implemented",
- [ USTCOMM_ERR_INDEX(USTCOMM_UNKNOWN_DOMAIN) ] = "Unknown tracing domain",
- [ USTCOMM_ERR_INDEX(USTCOMM_NO_SESSION) ] = "No session found",
- [ USTCOMM_ERR_INDEX(USTCOMM_LIST_FAIL) ] = "Unable to list traceable apps",
- [ USTCOMM_ERR_INDEX(USTCOMM_NO_APPS) ] = "No traceable apps found",
- [ USTCOMM_ERR_INDEX(USTCOMM_SESS_NOT_FOUND) ] = "Session name not found",
- [ USTCOMM_ERR_INDEX(USTCOMM_NO_TRACE) ] = "No trace found",
- [ USTCOMM_ERR_INDEX(USTCOMM_FATAL) ] = "Fatal error of the session daemon",
- [ USTCOMM_ERR_INDEX(USTCOMM_CREATE_FAIL) ] = "Create trace failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_START_FAIL) ] = "Start trace failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_STOP_FAIL) ] = "Stop trace failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_NO_TRACEABLE) ] = "App is not traceable",
- [ USTCOMM_ERR_INDEX(USTCOMM_SELECT_SESS) ] = "A session MUST be selected",
- [ USTCOMM_ERR_INDEX(USTCOMM_EXIST_SESS) ] = "Session name already exist",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_NA) ] = "UST tracer not available",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_EVENT_EXIST) ] = "UST event already exists",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_SESS_FAIL) ] = "UST create session failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CHAN_FAIL) ] = "UST create channel failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CHAN_NOT_FOUND) ] = "UST channel not found",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CHAN_DISABLE_FAIL) ] = "Disable UST channel failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CHAN_ENABLE_FAIL) ] = "Enable UST channel failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CONTEXT_FAIL) ] = "Add UST context failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_ENABLE_FAIL) ] = "Enable UST event failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_DISABLE_FAIL) ] = "Disable UST event failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_META_FAIL) ] = "Opening metadata failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_START_FAIL) ] = "Starting UST trace failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_STOP_FAIL) ] = "Stoping UST trace failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_CONSUMER_FAIL) ] = "UST consumer start failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_STREAM_FAIL) ] = "UST create stream failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_DIR_FAIL) ] = "UST trace directory creation failed",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_DIR_EXIST) ] = "UST trace directory already exist",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_NO_SESSION) ] = "No UST session found",
- [ USTCOMM_ERR_INDEX(USTCOMM_KERN_LIST_FAIL) ] = "Listing UST events failed",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_COMMAND_SOCK_READY) ] = "UST consumer command socket ready",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_SUCCESS_RECV_FD) ] = "UST consumer success on receiving fds",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_ERROR_RECV_FD) ] = "UST consumer error on receiving fds",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_POLL_ERROR) ] = "UST consumer error in polling thread",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_POLL_NVAL) ] = "UST consumer polling on closed fd",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_POLL_HUP) ] = "UST consumer all fd hung up",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_EXIT_SUCCESS) ] = "UST consumer exiting normally",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_EXIT_FAILURE) ] = "UST consumer exiting on error",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_OUTFD_ERROR) ] = "UST consumer error opening the tracefile",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_SPLICE_EBADF) ] = "UST consumer splice EBADF",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_SPLICE_EINVAL) ] = "UST consumer splice EINVAL",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_SPLICE_ENOMEM) ] = "UST consumer splice ENOMEM",
- [ USTCOMM_ERR_INDEX(USTCONSUMER_SPLICE_ESPIPE) ] = "UST consumer splice ESPIPE",
- [ USTCOMM_ERR_INDEX(USTCOMM_NO_EVENT) ] = "Event not found",
+ [ USTCOMM_CODE_OFFSET(LTTNG_UST_OK) ] = "Success",
+ [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR) ] = "Unknown error",
+ [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_NOENT) ] = "No entry",
};
/*
- * lttcom_get_readable_code
+ * lttng_ust_strerror
*
- * Return ptr to string representing a human readable
- * error code from the ustcomm_return_code enum.
+ * Receives positive error value.
+ * Return ptr to string representing a human readable
+ * error code from the ustcomm_return_code enum.
*/
-const char *ustcomm_get_readable_code(int code)
+const char *lttng_ust_strerror(int code)
{
- if (code == USTCOMM_OK) {
- return "Success";
- }
- if (code >= USTCOMM_ERR && code < USTCOMM_NR) {
- return ustcomm_readable_code[USTCOMM_ERR_INDEX(code)];
- }
- return strerror(code);
+ if (code == LTTNG_UST_OK)
+ return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
+ if (code < LTTNG_UST_ERR)
+ return strerror(code);
+ if (code >= LTTNG_UST_ERR_NR)
+ code = LTTNG_UST_ERR;
+ return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
+
}
/*
int ustcomm_connect_unix_sock(const char *pathname)
{
struct sockaddr_un sun;
- int fd;
- int ret;
+ int fd, ret;
/*
* libust threads require the close-on-exec flag for all
fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
- ret = fd;
+ ret = -errno;
goto error;
}
ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
if (ret < 0) {
perror("fcntl");
+ ret = -errno;
goto error_fcntl;
}
* is used in normal execution to detect if sessiond is
* alive.
*/
+ ret = -errno;
goto error_connect;
}
error_connect:
error_fcntl:
- close(fd);
+ {
+ int closeret;
+
+ closeret = close(fd);
+ if (closeret)
+ perror("close");
+ }
error:
return ret;
}
new_fd = accept(sock, (struct sockaddr *) &sun, &len);
if (new_fd < 0) {
perror("accept");
- return -1;
+ return -errno;
}
return new_fd;
}
int ustcomm_create_unix_sock(const char *pathname)
{
struct sockaddr_un sun;
- int fd;
- int ret = -1;
+ int fd, ret;
/* Create server socket */
if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("socket");
+ ret = -errno;
goto error;
}
ret = bind(fd, (struct sockaddr *) &sun, sizeof(sun));
if (ret < 0) {
perror("bind");
- goto error;
+ ret = -errno;
+ goto error_close;
}
return fd;
+error_close:
+ {
+ int closeret;
+
+ closeret = close(fd);
+ if (closeret) {
+ perror("close");
+ }
+ }
error:
return ret;
}
ret = listen(sock, LTTNG_UST_COMM_MAX_LISTEN);
if (ret < 0) {
+ ret = -errno;
perror("listen");
}
{
struct msghdr msg;
struct iovec iov[1];
- ssize_t ret = -1;
+ ssize_t ret;
memset(&msg, 0, sizeof(msg));
do {
ret = recvmsg(sock, &msg, 0);
} while (ret < 0 && errno == EINTR);
- if (ret < 0 && errno != EPIPE) {
- perror("recvmsg");
+
+ if (ret < 0) {
+ int shutret;
+
+ if (errno != EPIPE)
+ perror("recvmsg");
+ ret = -errno;
+
+ shutret = shutdown(sock, SHUT_RDWR);
+ if (shutret)
+ fprintf(stderr, "Socket shutdown error");
}
return ret;
{
struct msghdr msg;
struct iovec iov[1];
- ssize_t ret = -1;
+ ssize_t ret;
memset(&msg, 0, sizeof(msg));
do {
ret = sendmsg(sock, &msg, MSG_NOSIGNAL);
} while (ret < 0 && errno == EINTR);
- if (ret < 0 && errno != EPIPE) {
- perror("sendmsg");
+
+ if (ret < 0) {
+ int shutret;
+
+ if (errno != EPIPE)
+ perror("recvmsg");
+ ret = -errno;
+
+ shutret = shutdown(sock, SHUT_RDWR);
+ if (shutret)
+ fprintf(stderr, "Socket shutdown error");
}
return ret;
ret = close(sock);
if (ret < 0) {
perror("close");
+ ret = -errno;
}
return ret;
memset(&msg, 0, sizeof(msg));
/*
- * Note: the consumerd receiver only supports receiving one FD per
+ * Note: we currently only support sending a single FD per
* message.
*/
assert(nb_fd == 1);
do {
ret = sendmsg(sock, &msg, MSG_NOSIGNAL);
} while (ret < 0 && errno == EINTR);
- if (ret < 0 && errno != EPIPE) {
- perror("sendmsg");
+
+ if (ret < 0) {
+ int shutret;
+
+ if (errno != EPIPE)
+ perror("recvmsg");
+ ret = -errno;
+
+ shutret = shutdown(sock, SHUT_RDWR);
+ if (shutret)
+ fprintf(stderr, "Socket shutdown error");
}
return ret;
switch (len) {
case sizeof(*lum):
break;
- case -1:
- if (errno == ECONNRESET) {
- fprintf(stderr, "remote end closed connection\n");
- return 0;
- }
- return -1;
default:
- fprintf(stderr, "incorrect message size: %zd\n", len);
- return -1;
+ if (len < 0) {
+ if (len == -ECONNRESET)
+ fprintf(stderr, "remote end closed connection\n");
+ return len;
+ } else {
+ fprintf(stderr, "incorrect message size: %zd\n", len);
+ return -EINVAL;
+ }
}
return 0;
}
fprintf(stderr, "Unexpected result message handle\n");
return -EINVAL;
}
-
if (lur->cmd != expected_cmd) {
fprintf(stderr, "Unexpected result message command\n");
return -EINVAL;
}
- if (lur->ret_code != USTCOMM_OK) {
- /*
- * Some errors are normal.. we should put this
- * in a debug level message...
- * fprintf(stderr, "remote operation failed with code %d.\n",
- * lur->ret_code);
- */
- return lur->ret_code;
- }
- return 0;
- case -1:
- if (errno == ECONNRESET) {
- fprintf(stderr, "remote end closed connection\n");
- return -EINVAL;
- }
- return -1;
+ return lur->ret_code;
default:
- fprintf(stderr, "incorrect message size: %zd\n", len);
- return len > 0 ? -1 : len;
+ if (len < 0) {
+ /* Transport level error */
+ if (len == -ECONNRESET)
+ fprintf(stderr, "remote end closed connection\n");
+ return len;
+ } else {
+ fprintf(stderr, "incorrect message size: %zd\n", len);
+ return len;
+ }
}
}
ret = ustcomm_send_app_msg(sock, lum);
if (ret)
return ret;
- ret = ustcomm_recv_app_reply(sock, lur, lum->handle, lum->cmd);
- if (ret)
- return ret;
- return 0;
+ return ustcomm_recv_app_reply(sock, lur, lum->handle, lum->cmd);
}
-
/*
* Receives a single fd from socket.
*
- * Returns the size of received data
+ * Returns negative error value on error, or file descriptor number on
+ * success.
*/
int ustcomm_recv_fd(int sock)
{
if (errno != EPIPE) {
perror("recvmsg");
}
+ ret = -errno;
goto end;
}
if (ret != sizeof(data_fd)) {
fprintf(stderr, "Received %d bytes, expected %zd", ret, sizeof(data_fd));
+ ret = -EINVAL;
goto end;
}
cmsg = CMSG_FIRSTHDR(&msg);
if (!cmsg) {
fprintf(stderr, "Invalid control message header\n");
- ret = -1;
+ ret = -EINVAL;
goto end;
}
if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
fprintf(stderr, "Didn't received any fd\n");
- ret = -1;
+ ret = -EINVAL;
goto end;
}
/* this is our fd */
* fprintf(stderr, "received fd %d\n", ret);
*/
end:
+ if (ret < 0) {
+ int shutret;
+
+ shutret = shutdown(sock, SHUT_RDWR);
+ if (shutret)
+ fprintf(stderr, "Socket shutdown error");
+ }
return ret;
}
lum.handle = handle;
lum.cmd = LTTNG_UST_RELEASE;
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
- if (ret < 0) {
+ if (ret)
return ret;
- }
}
return 0;
}
if (data->shm_fd >= 0) {
ret = close(data->shm_fd);
if (ret < 0) {
+ ret = -errno;
return ret;
}
}
if (data->wait_fd >= 0) {
ret = close(data->wait_fd);
if (ret < 0) {
+ ret = -errno;
return ret;
}
}
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
- if (lur.ret_code != USTCOMM_OK) {
- DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code));
- goto error;
- }
return 0;
-
-error:
- return -1;
}
/*
free(metadata_data);
return ret;
}
- if (lur.ret_code != USTCOMM_OK) {
- free(metadata_data);
- return lur.ret_code;
- }
metadata_data->handle = lur.ret_val;
DBG("received metadata handle %u", metadata_data->handle);
metadata_data->memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
ret = ustcomm_recv_fd(sock);
if (ret < 0)
- err = 1;
+ err = ret;
else
metadata_data->shm_fd = ret;
/*
/* get wait fd */
ret = ustcomm_recv_fd(sock);
if (ret < 0)
- err = 1;
+ err = ret;
else
metadata_data->wait_fd = ret;
if (err)
error:
(void) ustctl_release_object(sock, metadata_data);
free(metadata_data);
- return -EINVAL;
+ return err;
}
int ustctl_create_channel(int sock, int session_handle,
free(channel_data);
return ret;
}
- if (lur.ret_code != USTCOMM_OK) {
- free(channel_data);
- return lur.ret_code;
- }
channel_data->handle = lur.ret_val;
DBG("received channel handle %u", channel_data->handle);
channel_data->memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
ret = ustcomm_recv_fd(sock);
if (ret < 0)
- err = 1;
+ err = ret;
else
channel_data->shm_fd = ret;
/*
/* get wait fd */
ret = ustcomm_recv_fd(sock);
if (ret < 0)
- err = 1;
+ err = ret;
else
channel_data->wait_fd = ret;
if (err)
error:
(void) ustctl_release_object(sock, channel_data);
free(channel_data);
- return -EINVAL;
+ return err;
}
/*
* Return -ENOENT if no more stream is available for creation.
* Return 0 on success.
- * Return negative error value on error.
+ * Return negative error value on system error.
+ * Return positive error value on UST error.
*/
int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
struct lttng_ust_object_data **_stream_data)
free(stream_data);
return ret;
}
- if (lur.ret_code != USTCOMM_OK) {
- free(stream_data);
- return lur.ret_code;
- }
-
stream_data->handle = lur.ret_val;
DBG("received stream handle %u", stream_data->handle);
stream_data->memory_map_size = lur.u.stream.memory_map_size;
/* get shm fd */
fd = ustcomm_recv_fd(sock);
if (fd < 0)
- err = 1;
+ err = fd;
else
stream_data->shm_fd = fd;
/*
/* get wait fd */
fd = ustcomm_recv_fd(sock);
if (fd < 0)
- err = 1;
+ err = fd;
else
stream_data->wait_fd = fd;
if (err)
error:
(void) ustctl_release_object(sock, stream_data);
free(stream_data);
- return -EINVAL;
+ return err;
}
int ustctl_create_event(int sock, struct lttng_ust_event *ev,
ret = ustcomm_send_app_msg(sock, &lum);
if (ret)
return ret;
- if (ret) {
- return ret;
- }
/* send var len bytecode */
ret = ustcomm_send_unix_sock(sock, bytecode->data,
bytecode->len);
if (ret < 0) {
+ if (ret == -ECONNRESET)
+ fprintf(stderr, "remote end closed connection\n");
return ret;
}
- ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
- if (ret)
- return ret;
- return ret;
+ if (ret != bytecode->len)
+ return -EINVAL;
+ return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
}
/* Enable event, channel and session ioctl */
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
- if (lur.ret_code != USTCOMM_OK) {
- DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code));
- return -EINVAL;
- }
len = ustcomm_recv_unix_sock(sock, iter, sizeof(*iter));
if (len != sizeof(*iter)) {
return -EINVAL;
*/
#include <lttng/ust-abi.h>
+#include <lttng/ust-error.h>
#include <urcu/compiler.h>
#include <urcu/list.h>
#include <lttng/ust-events.h>
retry:
iter = lttng_ust_tracepoint_list_get_iter_next(list);
if (!iter)
- return -ENOENT;
+ return -LTTNG_UST_ERR_NOENT;
if (!strcmp(iter->name, "lttng_ust:metadata"))
goto retry;
memcpy(tp, iter, sizeof(*tp));
retry:
iter = lttng_ust_field_list_get_iter_next(list);
if (!iter)
- return -ENOENT;
+ return -LTTNG_UST_ERR_NOENT;
if (!strcmp(iter->event_name, "lttng_ust:metadata"))
goto retry;
memcpy(tp, iter, sizeof(*tp));
#include <lttng/ust-events.h>
#include <lttng/ust-abi.h>
#include <lttng/ust.h>
+#include <lttng/ust-error.h>
#include <ust-comm.h>
#include <usterr-signal-safe.h>
#include <helper.h>
case sizeof(*lur):
DBG("message successfully sent");
return 0;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
+ default:
+ if (len == -ECONNRESET) {
+ DBG("remote end closed connection");
return 0;
}
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return -1;
+ if (len < 0)
+ return len;
+ DBG("incorrect message size: %zd", len);
+ return -EINVAL;
}
}
struct lttng_ust_filter_bytecode *bytecode;
if (lum->u.filter.data_size > FILTER_BYTECODE_MAX_LEN) {
- ERR("Filter data size is too large: %u bytes\n",
+ ERR("Filter data size is too large: %u bytes",
lum->u.filter.data_size);
ret = -EINVAL;
goto error;
}
if (lum->u.filter.reloc_offset > lum->u.filter.data_size) {
- ERR("Filter reloc offset %u is not within data\n",
+ ERR("Filter reloc offset %u is not within data",
lum->u.filter.reloc_offset);
ret = -EINVAL;
goto error;
ret = 0;
free(bytecode);
goto error;
- case -1:
- DBG("Receive failed from lttng-sessiond with errno %d", errno);
- if (errno == ECONNRESET) {
- ERR("%s remote end closed connection\n", sock_info->name);
- ret = -EINVAL;
- free(bytecode);
- goto error;
- }
- ret = -EINVAL;
- goto end;
default:
if (len == lum->u.filter.data_size) {
- DBG("filter data received\n");
+ DBG("filter data received");
break;
+ } else if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection", sock_info->name);
+ ret = len;
+ free(bytecode);
+ goto error;
+ }
+ ret = len;
+ goto end;
} else {
- ERR("incorrect filter data message size: %zd\n", len);
+ DBG("incorrect filter data message size: %zd", len);
ret = -EINVAL;
free(bytecode);
goto end;
lur.cmd = lum->cmd;
lur.ret_val = ret;
if (ret >= 0) {
- lur.ret_code = USTCOMM_OK;
+ lur.ret_code = LTTNG_UST_OK;
} else {
- //lur.ret_code = USTCOMM_SESSION_FAIL;
- lur.ret_code = ret;
+ /*
+ * Use -LTTNG_UST_ERR as wildcard for UST internal
+ * error that are not caused by the transport, except if
+ * we already have a more precise error message to
+ * report.
+ */
+ if (ret > -LTTNG_UST_ERR)
+ lur.ret_code = -LTTNG_UST_ERR;
+ else
+ lur.ret_code = ret;
}
if (ret >= 0) {
switch (lum->cmd) {
}
ret = send_reply(sock, &lur);
if (ret < 0) {
- perror("error sending reply");
+ DBG("error sending reply");
goto error;
}
if ((lum->cmd == LTTNG_UST_STREAM
|| lum->cmd == LTTNG_UST_CHANNEL
|| lum->cmd == LTTNG_UST_METADATA)
- && lur.ret_code == USTCOMM_OK) {
+ && lur.ret_code == LTTNG_UST_OK) {
int sendret = 0;
/* we also need to send the file descriptors. */
&shm_fd, &shm_fd,
1, sizeof(int));
if (ret < 0) {
- perror("send shm_fd");
+ ERR("send shm_fd");
sendret = ret;
}
/*
* LTTNG_UST_TRACEPOINT_FIELD_LIST_GET needs to send the field
* after the reply.
*/
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
switch (lum->cmd) {
case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET:
len = ustcomm_send_unix_sock(sock,
&args.field_list.entry,
sizeof(args.field_list.entry));
+ if (len < 0) {
+ ret = len;
+ goto error;
+ }
if (len != sizeof(args.field_list.entry)) {
- ret = -1;
+ ret = -EINVAL;
goto error;
}
}
* that we keep the write side of the wait_fd open, but close
* the read side.
*/
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
switch (lum->cmd) {
case LTTNG_UST_STREAM:
if (shm_fd >= 0) {
len = ustcomm_recv_unix_sock(sock, &lum, sizeof(lum));
switch (len) {
case 0: /* orderly shutdown */
- DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name);
+ DBG("%s ltt-sessiond has performed an orderly shutdown", sock_info->name);
ust_lock();
/*
* Either sessiond has shutdown or refused us by closing the socket.
ust_unlock();
goto end;
case sizeof(lum):
- DBG("message received\n");
+ DBG("message received");
ret = handle_message(sock_info, sock, &lum);
- if (ret < 0) {
+ if (ret) {
ERR("Error handling message for %s socket", sock_info->name);
}
continue;
- case -1:
- DBG("Receive failed from lttng-sessiond with errno %d", errno);
- if (errno == ECONNRESET) {
- ERR("%s remote end closed connection\n", sock_info->name);
+ default:
+ if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ } else {
+ DBG("incorrect message size (%s socket): %zd", sock_info->name, len);
+ }
+ if (len == -ECONNRESET) {
+ DBG("%s remote end closed connection", sock_info->name);
goto end;
}
goto end;
- default:
- ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len);
- continue;
}
}
* sessiond monitoring thread: monitor presence of global and per-user
* sessiond by polling the application common named pipe.
*/
-/* TODO */
-
void __attribute__((constructor)) lttng_ust_init(void)
{
struct timespec constructor_timeout;
stream_datas[k].handle = lur.ret_val;
printf("received stream handle %u\n",
stream_datas[k].handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
stream_datas[k].memory_map_size = lur.u.stream.memory_map_size;
return ret;
metadata_data.handle = lur.ret_val;
printf("received metadata handle %u\n", metadata_data.handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
metadata_data.memory_map_size = lur.u.channel.memory_map_size;
return ret;
channel_data.handle = lur.ret_val;
printf("received channel handle %u\n", channel_data.handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
channel_data.memory_map_size = lur.u.channel.memory_map_size;
stream_datas[k].handle = lur.ret_val;
printf("received stream handle %u\n",
stream_datas[k].handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
stream_datas[k].memory_map_size = lur.u.stream.memory_map_size;
return ret;
metadata_data[i].handle = lur.ret_val;
printf("received metadata handle %u\n", metadata_data[i].handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
metadata_data[i].memory_map_size = lur.u.channel.memory_map_size;
return ret;
channel_data[i][j].handle = lur.ret_val;
printf("received channel handle %u\n", channel_data[i][j].handle);
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
ssize_t len;
channel_data[i][j].memory_map_size = lur.u.channel.memory_map_size;
projects / lttng-ust.git / commitdiff
