ACLOCAL_AMFLAGS = -I config
-SUBDIRS = . snprintf liblttng-ust-comm libringbuffer libust include doc \
- libustjava libustfork tests
+SUBDIRS = . snprintf liblttng-ust-comm libringbuffer libust libustctl \
+ include doc libustjava libustfork tests
#temporarily disabled
# . libustinstr-malloc
liblttng-ust-comm/Makefile
libringbuffer/Makefile
libust/Makefile
+ libustctl/Makefile
tests/Makefile
tests/hello/Makefile
tests/ust-basic-tracing/Makefile
ust/lttng-tracepoint-event.h \
ust/lttng-tracepoint-event-reset.h \
ust/lttng-events.h \
+ ust/lttng-ust-ctl.h \
ust/version.h \
ust/lttng-ust-abi.h \
ust/ringbuffer-abi.h \
*/
#include <limits.h>
-#include <lttng/lttng.h>
+#include <unistd.h>
#include <ust/lttng-ust-abi.h>
/*
/* Queue size of listen(2) */
#define MAX_LISTEN 10
-/* Get the error code index from 0 since
- * LTTCOMM_OK start at 1000
+/* Get the error code index from 0. USTCOMM_ERR starts at 1000.
*/
-#define LTTCOMM_ERR_INDEX(code) (code - LTTCOMM_OK)
+#define USTCOMM_ERR_INDEX(code) (code - USTCOMM_ERR)
/*
- * lttcomm error code.
+ * ustcomm error code.
*/
-enum lttcomm_return_code {
- LTTCOMM_OK = 1000, /* Ok */
- LTTCOMM_ERR, /* Unknown Error */
- LTTCOMM_UND, /* Undefine command */
- LTTCOMM_NOT_IMPLEMENTED, /* Command not implemented */
- LTTCOMM_UNKNOWN_DOMAIN, /* Tracing domain not known */
- LTTCOMM_ALLOC_FAIL, /* Trace allocation fail */
- LTTCOMM_NO_SESSION, /* No session found */
- LTTCOMM_CREATE_FAIL, /* Create trace fail */
- LTTCOMM_SESSION_FAIL, /* Create session fail */
- LTTCOMM_START_FAIL, /* Start tracing fail */
- LTTCOMM_STOP_FAIL, /* Stop tracing fail */
- LTTCOMM_LIST_FAIL, /* Listing apps fail */
- LTTCOMM_NO_APPS, /* No traceable application */
- LTTCOMM_SESS_NOT_FOUND, /* Session name not found */
- LTTCOMM_NO_TRACE, /* No trace exist */
- LTTCOMM_FATAL, /* Session daemon had a fatal error */
- LTTCOMM_NO_TRACEABLE, /* Error for non traceable app */
- LTTCOMM_SELECT_SESS, /* Must select a session */
- LTTCOMM_EXIST_SESS, /* Session name already exist */
- LTTCOMM_NO_EVENT, /* No event found */
- LTTCOMM_KERN_NA, /* Kernel tracer unavalable */
- LTTCOMM_KERN_EVENT_EXIST, /* Kernel event already exists */
- LTTCOMM_KERN_SESS_FAIL, /* Kernel create session failed */
- LTTCOMM_KERN_CHAN_FAIL, /* Kernel create channel failed */
- LTTCOMM_KERN_CHAN_NOT_FOUND, /* Kernel channel not found */
- LTTCOMM_KERN_CHAN_DISABLE_FAIL, /* Kernel disable channel failed */
- LTTCOMM_KERN_CHAN_ENABLE_FAIL, /* Kernel enable channel failed */
- LTTCOMM_KERN_CONTEXT_FAIL, /* Kernel add context failed */
- LTTCOMM_KERN_ENABLE_FAIL, /* Kernel enable event failed */
- LTTCOMM_KERN_DISABLE_FAIL, /* Kernel disable event failed */
- LTTCOMM_KERN_META_FAIL, /* Kernel open metadata failed */
- LTTCOMM_KERN_START_FAIL, /* Kernel start trace failed */
- LTTCOMM_KERN_STOP_FAIL, /* Kernel stop trace failed */
- LTTCOMM_KERN_CONSUMER_FAIL, /* Kernel consumer start failed */
- LTTCOMM_KERN_STREAM_FAIL, /* Kernel create stream failed */
- LTTCOMM_KERN_DIR_FAIL, /* Kernel trace directory creation failed */
- LTTCOMM_KERN_DIR_EXIST, /* Kernel trace directory exist */
- LTTCOMM_KERN_NO_SESSION, /* No kernel session found */
- LTTCOMM_KERN_LIST_FAIL, /* Kernel listing events failed */
- KCONSUMERD_COMMAND_SOCK_READY, /* when kconsumerd command socket ready */
- KCONSUMERD_SUCCESS_RECV_FD, /* success on receiving fds */
- KCONSUMERD_ERROR_RECV_FD, /* error on receiving fds */
- KCONSUMERD_POLL_ERROR, /* Error in polling thread in kconsumerd */
- KCONSUMERD_POLL_NVAL, /* Poll on closed fd */
- KCONSUMERD_POLL_HUP, /* All fds have hungup */
- KCONSUMERD_EXIT_SUCCESS, /* kconsumerd exiting normally */
- KCONSUMERD_EXIT_FAILURE, /* kconsumerd exiting on error */
- KCONSUMERD_OUTFD_ERROR, /* error opening the tracefile */
- KCONSUMERD_SPLICE_EBADF, /* EBADF from splice(2) */
- KCONSUMERD_SPLICE_EINVAL, /* EINVAL from splice(2) */
- KCONSUMERD_SPLICE_ENOMEM, /* ENOMEM from splice(2) */
- KCONSUMERD_SPLICE_ESPIPE, /* ESPIPE from splice(2) */
+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 */
- LTTCOMM_NR, /* Last element */
+ USTCOMM_NR, /* Last element */
};
/*
* Data structure for the commands sent from sessiond to UST.
*/
-struct lttcomm_ust_msg {
+struct ustcomm_ust_msg {
uint32_t handle;
uint32_t cmd;
union {
- struct lttng_ust_tracer_version version;
struct lttng_ust_channel channel;
struct lttng_ust_stream stream;
struct lttng_ust_event event;
struct lttng_ust_context context;
+ struct lttng_ust_tracer_version version;
} u;
};
* Data structure for the response from UST to the session daemon.
* cmd_type is sent back in the reply for validation.
*/
-struct lttcomm_ust_reply {
+struct ustcomm_ust_reply {
uint32_t handle;
uint32_t cmd;
- uint32_t ret_code; /* enum enum lttcomm_return_code */
+ uint32_t ret_code; /* enum enum ustcomm_return_code */
uint32_t ret_val; /* return value */
union {
struct {
struct {
uint64_t memory_map_size;
} stream;
+ struct lttng_ust_tracer_version version;
} u;
};
-extern int lttcomm_create_unix_sock(const char *pathname);
-extern int lttcomm_connect_unix_sock(const char *pathname);
-extern int lttcomm_accept_unix_sock(int sock);
-extern int lttcomm_listen_unix_sock(int sock);
-extern int lttcomm_close_unix_sock(int sock);
+extern int ustcomm_create_unix_sock(const char *pathname);
+extern int ustcomm_connect_unix_sock(const char *pathname);
+extern int ustcomm_accept_unix_sock(int sock);
+extern int ustcomm_listen_unix_sock(int sock);
+extern int ustcomm_close_unix_sock(int sock);
/* Send fd(s) over a unix socket. */
-extern ssize_t lttcomm_send_fds_unix_sock(int sock, void *buf, int *fds,
+extern ssize_t ustcomm_send_fds_unix_sock(int sock, void *buf, int *fds,
size_t nb_fd, size_t len);
-extern ssize_t lttcomm_recv_unix_sock(int sock, void *buf, size_t len);
-extern ssize_t lttcomm_send_unix_sock(int sock, void *buf, size_t len);
-extern const char *lttcomm_get_readable_code(enum lttcomm_return_code code);
+extern ssize_t ustcomm_recv_unix_sock(int sock, void *buf, size_t len);
+extern ssize_t ustcomm_send_unix_sock(int sock, void *buf, size_t len);
+extern const char *ustcomm_get_readable_code(int code);
+extern int ustcomm_send_app_msg(int sock, struct ustcomm_ust_msg *lum);
+extern int ustcomm_recv_app_reply(int sock, struct ustcomm_ust_reply *lur,
+ uint32_t expected_handle, uint32_t expected_cmd);
+extern int ustcomm_send_app_cmd(int sock,
+ struct ustcomm_ust_msg *lum,
+ struct ustcomm_ust_reply *lur);
+int ustcomm_recv_fd(int sock);
#endif /* _LTTNG_UST_COMM_H */
#include <sys/un.h>
#include <unistd.h>
#include <assert.h>
+#include <errno.h>
#include <lttng-ust-comm.h>
/*
* Human readable error message.
*/
-static const char *lttcomm_readable_code[] = {
- [ LTTCOMM_ERR_INDEX(LTTCOMM_OK) ] = "Success",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_ERR) ] = "Unknown error",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_UND) ] = "Undefined command",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NOT_IMPLEMENTED) ] = "Not implemented",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_UNKNOWN_DOMAIN) ] = "Unknown tracing domain",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_SESSION) ] = "No session found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_LIST_FAIL) ] = "Unable to list traceable apps",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_APPS) ] = "No traceable apps found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_SESS_NOT_FOUND) ] = "Session name not found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_TRACE) ] = "No trace found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_FATAL) ] = "Fatal error of the session daemon",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CREATE_FAIL) ] = "Create trace failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_START_FAIL) ] = "Start trace failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_STOP_FAIL) ] = "Stop trace failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_TRACEABLE) ] = "App is not traceable",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_SELECT_SESS) ] = "A session MUST be selected",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_EXIST_SESS) ] = "Session name already exist",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_NA) ] = "Kernel tracer not available",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_EVENT_EXIST) ] = "Kernel event already exists",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_SESS_FAIL) ] = "Kernel create session failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CHAN_FAIL) ] = "Kernel create channel failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CHAN_NOT_FOUND) ] = "Kernel channel not found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CHAN_DISABLE_FAIL) ] = "Disable kernel channel failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CHAN_ENABLE_FAIL) ] = "Enable kernel channel failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CONTEXT_FAIL) ] = "Add kernel context failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_ENABLE_FAIL) ] = "Enable kernel event failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_DISABLE_FAIL) ] = "Disable kernel event failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_META_FAIL) ] = "Opening metadata failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_START_FAIL) ] = "Starting kernel trace failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_STOP_FAIL) ] = "Stoping kernel trace failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_CONSUMER_FAIL) ] = "Kernel consumer start failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_STREAM_FAIL) ] = "Kernel create stream failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_DIR_FAIL) ] = "Kernel trace directory creation failed",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_DIR_EXIST) ] = "Kernel trace directory already exist",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_NO_SESSION) ] = "No kernel session found",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_KERN_LIST_FAIL) ] = "Listing kernel events failed",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_COMMAND_SOCK_READY) ] = "Kconsumerd command socket ready",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_SUCCESS_RECV_FD) ] = "Kconsumerd success on receiving fds",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_ERROR_RECV_FD) ] = "Kconsumerd error on receiving fds",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_POLL_ERROR) ] = "Kconsumerd error in polling thread",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_POLL_NVAL) ] = "Kconsumerd polling on closed fd",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_POLL_HUP) ] = "Kconsumerd all fd hung up",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_EXIT_SUCCESS) ] = "Kconsumerd exiting normally",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_EXIT_FAILURE) ] = "Kconsumerd exiting on error",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_OUTFD_ERROR) ] = "Kconsumerd error opening the tracefile",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_SPLICE_EBADF) ] = "Kconsumerd splice EBADF",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_SPLICE_EINVAL) ] = "Kconsumerd splice EINVAL",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_SPLICE_ENOMEM) ] = "Kconsumerd splice ENOMEM",
- [ LTTCOMM_ERR_INDEX(KCONSUMERD_SPLICE_ESPIPE) ] = "Kconsumerd splice ESPIPE",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_EVENT) ] = "Event not found",
+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",
};
/*
* lttcom_get_readable_code
*
* Return ptr to string representing a human readable
- * error code from the lttcomm_return_code enum.
- *
- * These code MUST be negative in other to treat that
- * as an error value.
+ * error code from the ustcomm_return_code enum.
*/
-const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
+const char *ustcomm_get_readable_code(int code)
{
- int tmp_code = -code;
-
- if (tmp_code >= LTTCOMM_OK && tmp_code < LTTCOMM_NR) {
- return lttcomm_readable_code[LTTCOMM_ERR_INDEX(tmp_code)];
+ if (code == USTCOMM_OK) {
+ return "Success";
}
-
- return "Unknown error code";
+ if (code >= USTCOMM_ERR && code < USTCOMM_NR) {
+ return ustcomm_readable_code[USTCOMM_ERR_INDEX(code)];
+ }
+ return strerror(code);
}
/*
- * lttcomm_connect_unix_sock
+ * ustcomm_connect_unix_sock
*
* Connect to unix socket using the path name.
*/
-int lttcomm_connect_unix_sock(const char *pathname)
+int ustcomm_connect_unix_sock(const char *pathname)
{
struct sockaddr_un sun;
int fd;
}
/*
- * lttcomm_accept_unix_sock
+ * ustcomm_accept_unix_sock
*
* Do an accept(2) on the sock and return the
* new file descriptor. The socket MUST be bind(2) before.
*/
-int lttcomm_accept_unix_sock(int sock)
+int ustcomm_accept_unix_sock(int sock)
{
int new_fd;
struct sockaddr_un sun;
}
/*
- * lttcomm_create_unix_sock
+ * ustcomm_create_unix_sock
*
* Creates a AF_UNIX local socket using pathname
* bind the socket upon creation and return the fd.
*/
-int lttcomm_create_unix_sock(const char *pathname)
+int ustcomm_create_unix_sock(const char *pathname)
{
struct sockaddr_un sun;
int fd;
}
/*
- * lttcomm_listen_unix_sock
+ * ustcomm_listen_unix_sock
*
* Make the socket listen using MAX_LISTEN.
*/
-int lttcomm_listen_unix_sock(int sock)
+int ustcomm_listen_unix_sock(int sock)
{
int ret;
}
/*
- * lttcomm_recv_unix_sock
+ * ustcomm_recv_unix_sock
*
* Receive data of size len in put that data into
* the buf param. Using recvmsg API.
* Return the size of received data.
*/
-ssize_t lttcomm_recv_unix_sock(int sock, void *buf, size_t len)
+ssize_t ustcomm_recv_unix_sock(int sock, void *buf, size_t len)
{
struct msghdr msg = { 0 };
struct iovec iov[1];
}
/*
- * lttcomm_send_unix_sock
+ * ustcomm_send_unix_sock
*
* Send buf data of size len. Using sendmsg API.
* Return the size of sent data.
*/
-ssize_t lttcomm_send_unix_sock(int sock, void *buf, size_t len)
+ssize_t ustcomm_send_unix_sock(int sock, void *buf, size_t len)
{
struct msghdr msg = { 0 };
struct iovec iov[1];
}
/*
- * lttcomm_close_unix_sock
+ * ustcomm_close_unix_sock
*
* Shutdown cleanly a unix socket.
*/
-int lttcomm_close_unix_sock(int sock)
+int ustcomm_close_unix_sock(int sock)
{
int ret;
}
/*
- * lttcomm_send_fds_unix_sock
+ * ustcomm_send_fds_unix_sock
*
* Send multiple fds on a unix socket.
*/
-ssize_t lttcomm_send_fds_unix_sock(int sock, void *buf, int *fds, size_t nb_fd, size_t len)
+ssize_t ustcomm_send_fds_unix_sock(int sock, void *buf, int *fds, size_t nb_fd, size_t len)
{
struct msghdr msg = { 0 };
struct cmsghdr *cmptr;
return ret;
}
+
+int ustcomm_send_app_msg(int sock, struct ustcomm_ust_msg *lum)
+{
+ ssize_t len;
+
+ len = ustcomm_send_unix_sock(sock, lum, sizeof(*lum));
+ switch (len) {
+ case sizeof(*lum):
+ printf("message successfully sent\n");
+ break;
+ case -1:
+ if (errno == ECONNRESET) {
+ printf("remote end closed connection\n");
+ return 0;
+ }
+ return -1;
+ default:
+ printf("incorrect message size: %zd\n", len);
+ return -1;
+ }
+ return 0;
+}
+
+int ustcomm_recv_app_reply(int sock, struct ustcomm_ust_reply *lur,
+ uint32_t expected_handle, uint32_t expected_cmd)
+{
+ ssize_t len;
+
+ memset(lur, 0, sizeof(*lur));
+ len = ustcomm_recv_unix_sock(sock, lur, sizeof(*lur));
+ switch (len) {
+ case 0: /* orderly shutdown */
+ printf("Application has performed an orderly shutdown\n");
+ return -EINVAL;
+ case sizeof(*lur):
+ printf("result message received\n");
+ if (lur->handle != expected_handle) {
+ printf("Unexpected result message handle\n");
+ return -EINVAL;
+ }
+
+ if (lur->cmd != expected_cmd) {
+ printf("Unexpected result message command\n");
+ return -EINVAL;
+ }
+ if (lur->ret_code != USTCOMM_OK) {
+ printf("remote operation failed with code %d.\n",
+ lur->ret_code);
+ return lur->ret_code;
+ }
+ return 0;
+ case -1:
+ if (errno == ECONNRESET) {
+ printf("remote end closed connection\n");
+ return -EINVAL;
+ }
+ return -1;
+ default:
+ printf("incorrect message size: %zd\n", len);
+ return len > 0 ? -1 : len;
+ }
+}
+
+int ustcomm_send_app_cmd(int sock,
+ struct ustcomm_ust_msg *lum,
+ struct ustcomm_ust_reply *lur)
+{
+ int ret;
+
+ 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;
+}
+
+
+/*
+ * Receives a single fd from socket.
+ *
+ * Returns the size of received data
+ */
+int ustcomm_recv_fd(int sock)
+{
+ struct iovec iov[1];
+ int ret = 0;
+ int data_fd;
+ struct cmsghdr *cmsg;
+ char recv_fd[CMSG_SPACE(sizeof(int))];
+ struct msghdr msg = { 0 };
+ union {
+ unsigned char vc[4];
+ int vi;
+ } tmp;
+ int i;
+
+ /* Prepare to receive the structures */
+ iov[0].iov_base = &data_fd;
+ iov[0].iov_len = sizeof(data_fd);
+ msg.msg_iov = iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = recv_fd;
+ msg.msg_controllen = sizeof(recv_fd);
+
+ printf("Waiting to receive fd\n");
+ if ((ret = recvmsg(sock, &msg, 0)) < 0) {
+ perror("recvmsg");
+ goto end;
+ }
+ if (ret != sizeof(data_fd)) {
+ printf("Received %d bytes, expected %ld", ret, sizeof(data_fd));
+ goto end;
+ }
+ cmsg = CMSG_FIRSTHDR(&msg);
+ if (!cmsg) {
+ printf("Invalid control message header\n");
+ ret = -1;
+ goto end;
+ }
+ if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
+ printf("Didn't received any fd\n");
+ ret = -1;
+ goto end;
+ }
+ /* this is our fd */
+ for (i = 0; i < sizeof(int); i++)
+ tmp.vc[i] = CMSG_DATA(cmsg)[i];
+ ret = tmp.vi;
+ printf("received fd %d\n", ret);
+end:
+ return ret;
+}
shmobj = shm_object_table_append(handle->table, shmsize);
if (!shmobj)
goto error_append;
+ /* struct channel is at object 0, offset 0 (hardcoded) */
set_shmp(handle->chan, zalloc_shm(shmobj, sizeof(struct channel)));
+ assert(handle->chan._ref.index == 0);
+ assert(handle->chan._ref.offset == 0);
chan = shmp(handle, handle->chan);
if (!chan)
goto error_append;
shm_fd, wait_fd, memory_map_size);
if (!object)
goto error_table_object;
-
+ /* struct channel is at object 0, offset 0 (hardcoded) */
+ handle->chan._ref.index = 0;
+ handle->chan._ref.offset = 0;
return handle;
error_table_object:
return -errno;
}
- ret = lttcomm_send_unix_sock(socket, ®_msg, sizeof(reg_msg));
+ ret = ustcomm_send_unix_sock(socket, ®_msg, sizeof(reg_msg));
if (ret >= 0 && ret != sizeof(reg_msg))
return -EIO;
return ret;
}
static
-int send_reply(int sock, struct lttcomm_ust_reply *lur)
+int send_reply(int sock, struct ustcomm_ust_reply *lur)
{
ssize_t len;
- len = lttcomm_send_unix_sock(sock, lur, sizeof(*lur));
+ len = ustcomm_send_unix_sock(sock, lur, sizeof(*lur));
switch (len) {
case sizeof(*lur):
DBG("message successfully sent");
static
int handle_message(struct sock_info *sock_info,
- int sock, struct lttcomm_ust_msg *lum)
+ int sock, struct ustcomm_ust_msg *lum)
{
int ret = 0;
const struct objd_ops *ops;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_reply lur;
int shm_fd, wait_fd;
ust_lock();
lur.cmd = lum->cmd;
lur.ret_val = ret;
if (ret >= 0) {
- lur.ret_code = LTTCOMM_OK;
+ lur.ret_code = USTCOMM_OK;
} else {
- //lur.ret_code = LTTCOMM_SESSION_FAIL;
+ //lur.ret_code = USTCOMM_SESSION_FAIL;
lur.ret_code = ret;
}
switch (lum->cmd) {
shm_fd = lum->u.channel.shm_fd;
wait_fd = lum->u.channel.wait_fd;
break;
+ case LTTNG_UST_VERSION:
+ lur.u.version = lum->u.version;
+ break;
}
ret = send_reply(sock, &lur);
if (ret < 0) {
if ((lum->cmd == LTTNG_UST_STREAM
|| lum->cmd == LTTNG_UST_CHANNEL
|| lum->cmd == LTTNG_UST_METADATA)
- && lur.ret_code == LTTCOMM_OK) {
+ && lur.ret_code == USTCOMM_OK) {
/* we also need to send the file descriptors. */
- ret = lttcomm_send_fds_unix_sock(sock,
+ ret = ustcomm_send_fds_unix_sock(sock,
&shm_fd, &shm_fd,
1, sizeof(int));
if (ret < 0) {
perror("send shm_fd");
goto error;
}
- ret = lttcomm_send_fds_unix_sock(sock,
+ ret = ustcomm_send_fds_unix_sock(sock,
&wait_fd, &wait_fd,
1, sizeof(int));
if (ret < 0) {
}
/* Register */
- ret = lttcomm_connect_unix_sock(sock_info->sock_path);
+ ret = ustcomm_connect_unix_sock(sock_info->sock_path);
if (ret < 0) {
ERR("Error connecting to %s apps socket", sock_info->name);
prev_connect_failed = 1;
for (;;) {
ssize_t len;
- struct lttcomm_ust_msg lum;
+ struct ustcomm_ust_msg lum;
- len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum));
+ 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);
--- /dev/null
+AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/liblttng-ust-comm
+AM_CFLAGS = -fno-strict-aliasing
+
+lib_LTLIBRARIES = libustctl.la
+
+libustctl_la_SOURCES = ustctl.c
+
+libustctl_la_LIBADD = $(top_builddir)/liblttng-ust-comm/liblttng-ust-comm.la \
+ $(top_builddir)/libringbuffer/libringbuffer.la
--- /dev/null
+/*
+ * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
+ * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; only version 2
+ * of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <ust/lttng-ust-ctl.h>
+#include <ust/lttng-ust-abi.h>
+#include <ust/usterr-signal-safe.h>
+#include "lttng-ust-comm.h"
+
+#include "../libringbuffer/backend.h"
+#include "../libringbuffer/frontend.h"
+
+static
+void init_object(struct object_data *data)
+{
+ data->handle = -1;
+ data->shm_fd = -1;
+ data->wait_fd = -1;
+ data->memory_map_size = 0;
+}
+
+void release_object(int sock, struct object_data *data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret;
+
+ if (data->shm_fd >= 0)
+ close(data->shm_fd);
+ if (data->wait_fd >= 0)
+ close(data->wait_fd);
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = data->handle;
+ lum.cmd = LTTNG_UST_RELEASE;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ assert(!ret);
+ free(data);
+}
+
+/*
+ * returns session handle.
+ */
+int ustctl_create_session(int sock)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret, session_handle;
+
+ /* Create session */
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = LTTNG_UST_ROOT_HANDLE;
+ lum.cmd = LTTNG_UST_SESSION;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret)
+ return ret;
+ session_handle = lur.ret_val;
+ DBG("received session handle %u", session_handle);
+ return session_handle;
+}
+
+/* open the metadata global channel */
+int ustctl_open_metadata(int sock, int session_handle,
+ struct lttng_ust_channel_attr *chops,
+ struct object_data **_metadata_data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ struct object_data *metadata_data;
+ int ret;
+
+ metadata_data = malloc(sizeof(*metadata_data));
+ if (!metadata_data)
+ return -ENOMEM;
+ init_object(metadata_data);
+ /* Create metadata channel */
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = session_handle;
+ lum.cmd = LTTNG_UST_METADATA;
+ lum.u.channel.overwrite = chops->overwrite;
+ lum.u.channel.subbuf_size = chops->subbuf_size;
+ lum.u.channel.num_subbuf = chops->num_subbuf;
+ lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
+ lum.u.channel.read_timer_interval = chops->read_timer_interval;
+ lum.u.channel.output = chops->output;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret) {
+ 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)
+ goto error;
+ metadata_data->shm_fd = ret;
+ /* get wait fd */
+ ret = ustcomm_recv_fd(sock);
+ if (ret < 0)
+ goto error;
+ metadata_data->wait_fd = ret;
+ *_metadata_data = metadata_data;
+ return 0;
+
+error:
+ release_object(sock, metadata_data);
+ return -EINVAL;
+}
+
+int ustctl_create_channel(int sock, int session_handle,
+ struct lttng_ust_channel_attr *chops,
+ struct object_data **_channel_data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ struct object_data *channel_data;
+ int ret;
+
+ channel_data = malloc(sizeof(*channel_data));
+ if (!channel_data)
+ return -ENOMEM;
+ init_object(channel_data);
+ /* Create metadata channel */
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = session_handle;
+ lum.cmd = LTTNG_UST_CHANNEL;
+ lum.u.channel.overwrite = chops->overwrite;
+ lum.u.channel.subbuf_size = chops->subbuf_size;
+ lum.u.channel.num_subbuf = chops->num_subbuf;
+ lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
+ lum.u.channel.read_timer_interval = chops->read_timer_interval;
+ lum.u.channel.output = chops->output;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret) {
+ 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)
+ goto error;
+ channel_data->shm_fd = ret;
+ /* get wait fd */
+ ret = ustcomm_recv_fd(sock);
+ if (ret < 0)
+ goto error;
+ channel_data->wait_fd = ret;
+ *_channel_data = channel_data;
+ return 0;
+
+error:
+ release_object(sock, channel_data);
+ return -EINVAL;
+}
+
+/*
+ * Return -ENOENT if no more stream is available for creation.
+ * Return 0 on success.
+ * Return negative error value on error.
+ */
+int ustctl_create_stream(int sock, struct object_data *channel_data,
+ struct object_data **_stream_data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ struct object_data *stream_data;
+ int ret, fd;
+
+ stream_data = malloc(sizeof(*stream_data));
+ if (!stream_data)
+ return -ENOMEM;
+ init_object(stream_data);
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = channel_data->handle;
+ lum.cmd = LTTNG_UST_STREAM;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret) {
+ 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)
+ goto error;
+ stream_data->shm_fd = fd;
+ /* get wait fd */
+ fd = ustcomm_recv_fd(sock);
+ if (fd < 0)
+ goto error;
+ stream_data->wait_fd = fd;
+ *_stream_data = stream_data;
+ return ret;
+
+error:
+ release_object(sock, stream_data);
+ return -EINVAL;
+}
+
+int ustctl_create_event(int sock, struct lttng_ust_event *ev,
+ struct object_data *channel_data,
+ struct object_data **_event_data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ struct object_data *event_data;
+ int ret;
+
+ event_data = malloc(sizeof(*event_data));
+ if (!event_data)
+ return -ENOMEM;
+ init_object(event_data);
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = channel_data->handle;
+ lum.cmd = LTTNG_UST_EVENT;
+ strncpy(lum.u.event.name, ev->name,
+ LTTNG_UST_SYM_NAME_LEN);
+ lum.u.event.instrumentation = ev->instrumentation;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret) {
+ free(event_data);
+ return ret;
+ }
+ event_data->handle = lur.ret_val;
+ DBG("received event handle %u", event_data->handle);
+ *_event_data = event_data;
+ return 0;
+}
+
+int ustctl_add_context(int sock, struct lttng_ust_context *ctx,
+ struct object_data *channel_data,
+ struct object_data **_context_data)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ struct object_data *context_data;
+ int ret;
+
+ context_data = malloc(sizeof(*context_data));
+ if (!context_data)
+ return -ENOMEM;
+ init_object(context_data);
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = channel_data->handle;
+ lum.cmd = LTTNG_UST_CONTEXT;
+ lum.u.context.ctx = ctx->ctx;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret) {
+ free(context_data);
+ return ret;
+ }
+ context_data->handle = lur.ret_val;
+ DBG("received context handle %u", context_data->handle);
+ *_context_data = context_data;
+ return ret;
+}
+
+/* Enable event, channel and session ioctl */
+int ustctl_enable(int sock, struct object_data *object)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret;
+
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = object->handle;
+ lum.cmd = LTTNG_UST_ENABLE;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret)
+ return ret;
+ DBG("enabled handle %u", object->handle);
+ return 0;
+}
+
+/* Disable event, channel and session ioctl */
+int ustctl_disable(int sock, struct object_data *object)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret;
+
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = object->handle;
+ lum.cmd = LTTNG_UST_DISABLE;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret)
+ return ret;
+ DBG("disable handle %u", object->handle);
+ return 0;
+}
+
+int ustctl_start_session(int sock, struct object_data *object)
+{
+ return ustctl_enable(sock, object);
+}
+
+int ustctl_stop_session(int sock, struct object_data *object)
+{
+ return ustctl_disable(sock, object);
+}
+
+
+int ustctl_tracepoint_list(int sock)
+{
+ return -ENOSYS; /* not implemented */
+}
+
+int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret;
+
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = LTTNG_UST_ROOT_HANDLE;
+ lum.cmd = LTTNG_UST_TRACER_VERSION;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret)
+ return ret;
+ memcpy(v, &lur.u.version, sizeof(*v));
+ DBG("received tracer version");
+ return 0;
+}
+
+int ustctl_wait_quiescent(int sock)
+{
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
+ int ret;
+
+ memset(&lum, 0, sizeof(lum));
+ lum.handle = LTTNG_UST_ROOT_HANDLE;
+ lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
+ if (ret)
+ return ret;
+ DBG("waited for quiescent state");
+ return 0;
+}
+
+int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
+{
+ return -ENOSYS;
+}
+
+/* Buffer operations */
+
+/* Map channel shm into process memory */
+struct shm_handle *ustctl_map_channel(struct object_data *chan_data)
+{
+ struct shm_handle *handle;
+ struct channel *chan;
+ size_t chan_size;
+
+ handle = channel_handle_create(chan_data->shm_fd,
+ chan_data->wait_fd,
+ chan_data->memory_map_size);
+ if (!handle) {
+ ERR("create handle error");
+ return NULL;
+ }
+ /*
+ * Set to -1 because the shm_handle destruction will take care
+ * of closing shm_fd and wait_fd.
+ */
+ chan_data->shm_fd = -1;
+ chan_data->wait_fd = -1;
+
+ /*
+ * TODO: add consistency checks to be resilient if the
+ * application try to feed us with incoherent channel structure
+ * values.
+ */
+ chan = shmp(handle, handle->chan);
+ /* chan is object 0. This is hardcoded. */
+ chan_size = handle->table->objects[0].allocated_len;
+ handle->shadow_chan = malloc(chan_size);
+ if (!handle->shadow_chan) {
+ channel_destroy(chan, handle, 1);
+ return NULL;
+ }
+ memcpy(handle->shadow_chan, chan, chan_size);
+ return handle;
+}
+
+/* Add stream to channel shm and map its shm into process memory */
+int ustctl_add_stream(struct shm_handle *handle,
+ struct object_data *stream_data)
+{
+ int ret;
+
+ if (!stream_data->handle)
+ return -ENOENT;
+ /* map stream */
+ ret = channel_handle_add_stream(handle,
+ stream_data->shm_fd,
+ stream_data->wait_fd,
+ stream_data->memory_map_size);
+ if (ret) {
+ ERR("add stream error\n");
+ return ret;
+ }
+ /*
+ * Set to -1 because the shm_handle destruction will take care
+ * of closing shm_fd and wait_fd.
+ */
+ stream_data->shm_fd = -1;
+ stream_data->wait_fd = -1;
+ return 0;
+}
+
+/* For mmap mode, readable without "get" operation */
+
+/* returns the length to mmap. */
+int ustctl_get_mmap_len(struct shm_handle *handle,
+ struct lib_ring_buffer *buf,
+ unsigned long *len)
+{
+ unsigned long mmap_buf_len;
+ struct channel *chan = handle->shadow_chan;
+
+ if (chan->backend.config.output != RING_BUFFER_MMAP)
+ return -EINVAL;
+ mmap_buf_len = chan->backend.buf_size;
+ if (chan->backend.extra_reader_sb)
+ mmap_buf_len += chan->backend.subbuf_size;
+ if (mmap_buf_len > INT_MAX)
+ return -EFBIG;
+ *len = mmap_buf_len;
+ return 0;
+}
+
+/* returns the maximum size for sub-buffers. */
+int ustctl_get_max_subbuf_size(struct shm_handle *handle,
+ struct lib_ring_buffer *buf,
+ unsigned long *len)
+{
+ struct channel *chan = handle->shadow_chan;
+
+ *len = chan->backend.subbuf_size;
+ return 0;
+}
+
+/*
+ * For mmap mode, operate on the current packet (between get/put or
+ * get_next/put_next).
+ */
+
+/* returns the offset of the subbuffer belonging to the mmap reader. */
+int ustctl_get_mmap_read_offset(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *off)
+{
+ struct channel *chan = handle->shadow_chan;
+ unsigned long sb_bindex;
+
+ if (chan->backend.config.output != RING_BUFFER_MMAP)
+ return -EINVAL;
+ sb_bindex = subbuffer_id_get_index(&chan->backend.config,
+ buf->backend.buf_rsb.id);
+ *off = shmp(handle, shmp_index(handle, buf->backend.array, sb_bindex)->shmp)->mmap_offset;
+ return 0;
+}
+
+/* returns the size of the current sub-buffer, without padding (for mmap). */
+int ustctl_get_subbuf_size(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *len)
+{
+ struct channel *chan = handle->shadow_chan;
+
+ *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
+ handle);
+ return 0;
+}
+
+/* returns the size of the current sub-buffer, without padding (for mmap). */
+int ustctl_get_padded_subbuf_size(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *len)
+{
+ struct channel *chan = handle->shadow_chan;
+
+ *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
+ handle);
+ *len = PAGE_ALIGN(*len);
+ return 0;
+}
+
+/* Get exclusive read access to the next sub-buffer that can be read. */
+int ustctl_get_next_subbuf(struct shm_handle *handle,
+ struct lib_ring_buffer *buf)
+{
+ return lib_ring_buffer_get_next_subbuf(buf, handle);
+}
+
+
+/* Release exclusive sub-buffer access, move consumer forward. */
+int ustctl_put_next_subbuf(struct shm_handle *handle,
+ struct lib_ring_buffer *buf)
+{
+ lib_ring_buffer_put_next_subbuf(buf, handle);
+ return 0;
+}
+
+/* snapshot */
+
+/* Get a snapshot of the current ring buffer producer and consumer positions */
+int ustctl_snapshot(struct shm_handle *handle,
+ struct lib_ring_buffer *buf)
+{
+ return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
+ &buf->prod_snapshot, handle);
+}
+
+/* Get the consumer position (iteration start) */
+int ustctl_snapshot_get_consumed(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *pos)
+{
+ *pos = buf->cons_snapshot;
+ return 0;
+}
+
+/* Get the producer position (iteration end) */
+int ustctl_snapshot_get_produced(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *pos)
+{
+ *pos = buf->prod_snapshot;
+ return 0;
+}
+
+/* Get exclusive read access to the specified sub-buffer position */
+int ustctl_get_subbuf(struct shm_handle *handle,
+ struct lib_ring_buffer *buf, unsigned long *pos)
+{
+ return lib_ring_buffer_get_subbuf(buf, *pos, handle);
+}
+
+/* Release exclusive sub-buffer access */
+int ustctl_put_subbuf(struct shm_handle *handle,
+ struct lib_ring_buffer *buf)
+{
+ lib_ring_buffer_put_subbuf(buf, handle);
+ return 0;
+}
+
+int ustctl_buffer_flush(struct shm_handle *handle,
+ struct lib_ring_buffer *buf)
+{
+ lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle);
+ return 0;
+}
quit_program = 1;
}
-static int send_app_msg(int sock, struct lttcomm_ust_msg *lum)
-{
- ssize_t len;
-
- len = lttcomm_send_unix_sock(sock, lum, sizeof(*lum));
- switch (len) {
- case sizeof(*lum):
- printf("message successfully sent\n");
- break;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
- return 0;
- }
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return -1;
- }
- return 0;
-}
-
-static int recv_app_reply(int sock, struct lttcomm_ust_reply *lur,
- uint32_t expected_handle, uint32_t expected_cmd)
-{
- ssize_t len;
-
- memset(lur, 0, sizeof(*lur));
- len = lttcomm_recv_unix_sock(sock, lur, sizeof(*lur));
- switch (len) {
- case 0: /* orderly shutdown */
- printf("Application has performed an orderly shutdown\n");
- return -EINVAL;
- case sizeof(*lur):
- printf("result message received\n");
- if (lur->handle != expected_handle) {
- printf("Unexpected result message handle\n");
- return -EINVAL;
- }
-
- if (lur->cmd != expected_cmd) {
- printf("Unexpected result message command\n");
- return -EINVAL;
- }
- if (lur->ret_code != LTTCOMM_OK) {
- printf("remote operation failed with code %d.\n",
- lur->ret_code);
- return lur->ret_code;
- }
- return 0;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
- return -EINVAL;
- }
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return len > 0 ? -1 : len;
- }
-}
-
-static int send_app_cmd(int sock,
- struct lttcomm_ust_msg *lum,
- struct lttcomm_ust_reply *lur)
-{
- int ret;
-
- ret = send_app_msg(sock, lum);
- if (ret)
- return ret;
- ret = recv_app_reply(sock, lur, lum->handle, lum->cmd);
- if (ret)
- return ret;
- return 0;
-}
-
-
-/*
- * Receives a single fd from socket.
- *
- * Returns the size of received data
- */
-static int lttcomm_recv_fd(int sock)
-{
- struct iovec iov[1];
- int ret = 0;
- int data_fd;
- struct cmsghdr *cmsg;
- char recv_fd[CMSG_SPACE(sizeof(int))];
- struct msghdr msg = { 0 };
- union {
- unsigned char vc[4];
- int vi;
- } tmp;
- int i;
-
- /* Prepare to receive the structures */
- iov[0].iov_base = &data_fd;
- iov[0].iov_len = sizeof(data_fd);
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
- msg.msg_control = recv_fd;
- msg.msg_controllen = sizeof(recv_fd);
-
- printf("Waiting to receive fd\n");
- if ((ret = recvmsg(sock, &msg, 0)) < 0) {
- perror("recvmsg");
- goto end;
- }
- if (ret != sizeof(data_fd)) {
- printf("Received %d bytes, expected %ld", ret, sizeof(data_fd));
- goto end;
- }
- cmsg = CMSG_FIRSTHDR(&msg);
- if (!cmsg) {
- printf("Invalid control message header\n");
- ret = -1;
- goto end;
- }
- if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
- printf("Didn't received any fd\n");
- ret = -1;
- goto end;
- }
- /* this is our fd */
- for (i = 0; i < sizeof(int); i++)
- tmp.vc[i] = CMSG_DATA(cmsg)[i];
- ret = tmp.vi;
- printf("received fd %d\n", ret);
-end:
- return ret;
-}
-
-
static
int open_streams(int sock, int channel_handle, struct object_data *stream_datas,
int nr_check)
int ret, k = 0;
for (;;) {
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
memset(&lum, 0, sizeof(lum));
lum.handle = channel_handle;
lum.cmd = LTTNG_UST_STREAM;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (!ret) {
assert(k < nr_check);
stream_datas[k].handle = lur.ret_val;
printf("received stream handle %u\n",
stream_datas[k].handle);
- if (lur.ret_code == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
stream_datas[k].memory_map_size = lur.u.stream.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
stream_datas[k].shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
stream_datas[k].wait_fd = len;
int ret, k;
for (k = 0; k < nr_check; k++) {
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
if (!stream_datas[k].handle)
continue;
memset(&lum, 0, sizeof(lum));
lum.handle = stream_datas[k].handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret) {
printf("Error closing stream\n");
return ret;
return 0;
}
+static
int send_app_msgs(int sock, const char *outputpath,
unsigned int nr_events, const char **event_names)
{
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
int ret, k;
/* Create session */
memset(&lum, 0, sizeof(lum));
lum.handle = LTTNG_UST_ROOT_HANDLE;
lum.cmd = LTTNG_UST_SESSION;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
session_handle = lur.ret_val;
lum.u.channel.switch_timer_interval = 0;
lum.u.channel.read_timer_interval = 0;
lum.u.channel.output = LTTNG_UST_MMAP;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
metadata_data.handle = lur.ret_val;
printf("received metadata handle %u\n", metadata_data.handle);
- if (lur.ret_code == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
metadata_data.memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
metadata_data.shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
metadata_data.wait_fd = len;
lum.u.channel.switch_timer_interval = 0;
lum.u.channel.read_timer_interval = 0;
lum.u.channel.output = LTTNG_UST_MMAP;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
channel_data.handle = lur.ret_val;
printf("received channel handle %u\n", channel_data.handle);
- if (lur.ret_code == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
channel_data.memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
channel_data.shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
channel_data.wait_fd = len;
strncpy(lum.u.event.name, event_names[k],
LTTNG_UST_SYM_NAME_LEN);
lum.u.event.instrumentation = LTTNG_UST_TRACEPOINT;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
event_handle[k] = lur.ret_val;
//lum.u.context.ctx = LTTNG_UST_CONTEXT_PTHREAD_ID;
//lum.u.context.ctx = LTTNG_UST_CONTEXT_VPID;
//lum.u.context.ctx = LTTNG_UST_CONTEXT_PROCNAME;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
context_handle = lur.ret_val;
memset(&lum, 0, sizeof(lum));
lum.handle = session_handle;
lum.cmd = LTTNG_UST_SESSION_START;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
printf("Session handle %u started.\n", session_handle);
memset(&lum, 0, sizeof(lum));
lum.handle = LTTNG_UST_ROOT_HANDLE;
lum.cmd = LTTNG_UST_REGISTER_DONE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
printf("Registration done acknowledged.\n");
memset(&lum, 0, sizeof(lum));
lum.handle = context_handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
memset(&lum, 0, sizeof(lum));
lum.handle = event_handle[k];
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
}
memset(&lum, 0, sizeof(lum));
lum.handle = channel_data.handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
if (channel_data.shm_fd >= 0) {
memset(&lum, 0, sizeof(lum));
lum.handle = metadata_data.handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
if (metadata_data.shm_fd >= 0) {
memset(&lum, 0, sizeof(lum));
lum.handle = session_handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
}
- ret = lttcomm_create_unix_sock(apps_sock_path);
+ ret = ustcomm_create_unix_sock(apps_sock_path);
if (ret < 0) {
perror("create error");
return ret;
}
umask(old_umask);
}
- ret = lttcomm_listen_unix_sock(apps_socket);
+ ret = ustcomm_listen_unix_sock(apps_socket);
if (ret < 0) {
perror("listen error");
return ret;
break;
printf("Accepting application registration\n");
- sock = lttcomm_accept_unix_sock(apps_socket);
+ sock = ustcomm_accept_unix_sock(apps_socket);
if (sock < 0) {
perror("accept error");
goto end;
* Basic recv here to handle the very simple data
* that the libust send to register (reg_msg).
*/
- len = lttcomm_recv_unix_sock(sock, ®_msg, sizeof(reg_msg));
+ len = ustcomm_recv_unix_sock(sock, ®_msg, sizeof(reg_msg));
if (len < 0 || len != sizeof(reg_msg)) {
- perror("lttcomm_recv_unix_sock");
+ perror("ustcomm_recv_unix_sock");
continue;
}
memcpy(bufname, reg_msg.name, 16);
quit_program = 1;
}
-static int send_app_msg(int sock, struct lttcomm_ust_msg *lum)
-{
- ssize_t len;
-
- len = lttcomm_send_unix_sock(sock, lum, sizeof(*lum));
- switch (len) {
- case sizeof(*lum):
- printf("message successfully sent\n");
- break;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
- return 0;
- }
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return -1;
- }
- return 0;
-}
-
-static int recv_app_reply(int sock, struct lttcomm_ust_reply *lur,
- uint32_t expected_handle, uint32_t expected_cmd)
-{
- ssize_t len;
-
- memset(lur, 0, sizeof(*lur));
- len = lttcomm_recv_unix_sock(sock, lur, sizeof(*lur));
- switch (len) {
- case 0: /* orderly shutdown */
- printf("Application has performed an orderly shutdown\n");
- return -EINVAL;
- case sizeof(*lur):
- printf("result message received\n");
- if (lur->handle != expected_handle) {
- printf("Unexpected result message handle\n");
- return -EINVAL;
- }
-
- if (lur->cmd != expected_cmd) {
- printf("Unexpected result message command\n");
- return -EINVAL;
- }
- if (lur->ret_code != LTTCOMM_OK) {
- printf("remote operation failed with code %d.\n",
- lur->ret_code);
- return lur->ret_code;
- }
- return 0;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
- return -EINVAL;
- }
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return len > 0 ? -1 : len;
- }
-}
-
-static int send_app_cmd(int sock,
- struct lttcomm_ust_msg *lum,
- struct lttcomm_ust_reply *lur)
-{
- int ret;
-
- ret = send_app_msg(sock, lum);
- if (ret)
- return ret;
- ret = recv_app_reply(sock, lur, lum->handle, lum->cmd);
- if (ret)
- return ret;
- return 0;
-}
-
-
-/*
- * Receives a single fd from socket.
- *
- * Returns the size of received data
- */
-static int lttcomm_recv_fd(int sock)
-{
- struct iovec iov[1];
- int ret = 0;
- int data_fd;
- struct cmsghdr *cmsg;
- char recv_fd[CMSG_SPACE(sizeof(int))];
- struct msghdr msg = { 0 };
- union {
- unsigned char vc[4];
- int vi;
- } tmp;
- int i;
-
- /* Prepare to receive the structures */
- iov[0].iov_base = &data_fd;
- iov[0].iov_len = sizeof(data_fd);
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
- msg.msg_control = recv_fd;
- msg.msg_controllen = sizeof(recv_fd);
-
- printf("Waiting to receive fd\n");
- if ((ret = recvmsg(sock, &msg, 0)) < 0) {
- perror("recvmsg");
- goto end;
- }
- if (ret != sizeof(data_fd)) {
- printf("Received %d bytes, expected %ld", ret, sizeof(data_fd));
- goto end;
- }
- cmsg = CMSG_FIRSTHDR(&msg);
- if (!cmsg) {
- printf("Invalid control message header\n");
- ret = -1;
- goto end;
- }
- if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
- printf("Didn't received any fd\n");
- ret = -1;
- goto end;
- }
- /* this is our fd */
- for (i = 0; i < sizeof(int); i++)
- tmp.vc[i] = CMSG_DATA(cmsg)[i];
- ret = tmp.vi;
- printf("received fd %d\n", ret);
-end:
- return ret;
-}
-
-
static
int open_streams(int sock, int channel_handle, struct object_data *stream_datas,
int nr_check)
int ret, k = 0;
for (;;) {
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
memset(&lum, 0, sizeof(lum));
lum.handle = channel_handle;
lum.cmd = LTTNG_UST_STREAM;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (!ret) {
assert(k < nr_check);
stream_datas[k].handle = lur.ret_val;
printf("received stream handle %u\n",
stream_datas[k].handle);
- if (lur.ret_code == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
stream_datas[k].memory_map_size = lur.u.stream.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
stream_datas[k].shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
stream_datas[k].wait_fd = len;
int ret, k;
for (k = 0; k < nr_check; k++) {
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
if (!stream_datas[k].handle)
continue;
memset(&lum, 0, sizeof(lum));
lum.handle = stream_datas[k].handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret) {
printf("Error closing stream\n");
return ret;
int send_app_msgs(int sock)
{
- struct lttcomm_ust_msg lum;
- struct lttcomm_ust_reply lur;
+ struct ustcomm_ust_msg lum;
+ struct ustcomm_ust_reply lur;
int ret, i, j, k;
for (i = 0; i < NR_SESSIONS; i++) {
memset(&lum, 0, sizeof(lum));
lum.handle = LTTNG_UST_ROOT_HANDLE;
lum.cmd = LTTNG_UST_SESSION;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
session_handle[i] = lur.ret_val;
lum.u.channel.switch_timer_interval = 0;
lum.u.channel.read_timer_interval = 0;
lum.u.channel.output = LTTNG_UST_MMAP;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
metadata_data[i].handle = lur.ret_val;
printf("received metadata handle %u\n", metadata_data[i].handle);
- if (lur.ret_code == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
metadata_data[i].memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
metadata_data[i].shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
metadata_data[i].wait_fd = len;
lum.u.channel.switch_timer_interval = 0;
lum.u.channel.read_timer_interval = 0;
lum.u.channel.output = LTTNG_UST_MMAP;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
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 == LTTCOMM_OK) {
+ if (lur.ret_code == USTCOMM_OK) {
ssize_t len;
channel_data[i][j].memory_map_size = lur.u.channel.memory_map_size;
/* get shm fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
channel_data[i][j].shm_fd = len;
/* get wait fd */
- len = lttcomm_recv_fd(sock);
+ len = ustcomm_recv_fd(sock);
if (len < 0)
return -EINVAL;
channel_data[i][j].wait_fd = len;
strncpy(lum.u.event.name, evname[k],
LTTNG_UST_SYM_NAME_LEN);
lum.u.event.instrumentation = LTTNG_UST_TRACEPOINT;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
event_handle[i][j][k] = lur.ret_val;
memset(&lum, 0, sizeof(lum));
lum.handle = session_handle[i];
lum.cmd = LTTNG_UST_SESSION_START;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
printf("Session handle %u started.\n", session_handle[i]);
memset(&lum, 0, sizeof(lum));
lum.handle = LTTNG_UST_ROOT_HANDLE;
lum.cmd = LTTNG_UST_REGISTER_DONE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
printf("Registration done acknowledged.\n");
memset(&lum, 0, sizeof(lum));
lum.handle = event_handle[i][j][k];
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
}
memset(&lum, 0, sizeof(lum));
lum.handle = channel_data[i][j].handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
if (channel_data[i][j].shm_fd >= 0) {
memset(&lum, 0, sizeof(lum));
lum.handle = metadata_data[i].handle;
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
if (metadata_data[i].shm_fd >= 0) {
memset(&lum, 0, sizeof(lum));
lum.handle = session_handle[i];
lum.cmd = LTTNG_UST_RELEASE;
- ret = send_app_cmd(sock, &lum, &lur);
+ ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret)
return ret;
}
DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
}
- ret = lttcomm_create_unix_sock(apps_sock_path);
+ ret = ustcomm_create_unix_sock(apps_sock_path);
if (ret < 0) {
perror("create error");
return ret;
}
umask(old_umask);
}
- ret = lttcomm_listen_unix_sock(apps_socket);
+ ret = ustcomm_listen_unix_sock(apps_socket);
if (ret < 0) {
perror("listen error");
return ret;
break;
printf("Accepting application registration\n");
- sock = lttcomm_accept_unix_sock(apps_socket);
+ sock = ustcomm_accept_unix_sock(apps_socket);
if (sock < 0) {
perror("accept error");
goto end;
* Basic recv here to handle the very simple data
* that the libust send to register (reg_msg).
*/
- len = lttcomm_recv_unix_sock(sock, ®_msg, sizeof(reg_msg));
+ len = ustcomm_recv_unix_sock(sock, ®_msg, sizeof(reg_msg));
if (len < 0 || len != sizeof(reg_msg)) {
- perror("lttcomm_recv_unix_sock");
+ perror("ustcomm_recv_unix_sock");
continue;
}
memcpy(bufname, reg_msg.name, 16);
projects / ust.git / commitdiff
