2 * Copyright (C) 2013 Julien Desfossez <jdesfossez@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
13 #include <common/compat/time.h>
14 #include <sys/types.h>
17 #include <sys/socket.h>
18 #include <netinet/in.h>
25 #include <lttng/lttng.h>
26 #include <lttng/ust-sigbus.h>
28 #include <urcu/list.h>
29 #include <common/common.h>
31 #include <bin/lttng-relayd/lttng-viewer-abi.h>
32 #include <common/index/ctf-index.h>
34 #include <common/compat/errno.h>
35 #include <common/compat/endian.h>
37 #define SESSION1 "test1"
38 #define RELAYD_URL "net://localhost"
39 #define LIVE_TIMER 2000000
41 /* Number of TAP tests in this file */
43 #define mmap_size 524288
45 DEFINE_LTTNG_UST_SIGBUS_STATE();
47 static int control_sock
;
48 struct live_session
*session
;
50 static int first_packet_offset
;
51 static int first_packet_len
;
52 static int first_packet_stream_id
= -1;
54 struct viewer_stream
{
56 uint64_t ctf_trace_id
;
65 struct viewer_stream
*streams
;
66 uint64_t live_timer_interval
;
67 uint64_t stream_count
;
71 ssize_t
lttng_live_recv(int fd
, void *buf
, size_t len
)
74 size_t copied
= 0, to_copy
= len
;
77 ret
= recv(fd
, buf
+ copied
, to_copy
, 0);
79 assert(ret
<= to_copy
);
83 } while ((ret
> 0 && to_copy
> 0)
84 || (ret
< 0 && errno
== EINTR
));
87 /* ret = 0 means orderly shutdown, ret < 0 is error. */
92 ssize_t
lttng_live_send(int fd
, const void *buf
, size_t len
)
97 ret
= send(fd
, buf
, len
, MSG_NOSIGNAL
);
98 } while (ret
< 0 && errno
== EINTR
);
103 int connect_viewer(const char *hostname
)
105 struct hostent
*host
;
106 struct sockaddr_in server_addr
;
109 host
= gethostbyname(hostname
);
115 if ((control_sock
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1) {
121 server_addr
.sin_family
= AF_INET
;
122 server_addr
.sin_port
= htons(5344);
123 server_addr
.sin_addr
= *((struct in_addr
*) host
->h_addr
);
124 bzero(&(server_addr
.sin_zero
), 8);
126 if (connect(control_sock
, (struct sockaddr
*) &server_addr
,
127 sizeof(struct sockaddr
)) == -1) {
133 server_addr
.sin_family
= AF_INET
;
134 server_addr
.sin_port
= htons(5345);
135 server_addr
.sin_addr
= *((struct in_addr
*) host
->h_addr
);
136 bzero(&(server_addr
.sin_zero
), 8);
145 int establish_connection(void)
147 struct lttng_viewer_cmd cmd
;
148 struct lttng_viewer_connect connect
;
151 cmd
.cmd
= htobe32(LTTNG_VIEWER_CONNECT
);
152 cmd
.data_size
= htobe64(sizeof(connect
));
153 cmd
.cmd_version
= htobe32(0);
155 memset(&connect
, 0, sizeof(connect
));
156 connect
.major
= htobe32(VERSION_MAJOR
);
157 connect
.minor
= htobe32(VERSION_MINOR
);
158 connect
.type
= htobe32(LTTNG_VIEWER_CLIENT_COMMAND
);
160 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
162 diag("Error sending cmd");
165 ret_len
= lttng_live_send(control_sock
, &connect
, sizeof(connect
));
167 diag("Error sending version");
171 ret_len
= lttng_live_recv(control_sock
, &connect
, sizeof(connect
));
173 diag("[error] Remote side has closed connection");
177 diag("Error receiving version");
187 * Returns the number of sessions, should be 1 during the unit test.
190 int list_sessions(uint64_t *session_id
)
192 struct lttng_viewer_cmd cmd
;
193 struct lttng_viewer_list_sessions list
;
194 struct lttng_viewer_session lsession
;
197 int first_session
= 0;
199 cmd
.cmd
= htobe32(LTTNG_VIEWER_LIST_SESSIONS
);
200 cmd
.data_size
= htobe64(0);
201 cmd
.cmd_version
= htobe32(0);
203 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
205 diag("Error sending cmd");
209 ret_len
= lttng_live_recv(control_sock
, &list
, sizeof(list
));
211 diag("[error] Remote side has closed connection");
215 diag("Error receiving session list");
219 for (i
= 0; i
< be32toh(list
.sessions_count
); i
++) {
220 ret_len
= lttng_live_recv(control_sock
, &lsession
, sizeof(lsession
));
222 diag("Error receiving session");
225 if (lsession
.streams
> 0 && first_session
<= 0) {
226 first_session
= be64toh(lsession
.id
);
227 *session_id
= first_session
;
231 return be32toh(list
.sessions_count
);
238 int create_viewer_session(void)
240 struct lttng_viewer_cmd cmd
;
241 struct lttng_viewer_create_session_response resp
;
244 cmd
.cmd
= htobe32(LTTNG_VIEWER_CREATE_SESSION
);
245 cmd
.data_size
= htobe64(0);
246 cmd
.cmd_version
= htobe32(0);
248 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
250 diag("[error] Error sending cmd");
253 assert(ret_len
== sizeof(cmd
));
255 ret_len
= lttng_live_recv(control_sock
, &resp
, sizeof(resp
));
257 diag("[error] Remote side has closed connection");
261 diag("[error] Error receiving create session reply");
264 assert(ret_len
== sizeof(resp
));
266 if (be32toh(resp
.status
) != LTTNG_VIEWER_CREATE_SESSION_OK
) {
267 diag("[error] Error creating viewer session");
277 int attach_session(uint64_t id
)
279 struct lttng_viewer_cmd cmd
;
280 struct lttng_viewer_attach_session_request rq
;
281 struct lttng_viewer_attach_session_response rp
;
282 struct lttng_viewer_stream stream
;
286 session
= zmalloc(sizeof(struct live_session
));
291 cmd
.cmd
= htobe32(LTTNG_VIEWER_ATTACH_SESSION
);
292 cmd
.data_size
= htobe64(sizeof(rq
));
293 cmd
.cmd_version
= htobe32(0);
295 memset(&rq
, 0, sizeof(rq
));
296 rq
.session_id
= htobe64(id
);
297 rq
.seek
= htobe32(LTTNG_VIEWER_SEEK_BEGINNING
);
299 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
301 diag("Error sending cmd LTTNG_VIEWER_ATTACH_SESSION");
304 ret_len
= lttng_live_send(control_sock
, &rq
, sizeof(rq
));
306 diag("Error sending attach request");
310 ret_len
= lttng_live_recv(control_sock
, &rp
, sizeof(rp
));
312 diag("[error] Remote side has closed connection");
316 diag("Error receiving attach response");
319 if (be32toh(rp
.status
) != LTTNG_VIEWER_ATTACH_OK
) {
323 session
->stream_count
= be32toh(rp
.streams_count
);
324 if (session
->stream_count
== 0) {
325 diag("Got session stream count == 0");
328 session
->streams
= zmalloc(session
->stream_count
*
329 sizeof(struct viewer_stream
));
330 if (!session
->streams
) {
334 for (i
= 0; i
< be32toh(rp
.streams_count
); i
++) {
335 ret_len
= lttng_live_recv(control_sock
, &stream
, sizeof(stream
));
337 diag("[error] Remote side has closed connection");
341 diag("Error receiving stream");
344 session
->streams
[i
].id
= be64toh(stream
.id
);
346 session
->streams
[i
].ctf_trace_id
= be64toh(stream
.ctf_trace_id
);
347 session
->streams
[i
].first_read
= 1;
348 session
->streams
[i
].mmap_base
= mmap(NULL
, mmap_size
,
349 PROT_READ
| PROT_WRITE
,
350 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
351 if (session
->streams
[i
].mmap_base
== MAP_FAILED
) {
356 if (be32toh(stream
.metadata_flag
)) {
357 session
->streams
[i
].metadata_flag
= 1;
360 return session
->stream_count
;
367 int get_metadata(void)
369 struct lttng_viewer_cmd cmd
;
370 struct lttng_viewer_get_metadata rq
;
371 struct lttng_viewer_metadata_packet rp
;
377 int metadata_stream_id
= -1;
379 cmd
.cmd
= htobe32(LTTNG_VIEWER_GET_METADATA
);
380 cmd
.data_size
= htobe64(sizeof(rq
));
381 cmd
.cmd_version
= htobe32(0);
383 for (i
= 0; i
< session
->stream_count
; i
++) {
384 if (session
->streams
[i
].metadata_flag
) {
385 metadata_stream_id
= i
;
390 if (metadata_stream_id
< 0) {
391 diag("No metadata stream found");
395 rq
.stream_id
= htobe64(session
->streams
[metadata_stream_id
].id
);
398 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
400 diag("Error sending cmd");
403 ret_len
= lttng_live_send(control_sock
, &rq
, sizeof(rq
));
405 diag("Error sending get_metadata request");
408 ret_len
= lttng_live_recv(control_sock
, &rp
, sizeof(rp
));
410 diag("[error] Remote side has closed connection");
414 diag("Error receiving metadata response");
417 switch (be32toh(rp
.status
)) {
418 case LTTNG_VIEWER_METADATA_OK
:
420 case LTTNG_VIEWER_NO_NEW_METADATA
:
421 diag("Got LTTNG_VIEWER_NO_NEW_METADATA:");
424 case LTTNG_VIEWER_METADATA_ERR
:
425 diag("Got LTTNG_VIEWER_METADATA_ERR:");
428 diag("Got unknown status during LTTNG_VIEWER_GET_METADATA");
432 len
= be64toh(rp
.len
);
439 PERROR("relay data zmalloc");
442 ret_len
= lttng_live_recv(control_sock
, data
, len
);
444 diag("[error] Remote side has closed connection");
445 goto error_free_data
;
448 diag("Error receiving trace packet");
449 goto error_free_data
;
463 int get_next_index(void)
465 struct lttng_viewer_cmd cmd
;
466 struct lttng_viewer_get_next_index rq
;
467 struct lttng_viewer_index rp
;
471 cmd
.cmd
= htobe32(LTTNG_VIEWER_GET_NEXT_INDEX
);
472 cmd
.data_size
= htobe64(sizeof(rq
));
473 cmd
.cmd_version
= htobe32(0);
475 for (id
= 0; id
< session
->stream_count
; id
++) {
476 if (session
->streams
[id
].metadata_flag
) {
479 memset(&rq
, 0, sizeof(rq
));
480 rq
.stream_id
= htobe64(session
->streams
[id
].id
);
483 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
485 diag("Error sending cmd");
488 ret_len
= lttng_live_send(control_sock
, &rq
, sizeof(rq
));
490 diag("Error sending get_next_index request");
493 ret_len
= lttng_live_recv(control_sock
, &rp
, sizeof(rp
));
495 diag("[error] Remote side has closed connection");
499 diag("Error receiving index response");
503 rp
.flags
= be32toh(rp
.flags
);
505 switch (be32toh(rp
.status
)) {
506 case LTTNG_VIEWER_INDEX_INACTIVE
:
507 /* Skip this stream. */
508 diag("Got LTTNG_VIEWER_INDEX_INACTIVE");
510 case LTTNG_VIEWER_INDEX_OK
:
512 case LTTNG_VIEWER_INDEX_RETRY
:
515 case LTTNG_VIEWER_INDEX_HUP
:
516 diag("Got LTTNG_VIEWER_INDEX_HUP");
517 session
->streams
[id
].id
= -1ULL;
518 session
->streams
[id
].fd
= -1;
520 case LTTNG_VIEWER_INDEX_ERR
:
521 diag("Got LTTNG_VIEWER_INDEX_ERR");
524 diag("Unknown reply status during LTTNG_VIEWER_GET_NEXT_INDEX (%d)", be32toh(rp
.status
));
527 if (first_packet_stream_id
< 0) {
529 * Initialize the first packet stream id. That is,
530 * the first active stream encoutered.
532 first_packet_offset
= be64toh(rp
.offset
);
533 first_packet_len
= be64toh(rp
.packet_size
) / CHAR_BIT
;
534 first_packet_stream_id
= id
;
535 diag("Got first packet index with offset %d and len %d",
536 first_packet_offset
, first_packet_len
);
546 int get_data_packet(int id
, uint64_t offset
,
549 struct lttng_viewer_cmd cmd
;
550 struct lttng_viewer_get_packet rq
;
551 struct lttng_viewer_trace_packet rp
;
554 cmd
.cmd
= htobe32(LTTNG_VIEWER_GET_PACKET
);
555 cmd
.data_size
= htobe64(sizeof(rq
));
556 cmd
.cmd_version
= htobe32(0);
558 memset(&rq
, 0, sizeof(rq
));
559 rq
.stream_id
= htobe64(session
->streams
[id
].id
);
560 /* Already in big endian. */
562 rq
.len
= htobe32(len
);
564 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
566 diag("Error sending cmd");
569 ret_len
= lttng_live_send(control_sock
, &rq
, sizeof(rq
));
571 diag("Error sending get_data_packet request");
574 ret_len
= lttng_live_recv(control_sock
, &rp
, sizeof(rp
));
576 diag("[error] Remote side has closed connection");
580 diag("Error receiving data response");
583 rp
.flags
= be32toh(rp
.flags
);
585 switch (be32toh(rp
.status
)) {
586 case LTTNG_VIEWER_GET_PACKET_OK
:
587 len
= be32toh(rp
.len
);
589 diag("Got LTTNG_VIEWER_GET_PACKET_OK, but len == 0");
593 case LTTNG_VIEWER_GET_PACKET_RETRY
:
594 diag("Got LTTNG_VIEWER_GET_PACKET_RETRY:");
596 case LTTNG_VIEWER_GET_PACKET_ERR
:
597 if (rp
.flags
& LTTNG_VIEWER_FLAG_NEW_METADATA
) {
598 diag("Got LTTNG_VIEWER_GET_PACKET_ERR with NEW_METADATA flag");
601 diag("Got LTTNG_VIEWER_GET_PACKET_ERR:");
604 diag("Got unknown status code during LTTNG_VIEWER_GET_PACKET");
608 if (len
> mmap_size
) {
609 diag("mmap_size not big enough");
613 ret_len
= lttng_live_recv(control_sock
, session
->streams
[id
].mmap_base
, len
);
615 diag("[error] Remote side has closed connection");
619 diag("Error receiving trace packet");
629 int detach_viewer_session(uint64_t id
)
631 struct lttng_viewer_cmd cmd
;
632 struct lttng_viewer_detach_session_response resp
;
633 struct lttng_viewer_detach_session_request rq
;
637 cmd
.cmd
= htobe32(LTTNG_VIEWER_DETACH_SESSION
);
638 cmd
.data_size
= htobe64(sizeof(rq
));
639 cmd
.cmd_version
= htobe32(0);
641 memset(&rq
, 0, sizeof(rq
));
642 rq
.session_id
= htobe64(id
);
644 ret_len
= lttng_live_send(control_sock
, &cmd
, sizeof(cmd
));
646 fprintf(stderr
, "[error] Error sending cmd\n");
651 ret_len
= lttng_live_send(control_sock
, &rq
, sizeof(rq
));
653 fprintf(stderr
, "Error sending attach request\n");
658 ret_len
= lttng_live_recv(control_sock
, &resp
, sizeof(resp
));
660 fprintf(stderr
, "[error] Error receiving detach session reply\n");
665 if (be32toh(resp
.status
) != LTTNG_VIEWER_DETACH_SESSION_OK
) {
666 fprintf(stderr
, "[error] Error detaching viewer session\n");
676 int main(int argc
, char **argv
)
681 plan_tests(NUM_TESTS
);
683 diag("Live unit tests");
685 ret
= connect_viewer("localhost");
686 ok(ret
== 0, "Connect viewer to relayd");
688 ret
= establish_connection();
689 ok(ret
== 0, "Established connection and version check with %d.%d",
690 VERSION_MAJOR
, VERSION_MINOR
);
692 ret
= list_sessions(&session_id
);
693 ok(ret
> 0, "List sessions : %d session(s)", ret
);
698 ret
= create_viewer_session();
699 ok(ret
== 0, "Create viewer session");
701 ret
= attach_session(session_id
);
702 ok(ret
> 0, "Attach to session, %d stream(s) received", ret
);
704 ret
= get_metadata();
705 ok(ret
> 0, "Get metadata, received %d bytes", ret
);
707 ret
= get_next_index();
708 ok(ret
== 0, "Get one index per stream");
710 ret
= get_data_packet(first_packet_stream_id
, first_packet_offset
,
713 "Get one data packet for stream %d, offset %d, len %d",
714 first_packet_stream_id
, first_packet_offset
,
717 ret
= detach_viewer_session(session_id
);
718 ok(ret
== 0, "Detach viewer session");
720 ret
= list_sessions(&session_id
);
721 ok(ret
> 0, "List sessions : %d session(s)", ret
);
723 ret
= attach_session(session_id
);
724 ok(ret
> 0, "Attach to session, %d streams received", ret
);
726 return exit_status();