1fc74be4084f41fe771ae5dd41b84bae485522fc
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
)
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
);
207 newproc
->comm
= strdup(comm
);
212 struct processtop
* update_proc(struct processtop
* proc
, int pid
, int tid
,
213 int ppid
, int vpid
, int vtid
, int vppid
, char *comm
, char *hostname
)
222 if (strcmp(proc
->comm
, comm
) != 0) {
224 proc
->comm
= strdup(comm
);
227 if (proc
->hostname
&& strcmp(proc
->hostname
, hostname
) != 0) {
228 free(proc
->hostname
);
230 proc
->hostname
= strdup(hostname
);
237 * This function just sets the time of death of a process.
238 * When we rotate the cputime we remove it from the process list.
240 void death_proc(struct lttngtop
*ctx
, int tid
, char *comm
,
241 unsigned long timestamp
)
243 struct processtop
*tmp
;
244 tmp
= find_process_tid(ctx
, tid
, comm
);
246 g_hash_table_remove(ctx
->process_hash_table
,
247 (gpointer
) (unsigned long) tid
);
248 if (tmp
&& strcmp(tmp
->comm
, comm
) == 0) {
249 tmp
->death
= timestamp
;
250 ctx
->nbdeadthreads
++;
255 struct processtop
* get_proc(struct lttngtop
*ctx
, int tid
, char *comm
,
256 unsigned long timestamp
)
258 struct processtop
*tmp
;
259 tmp
= find_process_tid(ctx
, tid
, comm
);
260 if (tmp
&& strcmp(tmp
->comm
, comm
) == 0)
262 return add_proc(ctx
, tid
, comm
, timestamp
);
265 struct processtop
*get_proc_pid(struct lttngtop
*ctx
, int tid
, int pid
,
266 unsigned long timestamp
)
268 struct processtop
*tmp
;
269 tmp
= find_process_tid(ctx
, tid
, NULL
);
270 if (tmp
&& tmp
->pid
== pid
)
272 return add_proc(ctx
, tid
, "Unknown", timestamp
);
275 void add_thread(struct processtop
*parent
, struct processtop
*thread
)
278 struct processtop
*tmp
;
283 for (i
= 0; i
< parent
->threads
->len
; i
++) {
284 tmp
= g_ptr_array_index(parent
->threads
, i
);
288 g_ptr_array_add(parent
->threads
, thread
);
291 struct cputime
* add_cpu(int cpu
)
293 struct cputime
*newcpu
;
295 newcpu
= g_new0(struct cputime
, 1);
297 newcpu
->current_task
= NULL
;
298 newcpu
->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
300 g_ptr_array_add(lttngtop
.cpu_table
, newcpu
);
304 struct cputime
* get_cpu(int cpu
)
309 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
310 tmp
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
319 * At the end of a sampling period, we need to display the cpu time for each
320 * process and to reset it to zero for the next period
322 void rotate_cputime(unsigned long end
)
326 unsigned long elapsed
;
328 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
329 tmp
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
330 elapsed
= end
- tmp
->task_start
;
331 if (tmp
->current_task
) {
332 tmp
->current_task
->totalcpunsec
+= elapsed
;
333 tmp
->current_task
->threadstotalcpunsec
+= elapsed
;
334 if (tmp
->current_task
->pid
!= tmp
->current_task
->tid
&&
335 tmp
->current_task
->threadparent
) {
336 tmp
->current_task
->threadparent
->threadstotalcpunsec
+= elapsed
;
339 tmp
->task_start
= end
;
343 void reset_perf_counter(gpointer key
, gpointer value
, gpointer user_data
)
345 ((struct perfcounter
*) value
)->count
= 0;
348 void copy_perf_counter(gpointer key
, gpointer value
, gpointer new_table
)
350 struct perfcounter
*newperf
;
352 newperf
= g_new0(struct perfcounter
, 1);
353 newperf
->count
= ((struct perfcounter
*) value
)->count
;
354 newperf
->visible
= ((struct perfcounter
*) value
)->visible
;
355 newperf
->sort
= ((struct perfcounter
*) value
)->sort
;
356 g_hash_table_insert((GHashTable
*) new_table
, strdup(key
), newperf
);
359 void copy_process_table(gpointer key
, gpointer value
, gpointer new_table
)
361 g_hash_table_insert((GHashTable
*) new_table
, key
, value
);
364 void rotate_perfcounter() {
366 struct processtop
*tmp
;
367 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
368 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
369 g_hash_table_foreach(tmp
->perf
, reset_perf_counter
, NULL
);
373 void cleanup_processtop()
376 struct processtop
*tmp
;
377 struct files
*tmpf
; /* a temporary file */
379 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
380 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
381 tmp
->totalcpunsec
= 0;
382 tmp
->threadstotalcpunsec
= 0;
386 for (j
= 0; j
< tmp
->process_files_table
->len
; j
++) {
387 tmpf
= g_ptr_array_index(tmp
->process_files_table
, j
);
392 if (tmpf
->flag
== __NR_close
)
394 tmp
->process_files_table
, j
401 void reset_global_counters()
403 lttngtop
.nbnewproc
= 0;
404 lttngtop
.nbdeadproc
= 0;
405 lttngtop
.nbnewthreads
= 0;
406 lttngtop
.nbdeadthreads
= 0;
407 lttngtop
.nbnewfiles
= 0;
408 lttngtop
.nbclosedfiles
= 0;
411 void copy_global_counters(struct lttngtop
*dst
)
413 dst
->nbproc
= lttngtop
.nbproc
;
414 dst
->nbnewproc
= lttngtop
.nbnewproc
;
415 dst
->nbdeadproc
= lttngtop
.nbdeadproc
;
416 dst
->nbthreads
= lttngtop
.nbthreads
;
417 dst
->nbnewthreads
= lttngtop
.nbnewthreads
;
418 dst
->nbdeadthreads
= lttngtop
.nbdeadthreads
;
419 dst
->nbfiles
= lttngtop
.nbfiles
;
420 dst
->nbnewfiles
= lttngtop
.nbnewfiles
;
421 dst
->nbclosedfiles
= lttngtop
.nbclosedfiles
;
422 reset_global_counters();
425 struct lttngtop
* get_copy_lttngtop(unsigned long start
, unsigned long end
)
429 struct lttngtop
*dst
;
430 struct processtop
*tmp
, *tmp2
, *new;
431 struct cputime
*tmpcpu
, *newcpu
;
432 struct files
*tmpfile
, *newfile
;
433 struct kprobes
*tmpprobe
, *newprobe
;
435 dst
= g_new0(struct lttngtop
, 1);
438 copy_global_counters(dst
);
439 dst
->process_table
= g_ptr_array_new();
440 dst
->files_table
= g_ptr_array_new();
441 dst
->cpu_table
= g_ptr_array_new();
442 dst
->kprobes_table
= g_ptr_array_new();
443 dst
->process_hash_table
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
444 g_hash_table_foreach(lttngtop
.process_hash_table
, copy_process_table
,
445 dst
->process_hash_table
);
449 for (i
= 0; i
< lttngtop
.process_table
->len
; i
++) {
450 tmp
= g_ptr_array_index(lttngtop
.process_table
, i
);
451 new = g_new0(struct processtop
, 1);
453 memcpy(new, tmp
, sizeof(struct processtop
));
454 new->threads
= g_ptr_array_new();
455 new->comm
= strdup(tmp
->comm
);
456 new->process_files_table
= g_ptr_array_new();
457 new->files_history
= tmp
->files_history
;
458 new->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
459 g_hash_table_foreach(tmp
->perf
, copy_perf_counter
, new->perf
);
461 /* compute the stream speed */
462 if (end
- start
!= 0) {
463 time
= (end
- start
) / NSEC_PER_SEC
;
464 new->fileread
= new->fileread
/(time
);
465 new->filewrite
= new->filewrite
/(time
);
468 for (j
= 0; j
< tmp
->process_files_table
->len
; j
++) {
469 tmpfile
= g_ptr_array_index(tmp
->process_files_table
, j
);
471 newfile
= malloc(sizeof(struct files
));
473 if (tmpfile
!= NULL
) {
474 memcpy(newfile
, tmpfile
, sizeof(struct files
));
475 newfile
->name
= strdup(tmpfile
->name
);
477 g_ptr_array_add(new->process_files_table
,
479 g_ptr_array_add(dst
->files_table
, newfile
);
481 g_ptr_array_add(new->process_files_table
, NULL
);
482 g_ptr_array_add(dst
->files_table
, NULL
);
485 * if the process died during the last period, we remove all
486 * files associated with if after the copy
488 if (tmp
->death
> 0 && tmp
->death
< end
) {
489 /* FIXME : close the files before */
490 g_ptr_array_remove(tmp
->process_files_table
, tmpfile
);
494 g_ptr_array_add(dst
->process_table
, new);
497 * if the process died during the last period, we remove it from
498 * the current process list after the copy
500 if (tmp
->death
> 0 && tmp
->death
< end
) {
501 g_ptr_array_remove(lttngtop
.process_table
, tmp
);
502 /* FIXME : TRUE does not mean clears the object in it */
503 g_ptr_array_free(tmp
->threads
, TRUE
);
505 g_ptr_array_free(tmp
->process_files_table
, TRUE
);
506 /* FIXME : clear elements */
507 g_hash_table_destroy(tmp
->perf
);
511 rotate_perfcounter();
513 for (i
= 0; i
< lttngtop
.cpu_table
->len
; i
++) {
514 tmpcpu
= g_ptr_array_index(lttngtop
.cpu_table
, i
);
515 newcpu
= g_new0(struct cputime
, 1);
516 memcpy(newcpu
, tmpcpu
, sizeof(struct cputime
));
517 newcpu
->perf
= g_hash_table_new(g_str_hash
, g_str_equal
);
518 g_hash_table_foreach(tmpcpu
->perf
, copy_perf_counter
, newcpu
->perf
);
520 * note : we don't care about the current process pointer in the copy
521 * so the reference is invalid after the memcpy
523 g_ptr_array_add(dst
->cpu_table
, newcpu
);
525 for (i
= 0; i
< lttngtop
.kprobes_table
->len
; i
++) {
526 tmpprobe
= g_ptr_array_index(lttngtop
.kprobes_table
, i
);
527 newprobe
= g_new0(struct kprobes
, 1);
528 memcpy(newprobe
, tmpprobe
, sizeof(struct kprobes
));
530 g_ptr_array_add(dst
->kprobes_table
, newprobe
);
532 /* FIXME : better algo */
533 /* create the threads index if required */
534 for (i
= 0; i
< dst
->process_table
->len
; i
++) {
535 tmp
= g_ptr_array_index(dst
->process_table
, i
);
536 if (tmp
->pid
== tmp
->tid
) {
537 for (j
= 0; j
< dst
->process_table
->len
; j
++) {
538 tmp2
= g_ptr_array_index(dst
->process_table
, j
);
539 if (tmp2
->pid
== tmp
->pid
) {
540 tmp2
->threadparent
= tmp
;
541 g_ptr_array_add(tmp
->threads
, tmp2
);
547 // update_global_stats(dst);
548 cleanup_processtop();
554 enum bt_cb_ret
handle_statedump_process_state(struct bt_ctf_event
*call_data
,
557 const struct bt_definition
*scope
;
558 struct processtop
*proc
;
559 unsigned long timestamp
;
560 int64_t pid
, tid
, ppid
, vtid
, vpid
, vppid
;
563 timestamp
= bt_ctf_get_timestamp(call_data
);
564 if (timestamp
== -1ULL)
567 scope
= bt_ctf_get_top_level_scope(call_data
,
569 pid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
571 if (bt_ctf_field_get_error()) {
572 fprintf(stderr
, "Missing pid context info\n");
575 ppid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
577 if (bt_ctf_field_get_error()) {
578 fprintf(stderr
, "Missing ppid context info\n");
581 tid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
583 if (bt_ctf_field_get_error()) {
584 fprintf(stderr
, "Missing tid context info\n");
587 vtid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
589 if (bt_ctf_field_get_error()) {
590 fprintf(stderr
, "Missing vtid context info\n");
593 vpid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
595 if (bt_ctf_field_get_error()) {
596 fprintf(stderr
, "Missing vpid context info\n");
599 vppid
= bt_ctf_get_int64(bt_ctf_get_field(call_data
,
601 if (bt_ctf_field_get_error()) {
602 fprintf(stderr
, "Missing vppid context info\n");
606 scope
= bt_ctf_get_top_level_scope(call_data
,
608 procname
= bt_ctf_get_char_array(bt_ctf_get_field(call_data
,
610 if (bt_ctf_field_get_error()) {
611 fprintf(stderr
, "Missing process name context info\n");
615 proc
= find_process_tid(<tngtop
, tid
, procname
);
617 proc
= add_proc(<tngtop
, tid
, procname
, timestamp
);
618 update_proc(proc
, pid
, tid
, ppid
, vpid
, vtid
, vppid
, procname
, NULL
);
622 proc
->comm
= strdup(procname
);
629 return BT_CB_ERROR_STOP
;
632 struct tm
format_timestamp(uint64_t timestamp
)
635 uint64_t ts_sec
= 0, ts_nsec
;
639 ts_sec
+= ts_nsec
/ NSEC_PER_SEC
;
640 ts_nsec
= ts_nsec
% NSEC_PER_SEC
;
642 time_s
= (time_t) ts_sec
;
644 localtime_r(&time_s
, &tm
);
649 int *lookup_tid_list(int tid
)
651 return g_hash_table_lookup(tid_list
, (gpointer
) &tid
);
654 char *lookup_hostname_list(const char *hostname
)
659 return g_hash_table_lookup(hostname_list
, (gpointer
) hostname
);
This page took 0.173674 seconds and 4 git commands to generate.