Commit | Line | Data |
---|---|---|
68c1021b PMF |
1 | #include <stdio.h> |
2 | #include <stdint.h> | |
3 | #include <signal.h> | |
4 | #include <sys/types.h> | |
5 | #include <sys/socket.h> | |
6 | #include <sys/un.h> | |
98963de4 | 7 | #include <sched.h> |
a584bc4e | 8 | #include <fcntl.h> |
fbd8191b PMF |
9 | |
10 | #include "marker.h" | |
a584bc4e | 11 | #include "tracer.h" |
d0b5f2b9 PMF |
12 | #include "localerr.h" |
13 | #include "ustcomm.h" | |
46ef48cd | 14 | #include "relay.h" /* FIXME: remove */ |
fbd8191b | 15 | |
b02e31e5 | 16 | //#define USE_CLONE |
3847c3ba | 17 | |
68c1021b PMF |
18 | #define USTSIGNAL SIGIO |
19 | ||
98963de4 PMF |
20 | #define MAX_MSG_SIZE (100) |
21 | #define MSG_NOTIF 1 | |
22 | #define MSG_REGISTER_NOTIF 2 | |
23 | ||
a584bc4e PMF |
24 | char consumer_stack[10000]; |
25 | ||
d0b5f2b9 PMF |
26 | static struct ustcomm_app ustcomm_app; |
27 | ||
68c1021b PMF |
28 | struct tracecmd { /* no padding */ |
29 | uint32_t size; | |
30 | uint16_t command; | |
31 | }; | |
32 | ||
98963de4 PMF |
33 | //struct listener_arg { |
34 | // int pipe_fd; | |
35 | //}; | |
36 | ||
37 | struct trctl_msg { | |
38 | /* size: the size of all the fields except size itself */ | |
39 | uint32_t size; | |
40 | uint16_t type; | |
41 | /* Only the necessary part of the payload is transferred. It | |
42 | * may even be none of it. | |
43 | */ | |
44 | char payload[94]; | |
45 | }; | |
68c1021b | 46 | |
a584bc4e PMF |
47 | struct consumer_channel { |
48 | int fd; | |
49 | struct ltt_channel_struct *chan; | |
50 | }; | |
51 | ||
52 | int consumer(void *arg) | |
53 | { | |
54 | int result; | |
55 | int fd; | |
56 | char str[] = "Hello, this is the consumer.\n"; | |
57 | struct ltt_trace_struct *trace; | |
58 | struct consumer_channel *consumer_channels; | |
59 | int i; | |
60 | char trace_name[] = "auto"; | |
61 | ||
62 | ltt_lock_traces(); | |
63 | trace = _ltt_trace_find(trace_name); | |
64 | ltt_unlock_traces(); | |
65 | ||
66 | if(trace == NULL) { | |
67 | CPRINTF("cannot find trace!"); | |
68 | return 1; | |
69 | } | |
70 | ||
71 | consumer_channels = (struct consumer_channel *) malloc(trace->nr_channels * sizeof(struct consumer_channel)); | |
72 | if(consumer_channels == NULL) { | |
73 | ERR("malloc returned NULL"); | |
74 | return 1; | |
75 | } | |
76 | ||
77 | CPRINTF("opening trace files"); | |
78 | for(i=0; i<trace->nr_channels; i++) { | |
79 | char tmp[100]; | |
80 | struct ltt_channel_struct *chan = &trace->channels[i]; | |
81 | ||
82 | consumer_channels[i].chan = chan; | |
83 | ||
1c184644 | 84 | snprintf(tmp, sizeof(tmp), "trace/%s_0", chan->channel_name); |
688760ef | 85 | result = consumer_channels[i].fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 00600); |
a584bc4e PMF |
86 | if(result == -1) { |
87 | perror("open"); | |
88 | return -1; | |
89 | } | |
90 | CPRINTF("\topened trace file %s", tmp); | |
91 | ||
92 | } | |
93 | CPRINTF("done opening trace files"); | |
94 | ||
95 | for(;;) { | |
96 | /*wait*/ | |
97 | ||
98 | for(i=0; i<trace->nr_channels; i++) { | |
99 | struct rchan *rchan = consumer_channels[i].chan->trans_channel_data; | |
100 | struct rchan_buf *rbuf = rchan->buf; | |
101 | struct ltt_channel_buf_struct *lttbuf = consumer_channels[i].chan->buf; | |
102 | long consumed_old; | |
103 | ||
104 | result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); | |
105 | if(result < 0) { | |
1c184644 | 106 | DBG("ltt_do_get_subbuf: error: %s", strerror(-result)); |
a584bc4e PMF |
107 | } |
108 | else { | |
1c184644 | 109 | DBG("success!"); |
a584bc4e PMF |
110 | |
111 | result = write(consumer_channels[i].fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); | |
112 | ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); | |
113 | } | |
114 | } | |
115 | ||
116 | sleep(1); | |
117 | } | |
a584bc4e PMF |
118 | } |
119 | ||
120 | void start_consumer(void) | |
121 | { | |
3847c3ba | 122 | #ifdef USE_CLONE |
a584bc4e PMF |
123 | int result; |
124 | ||
125 | result = clone(consumer, consumer_stack+sizeof(consumer_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL); | |
126 | if(result == -1) { | |
127 | perror("clone"); | |
128 | } | |
3847c3ba PMF |
129 | #else |
130 | pthread_t thread; | |
131 | ||
132 | pthread_create(&thread, NULL, consumer, NULL); | |
133 | #endif | |
a584bc4e | 134 | } |
fbd8191b PMF |
135 | |
136 | static void print_markers(void) | |
137 | { | |
138 | struct marker_iter iter; | |
139 | ||
d0b5f2b9 | 140 | lock_markers(); |
fbd8191b PMF |
141 | marker_iter_reset(&iter); |
142 | marker_iter_start(&iter); | |
143 | ||
144 | while(iter.marker) { | |
145 | fprintf(stderr, "marker: %s_%s \"%s\"\n", iter.marker->channel, iter.marker->name, iter.marker->format); | |
146 | marker_iter_next(&iter); | |
147 | } | |
d0b5f2b9 | 148 | unlock_markers(); |
fbd8191b PMF |
149 | } |
150 | ||
68c1021b PMF |
151 | void do_command(struct tracecmd *cmd) |
152 | { | |
153 | } | |
154 | ||
155 | void receive_commands() | |
156 | { | |
157 | } | |
158 | ||
98963de4 PMF |
159 | int fd_notif = -1; |
160 | void notif_cb(void) | |
161 | { | |
162 | int result; | |
163 | struct trctl_msg msg; | |
164 | ||
165 | /* FIXME: fd_notif should probably be protected by a spinlock */ | |
166 | ||
167 | if(fd_notif == -1) | |
168 | return; | |
169 | ||
170 | msg.type = MSG_NOTIF; | |
171 | msg.size = sizeof(msg.type); | |
172 | ||
173 | /* FIXME: don't block here */ | |
174 | result = write(fd_notif, &msg, msg.size+sizeof(msg.size)); | |
175 | if(result == -1) { | |
176 | PERROR("write"); | |
177 | return; | |
178 | } | |
179 | } | |
180 | ||
d0b5f2b9 PMF |
181 | static int inform_consumer_daemon(void) |
182 | { | |
3847c3ba PMF |
183 | ustcomm_request_consumer(getpid(), "metadata"); |
184 | ustcomm_request_consumer(getpid(), "ust"); | |
d0b5f2b9 | 185 | } |
fbd8191b | 186 | |
98963de4 PMF |
187 | int listener_main(void *p) |
188 | { | |
189 | int result; | |
190 | ||
b0540e11 PMF |
191 | DBG("LISTENER"); |
192 | ||
98963de4 | 193 | for(;;) { |
98963de4 | 194 | uint32_t size; |
98963de4 PMF |
195 | struct sockaddr_un addr; |
196 | socklen_t addrlen = sizeof(addr); | |
aafb1650 PMF |
197 | char trace_name[] = "auto"; |
198 | char trace_type[] = "ustrelay"; | |
d0b5f2b9 PMF |
199 | char *recvbuf; |
200 | int len; | |
b02e31e5 | 201 | struct ustcomm_source src; |
98963de4 | 202 | |
688760ef PMF |
203 | result = ustcomm_app_recv_message(&ustcomm_app, &recvbuf, &src, -1); |
204 | if(result <= 0) { | |
d0b5f2b9 PMF |
205 | WARN("error in ustcomm_app_recv_message"); |
206 | continue; | |
207 | } | |
98963de4 | 208 | |
d0b5f2b9 PMF |
209 | DBG("received a message! it's: %s\n", recvbuf); |
210 | len = strlen(recvbuf); | |
98963de4 | 211 | |
d0b5f2b9 PMF |
212 | if(!strcmp(recvbuf, "print_markers")) { |
213 | print_markers(); | |
214 | } | |
215 | else if(!strcmp(recvbuf, "trace_setup")) { | |
216 | DBG("trace setup"); | |
fbd8191b | 217 | |
d0b5f2b9 PMF |
218 | result = ltt_trace_setup(trace_name); |
219 | if(result < 0) { | |
220 | ERR("ltt_trace_setup failed"); | |
221 | return; | |
fbd8191b | 222 | } |
d0b5f2b9 PMF |
223 | |
224 | result = ltt_trace_set_type(trace_name, trace_type); | |
225 | if(result < 0) { | |
226 | ERR("ltt_trace_set_type failed"); | |
227 | return; | |
fbd8191b | 228 | } |
d0b5f2b9 PMF |
229 | } |
230 | else if(!strcmp(recvbuf, "trace_alloc")) { | |
231 | DBG("trace alloc"); | |
232 | ||
233 | result = ltt_trace_alloc(trace_name); | |
234 | if(result < 0) { | |
235 | ERR("ltt_trace_alloc failed"); | |
236 | return; | |
fbd8191b | 237 | } |
d0b5f2b9 PMF |
238 | } |
239 | else if(!strcmp(recvbuf, "trace_start")) { | |
240 | DBG("trace start"); | |
241 | ||
242 | result = ltt_trace_start(trace_name); | |
243 | if(result < 0) { | |
244 | ERR("ltt_trace_start failed"); | |
245 | continue; | |
fbd8191b | 246 | } |
d0b5f2b9 PMF |
247 | } |
248 | else if(!strcmp(recvbuf, "trace_stop")) { | |
249 | DBG("trace stop"); | |
250 | ||
251 | result = ltt_trace_stop(trace_name); | |
252 | if(result < 0) { | |
253 | ERR("ltt_trace_stop failed"); | |
254 | return; | |
aafb1650 | 255 | } |
d0b5f2b9 PMF |
256 | } |
257 | else if(!strcmp(recvbuf, "trace_destroy")) { | |
aafb1650 | 258 | |
d0b5f2b9 | 259 | DBG("trace destroy"); |
aafb1650 | 260 | |
d0b5f2b9 PMF |
261 | result = ltt_trace_destroy(trace_name); |
262 | if(result < 0) { | |
263 | ERR("ltt_trace_destroy failed"); | |
264 | return; | |
fbd8191b | 265 | } |
98963de4 | 266 | } |
b02e31e5 | 267 | else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) { |
3847c3ba PMF |
268 | struct ltt_trace_struct *trace; |
269 | char trace_name[] = "auto"; | |
270 | int i; | |
811e4b93 | 271 | char *channel_name; |
3847c3ba PMF |
272 | |
273 | DBG("get_shmid"); | |
274 | ||
811e4b93 PMF |
275 | channel_name = nth_token(recvbuf, 1); |
276 | if(channel_name == NULL) { | |
277 | ERR("get_shmid: cannot parse channel"); | |
278 | goto next_cmd; | |
279 | } | |
280 | ||
3847c3ba PMF |
281 | ltt_lock_traces(); |
282 | trace = _ltt_trace_find(trace_name); | |
283 | ltt_unlock_traces(); | |
284 | ||
285 | if(trace == NULL) { | |
286 | CPRINTF("cannot find trace!"); | |
287 | return 1; | |
288 | } | |
289 | ||
290 | for(i=0; i<trace->nr_channels; i++) { | |
291 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
292 | struct rchan_buf *rbuf = rchan->buf; | |
293 | ||
811e4b93 PMF |
294 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { |
295 | char *reply; | |
296 | ||
297 | DBG("the shmid for the requested channel is %d", rbuf->shmid); | |
298 | asprintf(&reply, "%d", rbuf->shmid); | |
299 | ||
300 | result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); | |
301 | if(result) { | |
302 | ERR("listener: get_shmid: ustcomm_send_reply failed"); | |
303 | goto next_cmd; | |
304 | } | |
305 | ||
306 | free(reply); | |
307 | ||
308 | break; | |
309 | } | |
310 | } | |
311 | } | |
312 | else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) { | |
313 | struct ltt_trace_struct *trace; | |
314 | char trace_name[] = "auto"; | |
315 | int i; | |
316 | char *channel_name; | |
317 | ||
318 | DBG("get_n_subbufs"); | |
319 | ||
320 | channel_name = nth_token(recvbuf, 1); | |
321 | if(channel_name == NULL) { | |
322 | ERR("get_n_subbufs: cannot parse channel"); | |
323 | goto next_cmd; | |
324 | } | |
325 | ||
326 | ltt_lock_traces(); | |
327 | trace = _ltt_trace_find(trace_name); | |
328 | ltt_unlock_traces(); | |
329 | ||
330 | if(trace == NULL) { | |
331 | CPRINTF("cannot find trace!"); | |
332 | return 1; | |
333 | } | |
334 | ||
335 | for(i=0; i<trace->nr_channels; i++) { | |
336 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
337 | ||
338 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { | |
339 | char *reply; | |
340 | ||
341 | DBG("the n_subbufs for the requested channel is %d", rchan->n_subbufs); | |
342 | asprintf(&reply, "%d", rchan->n_subbufs); | |
343 | ||
344 | result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); | |
345 | if(result) { | |
346 | ERR("listener: get_n_subbufs: ustcomm_send_reply failed"); | |
347 | goto next_cmd; | |
348 | } | |
349 | ||
350 | free(reply); | |
351 | ||
352 | break; | |
353 | } | |
354 | } | |
355 | } | |
356 | else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) { | |
357 | struct ltt_trace_struct *trace; | |
358 | char trace_name[] = "auto"; | |
359 | int i; | |
360 | char *channel_name; | |
361 | ||
362 | DBG("get_subbuf_size"); | |
363 | ||
364 | channel_name = nth_token(recvbuf, 1); | |
365 | if(channel_name == NULL) { | |
366 | ERR("get_subbuf_size: cannot parse channel"); | |
367 | goto next_cmd; | |
368 | } | |
369 | ||
370 | ltt_lock_traces(); | |
371 | trace = _ltt_trace_find(trace_name); | |
372 | ltt_unlock_traces(); | |
373 | ||
374 | if(trace == NULL) { | |
375 | CPRINTF("cannot find trace!"); | |
376 | return 1; | |
377 | } | |
378 | ||
379 | for(i=0; i<trace->nr_channels; i++) { | |
380 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
381 | ||
382 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { | |
383 | char *reply; | |
384 | ||
385 | DBG("the subbuf_size for the requested channel is %d", rchan->subbuf_size); | |
386 | asprintf(&reply, "%d", rchan->subbuf_size); | |
387 | ||
388 | result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); | |
389 | if(result) { | |
390 | ERR("listener: get_subbuf_size: ustcomm_send_reply failed"); | |
391 | goto next_cmd; | |
392 | } | |
393 | ||
394 | free(reply); | |
3847c3ba | 395 | |
811e4b93 PMF |
396 | break; |
397 | } | |
3847c3ba PMF |
398 | } |
399 | } | |
b02e31e5 PMF |
400 | else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) { |
401 | char *libfile; | |
402 | ||
403 | libfile = nth_token(recvbuf, 1); | |
404 | ||
405 | DBG("load_probe_lib loading %s", libfile); | |
406 | } | |
688760ef PMF |
407 | else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) { |
408 | struct ltt_trace_struct *trace; | |
409 | char trace_name[] = "auto"; | |
410 | int i; | |
411 | char *channel_name; | |
412 | ||
413 | DBG("get_subbuf"); | |
414 | ||
415 | channel_name = nth_token(recvbuf, 1); | |
416 | if(channel_name == NULL) { | |
417 | ERR("get_subbuf: cannot parse channel"); | |
418 | goto next_cmd; | |
419 | } | |
420 | ||
421 | ltt_lock_traces(); | |
422 | trace = _ltt_trace_find(trace_name); | |
423 | ltt_unlock_traces(); | |
424 | ||
425 | if(trace == NULL) { | |
426 | CPRINTF("cannot find trace!"); | |
427 | return 1; | |
428 | } | |
429 | ||
430 | for(i=0; i<trace->nr_channels; i++) { | |
431 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
432 | ||
433 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { | |
434 | struct rchan_buf *rbuf = rchan->buf; | |
435 | struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; | |
436 | char *reply; | |
437 | long consumed_old=0; | |
438 | ||
439 | result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); | |
440 | if(result < 0) { | |
441 | DBG("ltt_do_get_subbuf: error: %s", strerror(-result)); | |
442 | asprintf(&reply, "%s %ld", "UNAVAIL", 0); | |
443 | } | |
444 | else { | |
445 | DBG("ltt_do_get_subbuf: success"); | |
446 | asprintf(&reply, "%s %ld", "OK", consumed_old); | |
447 | } | |
448 | ||
449 | result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); | |
450 | if(result) { | |
451 | ERR("listener: get_subbuf: ustcomm_send_reply failed"); | |
452 | goto next_cmd; | |
453 | } | |
454 | ||
455 | free(reply); | |
456 | ||
457 | break; | |
458 | } | |
459 | } | |
460 | } | |
461 | else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) { | |
462 | struct ltt_trace_struct *trace; | |
463 | char trace_name[] = "auto"; | |
464 | int i; | |
465 | char *channel_name; | |
466 | long consumed_old; | |
467 | char *consumed_old_str; | |
468 | char *endptr; | |
469 | ||
470 | DBG("put_subbuf"); | |
471 | ||
472 | channel_name = strdup_malloc(nth_token(recvbuf, 1)); | |
473 | if(channel_name == NULL) { | |
474 | ERR("put_subbuf_size: cannot parse channel"); | |
475 | goto next_cmd; | |
476 | } | |
477 | ||
478 | consumed_old_str = strdup_malloc(nth_token(recvbuf, 2)); | |
479 | if(consumed_old_str == NULL) { | |
480 | ERR("put_subbuf: cannot parse consumed_old"); | |
481 | goto next_cmd; | |
482 | } | |
483 | consumed_old = strtol(consumed_old_str, &endptr, 10); | |
484 | if(*endptr != '\0') { | |
485 | ERR("put_subbuf: invalid value for consumed_old"); | |
486 | goto next_cmd; | |
487 | } | |
488 | ||
489 | ltt_lock_traces(); | |
490 | trace = _ltt_trace_find(trace_name); | |
491 | ltt_unlock_traces(); | |
492 | ||
493 | if(trace == NULL) { | |
494 | CPRINTF("cannot find trace!"); | |
495 | return 1; | |
496 | } | |
497 | ||
498 | for(i=0; i<trace->nr_channels; i++) { | |
499 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
500 | ||
501 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { | |
502 | struct rchan_buf *rbuf = rchan->buf; | |
503 | struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; | |
504 | char *reply; | |
505 | long consumed_old=0; | |
506 | ||
507 | result = ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); | |
508 | if(result < 0) { | |
509 | WARN("ltt_do_put_subbuf: error"); | |
510 | } | |
511 | else { | |
512 | DBG("ltt_do_put_subbuf: success"); | |
513 | } | |
514 | asprintf(&reply, "%s", "OK", consumed_old); | |
515 | ||
516 | result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); | |
517 | if(result) { | |
518 | ERR("listener: put_subbuf: ustcomm_send_reply failed"); | |
519 | goto next_cmd; | |
520 | } | |
521 | ||
522 | free(reply); | |
523 | ||
524 | break; | |
525 | } | |
526 | } | |
527 | ||
528 | free(channel_name); | |
529 | free(consumed_old_str); | |
530 | } | |
46ef48cd PMF |
531 | else if(nth_token_is(recvbuf, "get_notifications", 0) == 1) { |
532 | struct ltt_trace_struct *trace; | |
533 | char trace_name[] = "auto"; | |
534 | int i; | |
535 | char *channel_name; | |
536 | ||
537 | DBG("get_notifications"); | |
538 | ||
539 | channel_name = strdup_malloc(nth_token(recvbuf, 1)); | |
540 | if(channel_name == NULL) { | |
541 | ERR("put_subbuf_size: cannot parse channel"); | |
542 | goto next_cmd; | |
543 | } | |
544 | ||
545 | ltt_lock_traces(); | |
546 | trace = _ltt_trace_find(trace_name); | |
547 | ltt_unlock_traces(); | |
548 | ||
549 | if(trace == NULL) { | |
550 | CPRINTF("cannot find trace!"); | |
551 | return 1; | |
552 | } | |
553 | ||
554 | for(i=0; i<trace->nr_channels; i++) { | |
555 | struct rchan *rchan = trace->channels[i].trans_channel_data; | |
556 | int fd; | |
557 | ||
558 | if(!strcmp(trace->channels[i].channel_name, channel_name)) { | |
559 | struct rchan_buf *rbuf = rchan->buf; | |
560 | struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; | |
561 | ||
562 | result = fd = ustcomm_app_detach_client(&ustcomm_app, &src); | |
563 | if(result == -1) { | |
564 | ERR("ustcomm_app_detach_client failed"); | |
565 | goto next_cmd; | |
566 | } | |
567 | ||
568 | lttbuf->wake_consumer_arg = (void *) fd; | |
569 | ||
570 | smp_wmb(); | |
571 | ||
572 | lttbuf->call_wake_consumer = 1; | |
573 | ||
574 | break; | |
575 | } | |
576 | } | |
577 | ||
578 | free(channel_name); | |
579 | } | |
688760ef PMF |
580 | else { |
581 | ERR("unable to parse message: %s", recvbuf); | |
582 | } | |
d0b5f2b9 | 583 | |
811e4b93 | 584 | next_cmd: |
d0b5f2b9 | 585 | free(recvbuf); |
98963de4 PMF |
586 | } |
587 | } | |
588 | ||
b0540e11 PMF |
589 | static char listener_stack[16384]; |
590 | ||
98963de4 PMF |
591 | void create_listener(void) |
592 | { | |
593 | int result; | |
594 | static char listener_stack[16384]; | |
b0540e11 | 595 | //char *listener_stack = malloc(16384); |
98963de4 | 596 | |
3847c3ba | 597 | #ifdef USE_CLONE |
fbd8191b | 598 | result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL); |
98963de4 PMF |
599 | if(result == -1) { |
600 | perror("clone"); | |
601 | } | |
3847c3ba PMF |
602 | #else |
603 | pthread_t thread; | |
b0540e11 | 604 | |
3847c3ba PMF |
605 | pthread_create(&thread, NULL, listener_main, NULL); |
606 | #endif | |
98963de4 PMF |
607 | } |
608 | ||
d0b5f2b9 PMF |
609 | /* The signal handler itself. Signals must be setup so there cannot be |
610 | nested signals. */ | |
68c1021b PMF |
611 | |
612 | void sighandler(int sig) | |
613 | { | |
d0b5f2b9 | 614 | static char have_listener = 0; |
68c1021b | 615 | DBG("sighandler"); |
d0b5f2b9 PMF |
616 | |
617 | if(!have_listener) { | |
618 | create_listener(); | |
619 | have_listener = 1; | |
620 | } | |
68c1021b PMF |
621 | } |
622 | ||
623 | /* Called by the app signal handler to chain it to us. */ | |
624 | ||
98963de4 | 625 | void chain_signal(void) |
68c1021b PMF |
626 | { |
627 | sighandler(USTSIGNAL); | |
628 | } | |
629 | ||
98963de4 | 630 | static int init_socket(void) |
68c1021b | 631 | { |
d0b5f2b9 | 632 | return ustcomm_init_app(getpid(), &ustcomm_app); |
68c1021b PMF |
633 | } |
634 | ||
98963de4 | 635 | static void destroy_socket(void) |
68c1021b | 636 | { |
46ef48cd PMF |
637 | // int result; |
638 | // | |
639 | // if(mysocketfile[0] == '\0') | |
640 | // return; | |
641 | // | |
642 | // result = unlink(mysocketfile); | |
643 | // if(result == -1) { | |
644 | // PERROR("unlink"); | |
645 | // } | |
68c1021b PMF |
646 | } |
647 | ||
98963de4 | 648 | static int init_signal_handler(void) |
68c1021b PMF |
649 | { |
650 | /* Attempt to handler SIGIO. If the main program wants to | |
651 | * handle it, fine, it'll override us. They it'll have to | |
652 | * use the chaining function. | |
653 | */ | |
654 | ||
655 | int result; | |
656 | struct sigaction act; | |
657 | ||
658 | result = sigemptyset(&act.sa_mask); | |
659 | if(result == -1) { | |
660 | PERROR("sigemptyset"); | |
661 | return -1; | |
662 | } | |
663 | ||
664 | act.sa_handler = sighandler; | |
665 | act.sa_flags = SA_RESTART; | |
666 | ||
667 | /* Only defer ourselves. Also, try to restart interrupted | |
668 | * syscalls to disturb the traced program as little as possible. | |
669 | */ | |
670 | result = sigaction(SIGIO, &act, NULL); | |
671 | if(result == -1) { | |
672 | PERROR("sigaction"); | |
673 | return -1; | |
674 | } | |
675 | ||
676 | return 0; | |
677 | } | |
678 | ||
20b37a31 | 679 | static void auto_probe_connect(struct marker *m) |
68c1021b PMF |
680 | { |
681 | int result; | |
682 | ||
20b37a31 PMF |
683 | result = ltt_marker_connect(m->channel, m->name, "default"); |
684 | if(result) | |
685 | ERR("ltt_marker_connect"); | |
686 | ||
687 | DBG("just auto connected marker %s %s to probe default", m->channel, m->name); | |
688 | } | |
689 | ||
46ef48cd PMF |
690 | /* Wake the consumer of a buffer |
691 | * | |
692 | * wake_consumer_cb is called in tracing context so it must haste. | |
693 | * | |
694 | * FIXME: don't do a system call here; maybe schedule work to be done | |
695 | * in listener context? Once this is done in listener context, we can | |
696 | * check for the return value of send_message_fd and remove the fd if necessary | |
697 | * | |
698 | * @arg: the buffer | |
699 | * @finished: 0: subbuffer full; 1: buffer being destroyed | |
700 | */ | |
701 | ||
702 | static void wake_consumer_cb(void *arg, int finished) | |
703 | { | |
704 | struct ltt_channel_buf_struct *ltt_buf = (struct ltt_channel_buf_struct *) arg; | |
705 | int fd = (int)ACCESS_ONCE(arg); | |
706 | ||
707 | if(!finished) { | |
708 | send_message_fd(fd, "consume", NULL); | |
709 | } | |
710 | else { | |
711 | send_message_fd(fd, "destroyed", NULL); | |
712 | } | |
713 | } | |
714 | ||
20b37a31 PMF |
715 | static void __attribute__((constructor(101))) init0() |
716 | { | |
717 | DBG("UST_AUTOPROBE constructor"); | |
718 | if(getenv("UST_AUTOPROBE")) { | |
719 | marker_set_new_marker_cb(auto_probe_connect); | |
720 | } | |
46ef48cd PMF |
721 | |
722 | relay_set_wake_consumer(wake_consumer_cb); | |
20b37a31 PMF |
723 | } |
724 | ||
a584bc4e PMF |
725 | static void fini(void); |
726 | ||
20b37a31 PMF |
727 | static void __attribute__((constructor(1000))) init() |
728 | { | |
729 | int result; | |
730 | ||
731 | DBG("UST_TRACE constructor"); | |
732 | ||
3847c3ba PMF |
733 | /* Must create socket before signal handler to prevent races. |
734 | */ | |
735 | result = init_socket(); | |
736 | if(result == -1) { | |
737 | ERR("init_socket error"); | |
738 | return; | |
739 | } | |
740 | result = init_signal_handler(); | |
741 | if(result == -1) { | |
742 | ERR("init_signal_handler error"); | |
743 | return; | |
744 | } | |
68c1021b | 745 | |
4db647c5 PMF |
746 | if(getenv("UST_TRACE")) { |
747 | char trace_name[] = "auto"; | |
748 | char trace_type[] = "ustrelay"; | |
749 | ||
750 | DBG("starting early tracing"); | |
751 | ||
752 | /* Ensure marker control is initialized */ | |
753 | init_marker_control(); | |
754 | ||
755 | /* Ensure relay is initialized */ | |
756 | init_ustrelay_transport(); | |
757 | ||
758 | /* Ensure markers are initialized */ | |
759 | init_markers(); | |
760 | ||
20b37a31 PMF |
761 | /* In case. */ |
762 | ltt_channels_register("ust"); | |
4db647c5 PMF |
763 | |
764 | result = ltt_trace_setup(trace_name); | |
765 | if(result < 0) { | |
766 | ERR("ltt_trace_setup failed"); | |
767 | return; | |
768 | } | |
769 | ||
770 | result = ltt_trace_set_type(trace_name, trace_type); | |
771 | if(result < 0) { | |
772 | ERR("ltt_trace_set_type failed"); | |
773 | return; | |
774 | } | |
775 | ||
776 | result = ltt_trace_alloc(trace_name); | |
777 | if(result < 0) { | |
778 | ERR("ltt_trace_alloc failed"); | |
779 | return; | |
780 | } | |
781 | ||
782 | result = ltt_trace_start(trace_name); | |
783 | if(result < 0) { | |
784 | ERR("ltt_trace_start failed"); | |
785 | return; | |
786 | } | |
3847c3ba PMF |
787 | //start_consumer(); |
788 | inform_consumer_daemon(); | |
4db647c5 PMF |
789 | } |
790 | ||
68c1021b PMF |
791 | |
792 | return; | |
793 | ||
794 | /* should decrementally destroy stuff if error */ | |
795 | ||
796 | } | |
797 | ||
798 | /* This is only called if we terminate normally, not with an unhandled signal, | |
799 | * so we cannot rely on it. */ | |
800 | ||
98963de4 | 801 | static void __attribute__((destructor)) fini() |
68c1021b | 802 | { |
a584bc4e PMF |
803 | int result; |
804 | ||
805 | /* if trace running, finish it */ | |
806 | ||
807 | DBG("destructor stopping traces"); | |
808 | ||
809 | result = ltt_trace_stop("auto"); | |
810 | if(result == -1) { | |
811 | ERR("ltt_trace_stop error"); | |
812 | } | |
813 | ||
814 | result = ltt_trace_destroy("auto"); | |
815 | if(result == -1) { | |
816 | ERR("ltt_trace_destroy error"); | |
817 | } | |
818 | ||
819 | /* FIXME: wait for the consumer to be done */ | |
688760ef PMF |
820 | DBG("waiting 5 sec for consume"); |
821 | sleep(5); | |
a584bc4e | 822 | |
68c1021b PMF |
823 | destroy_socket(); |
824 | } |