bc3fff3d55b3e0d5023e3ff910658637fa82c435
2 * Copyright (C) 2011-2012 Julien Desfossez
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 #include <babeltrace/ctf/events.h>
20 #include <linux/unistd.h>
24 uint64_t get_cpu_id(const struct bt_ctf_event
*event
)
26 const struct bt_definition
*scope
;
29 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_PACKET_CONTEXT
);
30 cpu_id
= bt_ctf_get_uint64(bt_ctf_get_field(event
, scope
, "cpu_id"));
31 if (bt_ctf_field_get_error()) {
32 fprintf(stderr
, "[error] get cpu_id\n");
39 uint64_t get_context_tid(const struct bt_ctf_event
*event
)
41 const struct bt_definition
*scope
;
44 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
45 tid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
47 if (bt_ctf_field_get_error()) {
48 fprintf(stderr
, "Missing tid context info\n");
55 uint64_t get_context_pid(const struct bt_ctf_event
*event
)
57 const struct bt_definition
*scope
;
60 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
61 pid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
63 if (bt_ctf_field_get_error()) {
64 fprintf(stderr
, "Missing pid context info\n");
71 uint64_t get_context_ppid(const struct bt_ctf_event
*event
)
73 const struct bt_definition
*scope
;
76 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
77 ppid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
79 if (bt_ctf_field_get_error()) {
80 fprintf(stderr
, "Missing ppid context info\n");
87 uint64_t get_context_vtid(const struct bt_ctf_event
*event
)
89 const struct definition
*scope
;
92 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
93 vtid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
95 if (bt_ctf_field_get_error()) {
102 uint64_t get_context_vpid(const struct bt_ctf_event
*event
)
104 const struct definition
*scope
;
107 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
108 vpid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
110 if (bt_ctf_field_get_error()) {
117 uint64_t get_context_vppid(const struct bt_ctf_event
*event
)
119 const struct definition
*scope
;
122 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
123 vppid
= bt_ctf_get_int64(bt_ctf_get_field(event
,
125 if (bt_ctf_field_get_error()) {
132 char *get_context_comm(const struct bt_ctf_event
*event
)
134 const struct bt_definition
*scope
;
137 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
138 comm
= bt_ctf_get_char_array(bt_ctf_get_field(event
,
139 scope
, "_procname"));
140 if (bt_ctf_field_get_error()) {
141 fprintf(stderr
, "Missing comm context info\n");
148 char *get_context_hostname(const struct bt_ctf_event
*event
)
150 const struct definition
*scope
;
153 scope
= bt_ctf_get_top_level_scope(event
, BT_STREAM_EVENT_CONTEXT
);
154 hostname
= bt_ctf_get_char_array(bt_ctf_get_field(event
,
155 scope
, "_hostname"));
156 if (bt_ctf_field_get_error()) {
164 * To get the parent process, put the pid in the tid field
165 * because the parent process gets pid = tid
167 struct processtop
*find_process_tid(struct lttngtop
*ctx
, int tid
, char *comm
)
169 struct processtop
*tmp
;
171 tmp
= g_hash_table_lookup(ctx
->process_hash_table
,
172 (gconstpointer
) (unsigned long) tid
);
177 struct processtop
* add_proc(struct lttngtop
*ctx
, int tid
, char *comm
,
178 unsigned long timestamp
, char *hostname
)
180 struct processtop
*newproc
;
182 /* if the PID already exists, we just rename the process */
183 /* FIXME : need to integrate with clone/fork/exit to be accurate */
184 newproc
= find_process_tid(ctx
, tid
, comm
);
187 newproc
= g_new0(struct processtop
, 1);
189 newproc
->birth
= timestamp
;
190 newproc
->process_files_table
= g_ptr_array_new();
191 newproc
->files_history
= NULL
;
192 newproc
->totalfileread
= 0;
193 newproc
->totalfilewrite
= 0;
194 newproc
->fileread
= 0;
195 newproc
->filewrite
= 0;
196 newproc
->syscall_info
= NULL
;
197 newproc
->threadparent
= NULL
;
198 newproc
->threads
= g_ptr_array_new();
199 newproc
->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
200 g_ptr_array_add(ctx
->process_table
, newproc
);
201 g_hash_table_insert(ctx
->process_hash_table
,
202 (gpointer
) (unsigned long) tid
, newproc
);
203 if (lookup_tid_list(tid
)) {
204 add_filter_tid_list(tid
, newproc
);
209 newproc
->comm
= strdup(comm
);
211 if (newproc
->hostname
&& strcmp(newproc
->hostname
, hostname
) != 0) {
212 free(newproc
->hostname
);
214 newproc
->hostname
= strdup(hostname
);
215 if (is_hostname_filtered(hostname
)) {
216 add_filter_tid_list(tid
, newproc
);
218 add_hostname_list(hostname
, 0);
224 struct processtop
* update_proc(struct processtop
* proc
, int pid
, int tid
,
225 int ppid
, int vpid
, int vtid
, int vppid
, char *comm
, char *hostname
)
234 if (strcmp(proc
->comm
, comm
) != 0) {
236 proc
->comm
= strdup(comm
);
238 if (hostname
&& !proc
->hostname
) {
239 proc
->hostname
= strdup(hostname
);
240 if (is_hostname_filtered(hostname
)) {
241 add_filter_tid_list(tid
, proc
);
243 add_hostname_list(hostname
, 0);
250 * This function just sets the time of death of a process.
251 * When we rotate the cputime we remove it from the process list.
253 void death_proc(struct lttngtop
*ctx
, int tid
, char *comm
,
254 unsigned long timestamp
)
256 struct processtop
*tmp
;
257 tmp
= find_process_tid(ctx
, tid
, comm
);
259 g_hash_table_remove(ctx
->process_hash_table
,
260 (gpointer
) (unsigned long) tid
);
261 if (tmp
&& strcmp(tmp
->comm
, comm
) == 0) {
262 tmp
->death
= timestamp
;
263 ctx
->nbdeadthreads
++;
268 struct processtop
* get_proc(struct lttngtop
*ctx
, int tid
, char *comm
,
269 unsigned long timestamp
, char *hostname
)
271 struct processtop
*tmp
;
273 tmp
= find_process_tid(ctx
, tid
, comm
);
274 if (tmp
&& strcmp(tmp
->comm
, comm
) == 0) {
277 return add_proc(ctx
, tid
, comm
, timestamp
, hostname
);
280 struct processtop
*get_proc_pid(struct lttngtop
*ctx
, int tid
, int pid
,
281 unsigned long timestamp
, char *hostname
)
283 struct processtop
*tmp
;
284 tmp
= find_process_tid(ctx
, tid
, NULL
);
285 if (tmp
&& tmp
->pid
== pid
)
287 return add_proc(ctx
, tid
, "Unknown", timestamp
, hostname
);
290 void add_thread(struct processtop
*parent
, struct processtop
*thread
)
293 struct processtop
*tmp
;
298 for (i
= 0; i
< parent
->threads
->len
; i
++) {
299 tmp
= g_ptr_array_index(parent
->threads
, i
);
303 g_ptr_array_add(parent
->threads
, thread
);
306 struct cputime
* add_cpu(int cpu
)
308 struct cputime
*newcpu
;
310 newcpu
= g_new0(struct cputime
, 1);
312 newcpu
->current_task
= NULL
;
313 newcpu
->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
315 g_ptr_array_add(lttngtop
.cpu_table
, newcpu
);
319 struct cputime
* get_cpu(int cpu
)
324 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
325 tmp
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
334 * At the end of a sampling period, we need to display the cpu time for each
335 * process and to reset it to zero for the next period
337 void rotate_cputime(unsigned long end
)
341 unsigned long elapsed
;
343 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
344 tmp
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
345 elapsed
= end
- tmp
->task_start
;
346 if (tmp
->current_task
) {
347 tmp
->current_task
->totalcpunsec
+= elapsed
;
348 tmp
->current_task
->threadstotalcpunsec
+= elapsed
;
349 if (tmp
->current_task
->pid
!= tmp
->current_task
->tid
&&
350 tmp
->current_task
->threadparent
) {
351 tmp
->current_task
->threadparent
->threadstotalcpunsec
+= elapsed
;
354 tmp
->task_start
= end
;
358 void reset_perf_counter(gpointer key
, gpointer value
, gpointer user_data
)
360 ((struct perfcounter
*) value
)->count
= 0;
363 void copy_perf_counter(gpointer key
, gpointer value
, gpointer new_table
)
365 struct perfcounter
*newperf
;
367 newperf
= g_new0(struct perfcounter
, 1);
368 newperf
->count
= ((struct perfcounter
*) value
)->count
;
369 newperf
->visible
= ((struct perfcounter
*) value
)->visible
;
370 newperf
->sort
= ((struct perfcounter
*) value
)->sort
;
371 g_hash_table_insert((GHashTable
*) new_table
, strdup(key
), newperf
);
374 void copy_process_table(gpointer key
, gpointer value
, gpointer new_table
)
376 g_hash_table_insert((GHashTable
*) new_table
, key
, value
);
379 void rotate_perfcounter() {
381 struct processtop
*tmp
;
382 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
383 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
384 g_hash_table_foreach(tmp
->perf
, reset_perf_counter
, NULL
);
388 void cleanup_processtop()
391 struct processtop
*tmp
;
392 struct files
*tmpf
; /* a temporary file */
394 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
395 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
396 tmp
->totalcpunsec
= 0;
397 tmp
->threadstotalcpunsec
= 0;
401 for (j
= 0; j
< tmp
->process_files_table
->len
; j
++) {
402 tmpf
= g_ptr_array_index(tmp
->process_files_table
, j
);
407 if (tmpf
->flag
== __NR_close
)
409 tmp
->process_files_table
, j
416 void reset_global_counters()
418 lttngtop
.nbnewproc
= 0;
419 lttngtop
.nbdeadproc
= 0;
420 lttngtop
.nbnewthreads
= 0;
421 lttngtop
.nbdeadthreads
= 0;
422 lttngtop
.nbnewfiles
= 0;
423 lttngtop
.nbclosedfiles
= 0;
426 void copy_global_counters(struct lttngtop
*dst
)
428 dst
->nbproc
= lttngtop
.nbproc
;
429 dst
->nbnewproc
= lttngtop
.nbnewproc
;
430 dst
->nbdeadproc
= lttngtop
.nbdeadproc
;
431 dst
->nbthreads
= lttngtop
.nbthreads
;
432 dst
->nbnewthreads
= lttngtop
.nbnewthreads
;
433 dst
->nbdeadthreads
= lttngtop
.nbdeadthreads
;
434 dst
->nbfiles
= lttngtop
.nbfiles
;
435 dst
->nbnewfiles
= lttngtop
.nbnewfiles
;
436 dst
->nbclosedfiles
= lttngtop
.nbclosedfiles
;
437 reset_global_counters();
440 struct lttngtop
* get_copy_lttngtop(unsigned long start
, unsigned long end
)
444 struct lttngtop
*dst
;
445 struct processtop
*tmp
, *tmp2
, *new;
446 struct cputime
*tmpcpu
, *newcpu
;
447 struct files
*tmpfile
, *newfile
;
448 struct kprobes
*tmpprobe
, *newprobe
;
450 dst
= g_new0(struct lttngtop
, 1);
453 copy_global_counters(dst
);
454 dst
->process_table
= g_ptr_array_new();
455 dst
->files_table
= g_ptr_array_new();
456 dst
->cpu_table
= g_ptr_array_new();
457 dst
->kprobes_table
= g_ptr_array_new();
458 dst
->process_hash_table
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
459 g_hash_table_foreach(lttngtop
.process_hash_table
, copy_process_table
,
460 dst
->process_hash_table
);
464 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
465 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
466 new = g_new0(struct processtop
, 1);
468 memcpy(new, tmp
, sizeof(struct processtop
));
469 new->threads
= g_ptr_array_new();
470 new->comm
= strdup(tmp
->comm
);
471 new->process_files_table
= g_ptr_array_new();
472 new->files_history
= tmp
->files_history
;
473 new->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
474 g_hash_table_foreach(tmp
->perf
, copy_perf_counter
, new->perf
);
476 /* compute the stream speed */
477 if (end
- start
!= 0) {
478 time
= (end
- start
) / NSEC_PER_SEC
;
479 new->fileread
= new->fileread
/(time
);
480 new->filewrite
= new->filewrite
/(time
);
483 for (j
= 0; j
< tmp
->process_files_table
->len
; j
++) {
484 tmpfile
= g_ptr_array_index(tmp
->process_files_table
, j
);
486 newfile
= malloc(sizeof(struct files
));
488 if (tmpfile
!= NULL
) {
489 memcpy(newfile
, tmpfile
, sizeof(struct files
));
490 newfile
->name
= strdup(tmpfile
->name
);
492 g_ptr_array_add(new->process_files_table
,
494 g_ptr_array_add(dst
->files_table
, newfile
);
496 g_ptr_array_add(new->process_files_table
, NULL
);
497 g_ptr_array_add(dst
->files_table
, NULL
);
500 * if the process died during the last period, we remove all
501 * files associated with if after the copy
503 if (tmp
->death
> 0 && tmp
->death
< end
) {
504 /* FIXME : close the files before */
505 g_ptr_array_remove(tmp
->process_files_table
, tmpfile
);
509 g_ptr_array_add(dst
->process_table
, new);
512 * if the process died during the last period, we remove it from
513 * the current process list after the copy
515 if (tmp
->death
> 0 && tmp
->death
< end
) {
516 g_ptr_array_remove(lttngtop
.process_table
, tmp
);
517 /* FIXME : TRUE does not mean clears the object in it */
518 g_ptr_array_free(tmp
->threads
, TRUE
);
520 g_ptr_array_free(tmp
->process_files_table
, TRUE
);
521 /* FIXME : clear elements */
522 g_hash_table_destroy(tmp
->perf
);
526 rotate_perfcounter();
528 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
529 tmpcpu
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
530 newcpu
= g_new0(struct cputime
, 1);
531 memcpy(newcpu
, tmpcpu
, sizeof(struct cputime
));
532 newcpu
->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
533 g_hash_table_foreach(tmpcpu
->perf
, copy_perf_counter
, newcpu
->perf
);
535 * note : we don't care about the current process pointer in the copy
536 * so the reference is invalid after the memcpy
538 g_ptr_array_add(dst
->cpu_table
, newcpu
);
540 if (lttngtop
.kprobes_table
) {
541 for (i
= 0; i
< lttngtop
.kprobes_table
->len
; i
++) {
542 tmpprobe
= g_ptr_array_index(lttngtop
.kprobes_table
, i
);
543 newprobe
= g_new0(struct kprobes
, 1);
544 memcpy(newprobe
, tmpprobe
, sizeof(struct kprobes
));
546 g_ptr_array_add(dst
->kprobes_table
, newprobe
);
549 /* FIXME : better algo */
550 /* create the threads index if required */
551 for (i
= 0; i
< dst
->process_table
->len
; i
++) {
552 tmp
= g_ptr_array_index(dst
->process_table
, i
);
553 if (tmp
->pid
== tmp
->tid
) {
554 for (j
= 0; j
< dst
->process_table
->len
; j
++) {
555 tmp2
= g_ptr_array_index(dst
->process_table
, j
);
556 if (tmp2
->pid
== tmp
->pid
) {
557 tmp2
->threadparent
= tmp
;
558 g_ptr_array_add(tmp
->threads
, tmp2
);
564 // update_global_stats(dst);
565 cleanup_processtop();
571 enum bt_cb_ret
handle_statedump_process_state(struct bt_ctf_event
*call_data
,
574 const struct bt_definition
*scope
;
575 struct processtop
*proc
;
576 unsigned long timestamp
;
577 int64_t pid
, tid
, ppid
, vtid
, vpid
, vppid
;
578 char *procname
, *hostname
= NULL
;
580 timestamp
= bt_ctf_get_timestamp(call_data
);
581 if (timestamp
== -1ULL)
584 scope
= bt_ctf_get_top_level_scope(call_data
,
586 pid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
588 if (bt_ctf_field_get_error()) {
589 fprintf(stderr
, "Missing pid context info\n");
592 ppid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
594 if (bt_ctf_field_get_error()) {
595 fprintf(stderr
, "Missing ppid context info\n");
598 tid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
600 if (bt_ctf_field_get_error()) {
601 fprintf(stderr
, "Missing tid context info\n");
604 vtid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
606 if (bt_ctf_field_get_error()) {
607 fprintf(stderr
, "Missing vtid context info\n");
610 vpid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
612 if (bt_ctf_field_get_error()) {
613 fprintf(stderr
, "Missing vpid context info\n");
616 vppid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
618 if (bt_ctf_field_get_error()) {
619 fprintf(stderr
, "Missing vppid context info\n");
623 scope
= bt_ctf_get_top_level_scope(call_data
,
625 procname
= bt_ctf_get_char_array(bt_ctf_get_field(call_data
,
627 if (bt_ctf_field_get_error()) {
628 fprintf(stderr
, "Missing process name context info\n");
632 hostname = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
633 scope, "_hostname"));
634 if (bt_ctf_field_get_error()) {
638 proc
= find_process_tid(<tngtop
, tid
, procname
);
640 proc
= add_proc(<tngtop
, tid
, procname
, timestamp
, hostname
);
641 update_proc(proc
, pid
, tid
, ppid
, vpid
, vtid
, vppid
, procname
, hostname
);
645 proc
->comm
= strdup(procname
);
652 return BT_CB_ERROR_STOP
;
655 struct tm
format_timestamp(uint64_t timestamp
)
658 uint64_t ts_sec
= 0, ts_nsec
;
662 ts_sec
+= ts_nsec
/ NSEC_PER_SEC
;
663 ts_nsec
= ts_nsec
% NSEC_PER_SEC
;
665 time_s
= (time_t) ts_sec
;
667 localtime_r(&time_s
, &tm
);
672 int *lookup_tid_list(int tid
)
674 if (!tid_filter_list
)
677 return g_hash_table_lookup(tid_filter_list
, (gpointer
) &tid
);
680 struct host
*lookup_hostname_list(const char *hostname
)
682 if (!hostname
|| !global_host_list
)
685 return g_hash_table_lookup(global_host_list
, (gpointer
) hostname
);
688 int is_hostname_filtered(const char *hostname
)
692 host
= lookup_hostname_list(hostname
);
698 int *lookup_filter_tid_list(int tid
)
700 return g_hash_table_lookup(global_filter_list
, (gpointer
) &tid
);
703 void add_filter_tid_list(int tid
, struct processtop
*newproc
)
705 unsigned long *hash_tid
;
707 hash_tid
= malloc(sizeof(unsigned long));
709 g_hash_table_insert(global_filter_list
,
710 (gpointer
) (unsigned long) hash_tid
, newproc
);
713 void remove_filter_tid_list(int tid
)
715 g_hash_table_remove(global_filter_list
,
716 (gpointer
) (unsigned long) &tid
);
719 void add_hostname_list(char *hostname
, int filter
)
723 if (lookup_hostname_list(hostname
))
726 host
= g_new0(struct host
, 1);
727 host
->hostname
= strdup(hostname
);
728 host
->filter
= filter
;
729 g_hash_table_insert(global_host_list
,
730 (gpointer
) host
->hostname
,
This page took 0.051717 seconds and 3 git commands to generate.