Commit | Line | Data |
---|---|---|
1b368955 | 1 | /* |
9d16b343 | 2 | * Copyright (C) 2013 Julien Desfossez <jdesfossez@efficios.com> |
1b368955 | 3 | * |
9d16b343 | 4 | * SPDX-License-Identifier: GPL-2.0-only |
1b368955 | 5 | * |
1b368955 JD |
6 | */ |
7 | ||
1b368955 JD |
8 | #include <stdio.h> |
9 | #include <stdlib.h> | |
10 | #include <string.h> | |
11 | #include <unistd.h> | |
c9e313bc | 12 | #include <common/compat/time.hpp> |
1b368955 JD |
13 | #include <sys/types.h> |
14 | #include <inttypes.h> | |
15 | #include <stdlib.h> | |
16 | #include <sys/socket.h> | |
17 | #include <netinet/in.h> | |
18 | #include <netdb.h> | |
19 | #include <fcntl.h> | |
20 | #include <sys/mman.h> | |
21 | #include <sys/stat.h> | |
22 | ||
23 | #include <tap/tap.h> | |
24 | #include <lttng/lttng.h> | |
25 | ||
26 | #include <urcu/list.h> | |
c9e313bc | 27 | #include <common/common.hpp> |
1b368955 | 28 | |
c9e313bc SM |
29 | #include <bin/lttng-relayd/lttng-viewer-abi.hpp> |
30 | #include <common/index/ctf-index.hpp> | |
1b368955 | 31 | |
c9e313bc SM |
32 | #include <common/compat/errno.hpp> |
33 | #include <common/compat/endian.hpp> | |
f263b7fd | 34 | |
1b368955 JD |
35 | #define SESSION1 "test1" |
36 | #define RELAYD_URL "net://localhost" | |
37 | #define LIVE_TIMER 2000000 | |
38 | ||
39 | /* Number of TAP tests in this file */ | |
e22ba966 | 40 | #define NUM_TESTS 11 |
1b368955 JD |
41 | #define mmap_size 524288 |
42 | ||
48c6e03e | 43 | #ifdef HAVE_LIBLTTNG_UST_CTL |
4bd69c5f | 44 | #include <lttng/lttng-export.h> |
48c6e03e | 45 | #include <lttng/ust-sigbus.h> |
4bd69c5f | 46 | LTTNG_EXPORT DEFINE_LTTNG_UST_SIGBUS_STATE(); |
48c6e03e | 47 | #endif |
e207fe73 | 48 | |
f1494934 | 49 | namespace { |
1b368955 | 50 | struct live_session *session; |
f1494934 | 51 | int control_sock; |
1b368955 | 52 | |
f1494934 JG |
53 | int first_packet_offset; |
54 | int first_packet_len; | |
55 | int first_packet_stream_id = -1; | |
1b368955 JD |
56 | |
57 | struct viewer_stream { | |
58 | uint64_t id; | |
59 | uint64_t ctf_trace_id; | |
60 | void *mmap_base; | |
61 | int fd; | |
62 | int metadata_flag; | |
63 | int first_read; | |
64 | char path[PATH_MAX]; | |
65 | }; | |
66 | ||
67 | struct live_session { | |
68 | struct viewer_stream *streams; | |
69 | uint64_t live_timer_interval; | |
70 | uint64_t stream_count; | |
71 | }; | |
f1494934 | 72 | } /* namespace */ |
1b368955 | 73 | |
10236918 MD |
74 | static |
75 | ssize_t lttng_live_recv(int fd, void *buf, size_t len) | |
76 | { | |
77 | ssize_t ret; | |
78 | size_t copied = 0, to_copy = len; | |
79 | ||
80 | do { | |
729c1fec | 81 | ret = recv(fd, (char *) buf + copied, to_copy, 0); |
10236918 | 82 | if (ret > 0) { |
a0377dfe | 83 | LTTNG_ASSERT(ret <= to_copy); |
10236918 MD |
84 | copied += ret; |
85 | to_copy -= ret; | |
86 | } | |
87 | } while ((ret > 0 && to_copy > 0) | |
88 | || (ret < 0 && errno == EINTR)); | |
89 | if (ret > 0) | |
90 | ret = copied; | |
91 | /* ret = 0 means orderly shutdown, ret < 0 is error. */ | |
92 | return ret; | |
93 | } | |
94 | ||
95 | static | |
96 | ssize_t lttng_live_send(int fd, const void *buf, size_t len) | |
97 | { | |
98 | ssize_t ret; | |
99 | ||
100 | do { | |
101 | ret = send(fd, buf, len, MSG_NOSIGNAL); | |
102 | } while (ret < 0 && errno == EINTR); | |
103 | return ret; | |
104 | } | |
105 | ||
1b368955 | 106 | static |
b53d4e59 | 107 | int connect_viewer(const char *hostname) |
1b368955 JD |
108 | { |
109 | struct hostent *host; | |
110 | struct sockaddr_in server_addr; | |
111 | int ret; | |
112 | ||
113 | host = gethostbyname(hostname); | |
114 | if (!host) { | |
115 | ret = -1; | |
116 | goto end; | |
117 | } | |
118 | ||
119 | if ((control_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { | |
6f04ed72 | 120 | PERROR("Socket"); |
1b368955 JD |
121 | ret = -1; |
122 | goto end; | |
123 | } | |
124 | ||
125 | server_addr.sin_family = AF_INET; | |
126 | server_addr.sin_port = htons(5344); | |
127 | server_addr.sin_addr = *((struct in_addr *) host->h_addr); | |
128 | bzero(&(server_addr.sin_zero), 8); | |
129 | ||
130 | if (connect(control_sock, (struct sockaddr *) &server_addr, | |
131 | sizeof(struct sockaddr)) == -1) { | |
6f04ed72 | 132 | PERROR("Connect"); |
1b368955 JD |
133 | ret = -1; |
134 | goto end; | |
135 | } | |
136 | ||
137 | server_addr.sin_family = AF_INET; | |
138 | server_addr.sin_port = htons(5345); | |
139 | server_addr.sin_addr = *((struct in_addr *) host->h_addr); | |
140 | bzero(&(server_addr.sin_zero), 8); | |
141 | ||
142 | ret = 0; | |
143 | ||
144 | end: | |
145 | return ret; | |
146 | } | |
147 | ||
8f92cd08 | 148 | static |
1b368955 JD |
149 | int establish_connection(void) |
150 | { | |
151 | struct lttng_viewer_cmd cmd; | |
152 | struct lttng_viewer_connect connect; | |
10236918 | 153 | ssize_t ret_len; |
1b368955 | 154 | |
c4e361a4 | 155 | cmd.cmd = htobe32(LTTNG_VIEWER_CONNECT); |
2dc797f3 JD |
156 | cmd.data_size = htobe64(sizeof(connect)); |
157 | cmd.cmd_version = htobe32(0); | |
1b368955 | 158 | |
dcf5c25e | 159 | memset(&connect, 0, sizeof(connect)); |
1b368955 JD |
160 | connect.major = htobe32(VERSION_MAJOR); |
161 | connect.minor = htobe32(VERSION_MINOR); | |
c4e361a4 | 162 | connect.type = htobe32(LTTNG_VIEWER_CLIENT_COMMAND); |
1b368955 | 163 | |
10236918 MD |
164 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
165 | if (ret_len < 0) { | |
7409dd34 | 166 | diag("Error sending cmd"); |
1b368955 JD |
167 | goto error; |
168 | } | |
10236918 MD |
169 | ret_len = lttng_live_send(control_sock, &connect, sizeof(connect)); |
170 | if (ret_len < 0) { | |
7409dd34 | 171 | diag("Error sending version"); |
1b368955 JD |
172 | goto error; |
173 | } | |
174 | ||
10236918 MD |
175 | ret_len = lttng_live_recv(control_sock, &connect, sizeof(connect)); |
176 | if (ret_len == 0) { | |
7409dd34 | 177 | diag("[error] Remote side has closed connection"); |
10236918 MD |
178 | goto error; |
179 | } | |
180 | if (ret_len < 0) { | |
7409dd34 | 181 | diag("Error receiving version"); |
1b368955 JD |
182 | goto error; |
183 | } | |
10236918 | 184 | return 0; |
1b368955 JD |
185 | |
186 | error: | |
10236918 | 187 | return -1; |
1b368955 JD |
188 | } |
189 | ||
190 | /* | |
191 | * Returns the number of sessions, should be 1 during the unit test. | |
192 | */ | |
8f92cd08 | 193 | static |
7409dd34 | 194 | int list_sessions(uint64_t *session_id) |
1b368955 JD |
195 | { |
196 | struct lttng_viewer_cmd cmd; | |
197 | struct lttng_viewer_list_sessions list; | |
198 | struct lttng_viewer_session lsession; | |
10236918 MD |
199 | int i; |
200 | ssize_t ret_len; | |
1b368955 JD |
201 | int first_session = 0; |
202 | ||
c4e361a4 | 203 | cmd.cmd = htobe32(LTTNG_VIEWER_LIST_SESSIONS); |
2dc797f3 JD |
204 | cmd.data_size = htobe64(0); |
205 | cmd.cmd_version = htobe32(0); | |
1b368955 | 206 | |
10236918 MD |
207 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
208 | if (ret_len < 0) { | |
7409dd34 | 209 | diag("Error sending cmd"); |
1b368955 JD |
210 | goto error; |
211 | } | |
212 | ||
10236918 MD |
213 | ret_len = lttng_live_recv(control_sock, &list, sizeof(list)); |
214 | if (ret_len == 0) { | |
7409dd34 | 215 | diag("[error] Remote side has closed connection"); |
10236918 MD |
216 | goto error; |
217 | } | |
218 | if (ret_len < 0) { | |
7409dd34 | 219 | diag("Error receiving session list"); |
1b368955 JD |
220 | goto error; |
221 | } | |
222 | ||
223 | for (i = 0; i < be32toh(list.sessions_count); i++) { | |
10236918 MD |
224 | ret_len = lttng_live_recv(control_sock, &lsession, sizeof(lsession)); |
225 | if (ret_len < 0) { | |
7409dd34 | 226 | diag("Error receiving session"); |
1b368955 JD |
227 | goto error; |
228 | } | |
229 | if (lsession.streams > 0 && first_session <= 0) { | |
230 | first_session = be64toh(lsession.id); | |
231 | *session_id = first_session; | |
232 | } | |
233 | } | |
234 | ||
10236918 | 235 | return be32toh(list.sessions_count); |
1b368955 JD |
236 | |
237 | error: | |
10236918 | 238 | return -1; |
1b368955 JD |
239 | } |
240 | ||
8f92cd08 | 241 | static |
10236918 | 242 | int create_viewer_session(void) |
25b50f8f JD |
243 | { |
244 | struct lttng_viewer_cmd cmd; | |
245 | struct lttng_viewer_create_session_response resp; | |
25b50f8f JD |
246 | ssize_t ret_len; |
247 | ||
248 | cmd.cmd = htobe32(LTTNG_VIEWER_CREATE_SESSION); | |
2dc797f3 JD |
249 | cmd.data_size = htobe64(0); |
250 | cmd.cmd_version = htobe32(0); | |
25b50f8f | 251 | |
10236918 | 252 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
25b50f8f | 253 | if (ret_len < 0) { |
7409dd34 | 254 | diag("[error] Error sending cmd"); |
25b50f8f JD |
255 | goto error; |
256 | } | |
a0377dfe | 257 | LTTNG_ASSERT(ret_len == sizeof(cmd)); |
25b50f8f | 258 | |
10236918 MD |
259 | ret_len = lttng_live_recv(control_sock, &resp, sizeof(resp)); |
260 | if (ret_len == 0) { | |
7409dd34 | 261 | diag("[error] Remote side has closed connection"); |
10236918 MD |
262 | goto error; |
263 | } | |
25b50f8f | 264 | if (ret_len < 0) { |
7409dd34 | 265 | diag("[error] Error receiving create session reply"); |
25b50f8f JD |
266 | goto error; |
267 | } | |
a0377dfe | 268 | LTTNG_ASSERT(ret_len == sizeof(resp)); |
25b50f8f JD |
269 | |
270 | if (be32toh(resp.status) != LTTNG_VIEWER_CREATE_SESSION_OK) { | |
7409dd34 | 271 | diag("[error] Error creating viewer session"); |
25b50f8f JD |
272 | goto error; |
273 | } | |
10236918 | 274 | return 0; |
25b50f8f JD |
275 | |
276 | error: | |
10236918 | 277 | return -1; |
25b50f8f JD |
278 | } |
279 | ||
8f92cd08 | 280 | static |
7409dd34 | 281 | int attach_session(uint64_t id) |
1b368955 JD |
282 | { |
283 | struct lttng_viewer_cmd cmd; | |
284 | struct lttng_viewer_attach_session_request rq; | |
285 | struct lttng_viewer_attach_session_response rp; | |
286 | struct lttng_viewer_stream stream; | |
10236918 MD |
287 | int i; |
288 | ssize_t ret_len; | |
1b368955 | 289 | |
64803277 | 290 | session = zmalloc<live_session>(); |
1b368955 | 291 | if (!session) { |
1b368955 JD |
292 | goto error; |
293 | } | |
294 | ||
c4e361a4 | 295 | cmd.cmd = htobe32(LTTNG_VIEWER_ATTACH_SESSION); |
2dc797f3 JD |
296 | cmd.data_size = htobe64(sizeof(rq)); |
297 | cmd.cmd_version = htobe32(0); | |
1b368955 | 298 | |
dcf5c25e | 299 | memset(&rq, 0, sizeof(rq)); |
1b368955 | 300 | rq.session_id = htobe64(id); |
c4e361a4 | 301 | rq.seek = htobe32(LTTNG_VIEWER_SEEK_BEGINNING); |
1b368955 | 302 | |
10236918 MD |
303 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
304 | if (ret_len < 0) { | |
7409dd34 | 305 | diag("Error sending cmd LTTNG_VIEWER_ATTACH_SESSION"); |
1b368955 JD |
306 | goto error; |
307 | } | |
10236918 MD |
308 | ret_len = lttng_live_send(control_sock, &rq, sizeof(rq)); |
309 | if (ret_len < 0) { | |
7409dd34 | 310 | diag("Error sending attach request"); |
1b368955 JD |
311 | goto error; |
312 | } | |
313 | ||
10236918 MD |
314 | ret_len = lttng_live_recv(control_sock, &rp, sizeof(rp)); |
315 | if (ret_len == 0) { | |
7409dd34 | 316 | diag("[error] Remote side has closed connection"); |
10236918 MD |
317 | goto error; |
318 | } | |
319 | if (ret_len < 0) { | |
7409dd34 | 320 | diag("Error receiving attach response"); |
1b368955 JD |
321 | goto error; |
322 | } | |
c4e361a4 | 323 | if (be32toh(rp.status) != LTTNG_VIEWER_ATTACH_OK) { |
10236918 | 324 | goto error; |
1b368955 JD |
325 | } |
326 | ||
327 | session->stream_count = be32toh(rp.streams_count); | |
7409dd34 JG |
328 | if (session->stream_count == 0) { |
329 | diag("Got session stream count == 0"); | |
330 | goto error; | |
331 | } | |
64803277 | 332 | session->streams = calloc<viewer_stream>(session->stream_count); |
1b368955 | 333 | if (!session->streams) { |
1b368955 JD |
334 | goto error; |
335 | } | |
336 | ||
337 | for (i = 0; i < be32toh(rp.streams_count); i++) { | |
10236918 MD |
338 | ret_len = lttng_live_recv(control_sock, &stream, sizeof(stream)); |
339 | if (ret_len == 0) { | |
7409dd34 | 340 | diag("[error] Remote side has closed connection"); |
10236918 MD |
341 | goto error; |
342 | } | |
343 | if (ret_len < 0) { | |
7409dd34 | 344 | diag("Error receiving stream"); |
1b368955 JD |
345 | goto error; |
346 | } | |
347 | session->streams[i].id = be64toh(stream.id); | |
348 | ||
349 | session->streams[i].ctf_trace_id = be64toh(stream.ctf_trace_id); | |
350 | session->streams[i].first_read = 1; | |
7409dd34 JG |
351 | session->streams[i].mmap_base = mmap(NULL, mmap_size, |
352 | PROT_READ | PROT_WRITE, | |
1b368955 JD |
353 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
354 | if (session->streams[i].mmap_base == MAP_FAILED) { | |
7409dd34 | 355 | diag("mmap error"); |
1b368955 JD |
356 | goto error; |
357 | } | |
358 | ||
359 | if (be32toh(stream.metadata_flag)) { | |
360 | session->streams[i].metadata_flag = 1; | |
361 | } | |
362 | } | |
10236918 | 363 | return session->stream_count; |
1b368955 | 364 | |
1b368955 | 365 | error: |
10236918 | 366 | return -1; |
1b368955 JD |
367 | } |
368 | ||
8f92cd08 | 369 | static |
1b368955 JD |
370 | int get_metadata(void) |
371 | { | |
372 | struct lttng_viewer_cmd cmd; | |
373 | struct lttng_viewer_get_metadata rq; | |
374 | struct lttng_viewer_metadata_packet rp; | |
10236918 | 375 | ssize_t ret_len; |
1b368955 JD |
376 | int ret; |
377 | uint64_t i; | |
378 | char *data = NULL; | |
379 | uint64_t len = 0; | |
380 | int metadata_stream_id = -1; | |
381 | ||
c4e361a4 | 382 | cmd.cmd = htobe32(LTTNG_VIEWER_GET_METADATA); |
2dc797f3 JD |
383 | cmd.data_size = htobe64(sizeof(rq)); |
384 | cmd.cmd_version = htobe32(0); | |
1b368955 JD |
385 | |
386 | for (i = 0; i < session->stream_count; i++) { | |
387 | if (session->streams[i].metadata_flag) { | |
388 | metadata_stream_id = i; | |
389 | break; | |
390 | } | |
391 | } | |
392 | ||
393 | if (metadata_stream_id < 0) { | |
7409dd34 | 394 | diag("No metadata stream found"); |
1b368955 JD |
395 | goto error; |
396 | } | |
397 | ||
398 | rq.stream_id = htobe64(session->streams[metadata_stream_id].id); | |
399 | ||
a648b489 | 400 | retry: |
10236918 MD |
401 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
402 | if (ret_len < 0) { | |
7409dd34 | 403 | diag("Error sending cmd"); |
1b368955 JD |
404 | goto error; |
405 | } | |
10236918 MD |
406 | ret_len = lttng_live_send(control_sock, &rq, sizeof(rq)); |
407 | if (ret_len < 0) { | |
7409dd34 | 408 | diag("Error sending get_metadata request"); |
1b368955 JD |
409 | goto error; |
410 | } | |
10236918 MD |
411 | ret_len = lttng_live_recv(control_sock, &rp, sizeof(rp)); |
412 | if (ret_len == 0) { | |
7409dd34 | 413 | diag("[error] Remote side has closed connection"); |
10236918 MD |
414 | goto error; |
415 | } | |
416 | if (ret_len < 0) { | |
7409dd34 | 417 | diag("Error receiving metadata response"); |
1b368955 JD |
418 | goto error; |
419 | } | |
420 | switch (be32toh(rp.status)) { | |
7409dd34 JG |
421 | case LTTNG_VIEWER_METADATA_OK: |
422 | break; | |
423 | case LTTNG_VIEWER_NO_NEW_METADATA: | |
424 | diag("Got LTTNG_VIEWER_NO_NEW_METADATA:"); | |
a648b489 JR |
425 | usleep(50); |
426 | goto retry; | |
7409dd34 JG |
427 | case LTTNG_VIEWER_METADATA_ERR: |
428 | diag("Got LTTNG_VIEWER_METADATA_ERR:"); | |
429 | goto error; | |
430 | default: | |
431 | diag("Got unknown status during LTTNG_VIEWER_GET_METADATA"); | |
432 | goto error; | |
1b368955 JD |
433 | } |
434 | ||
435 | len = be64toh(rp.len); | |
436 | if (len <= 0) { | |
10236918 | 437 | goto error; |
1b368955 JD |
438 | } |
439 | ||
64803277 | 440 | data = calloc<char>(len); |
1b368955 | 441 | if (!data) { |
6f04ed72 | 442 | PERROR("relay data zmalloc"); |
1b368955 JD |
443 | goto error; |
444 | } | |
10236918 MD |
445 | ret_len = lttng_live_recv(control_sock, data, len); |
446 | if (ret_len == 0) { | |
7409dd34 | 447 | diag("[error] Remote side has closed connection"); |
10236918 MD |
448 | goto error_free_data; |
449 | } | |
450 | if (ret_len < 0) { | |
7409dd34 | 451 | diag("Error receiving trace packet"); |
10236918 | 452 | goto error_free_data; |
1b368955 JD |
453 | } |
454 | free(data); | |
10236918 | 455 | ret = len; |
a648b489 | 456 | |
1b368955 | 457 | return ret; |
10236918 MD |
458 | |
459 | error_free_data: | |
460 | free(data); | |
461 | error: | |
462 | return -1; | |
1b368955 JD |
463 | } |
464 | ||
8f92cd08 | 465 | static |
1b368955 JD |
466 | int get_next_index(void) |
467 | { | |
468 | struct lttng_viewer_cmd cmd; | |
469 | struct lttng_viewer_get_next_index rq; | |
470 | struct lttng_viewer_index rp; | |
10236918 | 471 | ssize_t ret_len; |
1b368955 JD |
472 | int id; |
473 | ||
c4e361a4 | 474 | cmd.cmd = htobe32(LTTNG_VIEWER_GET_NEXT_INDEX); |
2dc797f3 JD |
475 | cmd.data_size = htobe64(sizeof(rq)); |
476 | cmd.cmd_version = htobe32(0); | |
1b368955 JD |
477 | |
478 | for (id = 0; id < session->stream_count; id++) { | |
479 | if (session->streams[id].metadata_flag) { | |
480 | continue; | |
481 | } | |
10236918 | 482 | memset(&rq, 0, sizeof(rq)); |
1b368955 JD |
483 | rq.stream_id = htobe64(session->streams[id].id); |
484 | ||
485 | retry: | |
10236918 MD |
486 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
487 | if (ret_len < 0) { | |
7409dd34 | 488 | diag("Error sending cmd"); |
1b368955 JD |
489 | goto error; |
490 | } | |
10236918 MD |
491 | ret_len = lttng_live_send(control_sock, &rq, sizeof(rq)); |
492 | if (ret_len < 0) { | |
7409dd34 | 493 | diag("Error sending get_next_index request"); |
1b368955 JD |
494 | goto error; |
495 | } | |
10236918 MD |
496 | ret_len = lttng_live_recv(control_sock, &rp, sizeof(rp)); |
497 | if (ret_len == 0) { | |
7409dd34 | 498 | diag("[error] Remote side has closed connection"); |
10236918 MD |
499 | goto error; |
500 | } | |
501 | if (ret_len < 0) { | |
7409dd34 | 502 | diag("Error receiving index response"); |
1b368955 JD |
503 | goto error; |
504 | } | |
505 | ||
506 | rp.flags = be32toh(rp.flags); | |
507 | ||
508 | switch (be32toh(rp.status)) { | |
7409dd34 JG |
509 | case LTTNG_VIEWER_INDEX_INACTIVE: |
510 | /* Skip this stream. */ | |
511 | diag("Got LTTNG_VIEWER_INDEX_INACTIVE"); | |
512 | continue; | |
513 | case LTTNG_VIEWER_INDEX_OK: | |
514 | break; | |
515 | case LTTNG_VIEWER_INDEX_RETRY: | |
516 | sleep(1); | |
517 | goto retry; | |
518 | case LTTNG_VIEWER_INDEX_HUP: | |
519 | diag("Got LTTNG_VIEWER_INDEX_HUP"); | |
520 | session->streams[id].id = -1ULL; | |
521 | session->streams[id].fd = -1; | |
522 | goto error; | |
523 | case LTTNG_VIEWER_INDEX_ERR: | |
524 | diag("Got LTTNG_VIEWER_INDEX_ERR"); | |
525 | goto error; | |
526 | default: | |
527 | diag("Unknown reply status during LTTNG_VIEWER_GET_NEXT_INDEX (%d)", be32toh(rp.status)); | |
528 | goto error; | |
1b368955 | 529 | } |
7409dd34 JG |
530 | if (first_packet_stream_id < 0) { |
531 | /* | |
532 | * Initialize the first packet stream id. That is, | |
533 | * the first active stream encoutered. | |
534 | */ | |
1b368955 JD |
535 | first_packet_offset = be64toh(rp.offset); |
536 | first_packet_len = be64toh(rp.packet_size) / CHAR_BIT; | |
537 | first_packet_stream_id = id; | |
7409dd34 JG |
538 | diag("Got first packet index with offset %d and len %d", |
539 | first_packet_offset, first_packet_len); | |
1b368955 JD |
540 | } |
541 | } | |
10236918 | 542 | return 0; |
1b368955 JD |
543 | |
544 | error: | |
10236918 | 545 | return -1; |
1b368955 JD |
546 | } |
547 | ||
548 | static | |
549 | int get_data_packet(int id, uint64_t offset, | |
550 | uint64_t len) | |
551 | { | |
552 | struct lttng_viewer_cmd cmd; | |
553 | struct lttng_viewer_get_packet rq; | |
554 | struct lttng_viewer_trace_packet rp; | |
10236918 | 555 | ssize_t ret_len; |
1b368955 | 556 | |
c4e361a4 | 557 | cmd.cmd = htobe32(LTTNG_VIEWER_GET_PACKET); |
2dc797f3 JD |
558 | cmd.data_size = htobe64(sizeof(rq)); |
559 | cmd.cmd_version = htobe32(0); | |
1b368955 | 560 | |
10236918 | 561 | memset(&rq, 0, sizeof(rq)); |
1b368955 JD |
562 | rq.stream_id = htobe64(session->streams[id].id); |
563 | /* Already in big endian. */ | |
564 | rq.offset = offset; | |
565 | rq.len = htobe32(len); | |
566 | ||
10236918 MD |
567 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); |
568 | if (ret_len < 0) { | |
7409dd34 | 569 | diag("Error sending cmd"); |
1b368955 JD |
570 | goto error; |
571 | } | |
10236918 MD |
572 | ret_len = lttng_live_send(control_sock, &rq, sizeof(rq)); |
573 | if (ret_len < 0) { | |
7409dd34 | 574 | diag("Error sending get_data_packet request"); |
1b368955 JD |
575 | goto error; |
576 | } | |
10236918 MD |
577 | ret_len = lttng_live_recv(control_sock, &rp, sizeof(rp)); |
578 | if (ret_len == 0) { | |
7409dd34 | 579 | diag("[error] Remote side has closed connection"); |
10236918 MD |
580 | goto error; |
581 | } | |
582 | if (ret_len < 0) { | |
7409dd34 | 583 | diag("Error receiving data response"); |
1b368955 JD |
584 | goto error; |
585 | } | |
586 | rp.flags = be32toh(rp.flags); | |
587 | ||
588 | switch (be32toh(rp.status)) { | |
c4e361a4 | 589 | case LTTNG_VIEWER_GET_PACKET_OK: |
10236918 | 590 | len = be32toh(rp.len); |
7409dd34 JG |
591 | if (len == 0) { |
592 | diag("Got LTTNG_VIEWER_GET_PACKET_OK, but len == 0"); | |
593 | goto error; | |
594 | } | |
1b368955 | 595 | break; |
c4e361a4 | 596 | case LTTNG_VIEWER_GET_PACKET_RETRY: |
7409dd34 | 597 | diag("Got LTTNG_VIEWER_GET_PACKET_RETRY:"); |
10236918 | 598 | goto error; |
c4e361a4 | 599 | case LTTNG_VIEWER_GET_PACKET_ERR: |
1b368955 | 600 | if (rp.flags & LTTNG_VIEWER_FLAG_NEW_METADATA) { |
7409dd34 | 601 | diag("Got LTTNG_VIEWER_GET_PACKET_ERR with NEW_METADATA flag"); |
1b368955 JD |
602 | goto end; |
603 | } | |
7409dd34 | 604 | diag("Got LTTNG_VIEWER_GET_PACKET_ERR:"); |
10236918 | 605 | goto error; |
1b368955 | 606 | default: |
7409dd34 | 607 | diag("Got unknown status code during LTTNG_VIEWER_GET_PACKET"); |
10236918 | 608 | goto error; |
1b368955 JD |
609 | } |
610 | ||
611 | if (len > mmap_size) { | |
7409dd34 | 612 | diag("mmap_size not big enough"); |
1b368955 JD |
613 | goto error; |
614 | } | |
615 | ||
10236918 MD |
616 | ret_len = lttng_live_recv(control_sock, session->streams[id].mmap_base, len); |
617 | if (ret_len == 0) { | |
7409dd34 | 618 | diag("[error] Remote side has closed connection"); |
10236918 MD |
619 | goto error; |
620 | } | |
621 | if (ret_len < 0) { | |
7409dd34 | 622 | diag("Error receiving trace packet"); |
1b368955 JD |
623 | goto error; |
624 | } | |
1b368955 | 625 | end: |
10236918 | 626 | return 0; |
1b368955 | 627 | error: |
10236918 | 628 | return -1; |
1b368955 JD |
629 | } |
630 | ||
8f92cd08 | 631 | static |
e22ba966 JD |
632 | int detach_viewer_session(uint64_t id) |
633 | { | |
634 | struct lttng_viewer_cmd cmd; | |
635 | struct lttng_viewer_detach_session_response resp; | |
636 | struct lttng_viewer_detach_session_request rq; | |
637 | int ret; | |
638 | ssize_t ret_len; | |
639 | ||
640 | cmd.cmd = htobe32(LTTNG_VIEWER_DETACH_SESSION); | |
2dc797f3 JD |
641 | cmd.data_size = htobe64(sizeof(rq)); |
642 | cmd.cmd_version = htobe32(0); | |
e22ba966 JD |
643 | |
644 | memset(&rq, 0, sizeof(rq)); | |
645 | rq.session_id = htobe64(id); | |
646 | ||
647 | ret_len = lttng_live_send(control_sock, &cmd, sizeof(cmd)); | |
648 | if (ret_len < 0) { | |
649 | fprintf(stderr, "[error] Error sending cmd\n"); | |
650 | ret = ret_len; | |
651 | goto error; | |
652 | } | |
653 | ||
654 | ret_len = lttng_live_send(control_sock, &rq, sizeof(rq)); | |
655 | if (ret_len < 0) { | |
656 | fprintf(stderr, "Error sending attach request\n"); | |
657 | ret = ret_len; | |
658 | goto error; | |
659 | } | |
660 | ||
661 | ret_len = lttng_live_recv(control_sock, &resp, sizeof(resp)); | |
662 | if (ret_len < 0) { | |
663 | fprintf(stderr, "[error] Error receiving detach session reply\n"); | |
664 | ret = ret_len; | |
665 | goto error; | |
666 | } | |
667 | ||
668 | if (be32toh(resp.status) != LTTNG_VIEWER_DETACH_SESSION_OK) { | |
669 | fprintf(stderr, "[error] Error detaching viewer session\n"); | |
670 | ret = -1; | |
671 | goto error; | |
672 | } | |
673 | ret = 0; | |
674 | ||
675 | error: | |
676 | return ret; | |
677 | } | |
678 | ||
f46376a1 | 679 | int main(void) |
1b368955 JD |
680 | { |
681 | int ret; | |
7409dd34 | 682 | uint64_t session_id; |
1b368955 JD |
683 | |
684 | plan_tests(NUM_TESTS); | |
685 | ||
686 | diag("Live unit tests"); | |
687 | ||
688 | ret = connect_viewer("localhost"); | |
689 | ok(ret == 0, "Connect viewer to relayd"); | |
690 | ||
691 | ret = establish_connection(); | |
692 | ok(ret == 0, "Established connection and version check with %d.%d", | |
693 | VERSION_MAJOR, VERSION_MINOR); | |
694 | ||
695 | ret = list_sessions(&session_id); | |
696 | ok(ret > 0, "List sessions : %d session(s)", ret); | |
8674c9bf JG |
697 | if (ret < 0) { |
698 | goto end; | |
699 | } | |
1b368955 | 700 | |
25b50f8f JD |
701 | ret = create_viewer_session(); |
702 | ok(ret == 0, "Create viewer session"); | |
703 | ||
1b368955 | 704 | ret = attach_session(session_id); |
7409dd34 | 705 | ok(ret > 0, "Attach to session, %d stream(s) received", ret); |
1b368955 JD |
706 | |
707 | ret = get_metadata(); | |
708 | ok(ret > 0, "Get metadata, received %d bytes", ret); | |
709 | ||
710 | ret = get_next_index(); | |
711 | ok(ret == 0, "Get one index per stream"); | |
712 | ||
713 | ret = get_data_packet(first_packet_stream_id, first_packet_offset, | |
714 | first_packet_len); | |
10236918 | 715 | ok(ret == 0, |
1b368955 JD |
716 | "Get one data packet for stream %d, offset %d, len %d", |
717 | first_packet_stream_id, first_packet_offset, | |
718 | first_packet_len); | |
719 | ||
e22ba966 JD |
720 | ret = detach_viewer_session(session_id); |
721 | ok(ret == 0, "Detach viewer session"); | |
722 | ||
723 | ret = list_sessions(&session_id); | |
724 | ok(ret > 0, "List sessions : %d session(s)", ret); | |
725 | ||
726 | ret = attach_session(session_id); | |
727 | ok(ret > 0, "Attach to session, %d streams received", ret); | |
8674c9bf | 728 | end: |
1b368955 JD |
729 | return exit_status(); |
730 | } |