X-Git-Url: https://git.lttng.org/?p=lttngtop.git;a=blobdiff_plain;f=src%2Fcommon.c;h=c01aee273aae54f3113a6a44ee6a1894bb9c311d;hp=e59de36c8157ffb6512f6f3a01872978f9fbe098;hb=e05a35a69ff03f10bba459a07dc26684049f1bc9;hpb=559c9f8611df967995dae28f8d3c7089ac585a1a diff --git a/src/common.c b/src/common.c index e59de36..c01aee2 100644 --- a/src/common.c +++ b/src/common.c @@ -10,16 +10,96 @@ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include #include +#include #include #include "common.h" +uint64_t get_cpu_id(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t cpu_id; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_PACKET_CONTEXT); + cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(event, scope, "cpu_id")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "[error] get cpu_id\n"); + return -1ULL; + } + + return cpu_id; +} + +uint64_t get_context_tid(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t tid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + tid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_tid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing tid context info\n"); + return -1ULL; + } + + return tid; +} + +uint64_t get_context_pid(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t pid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + pid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_pid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing pid context info\n"); + return -1ULL; + } + + return pid; +} + +uint64_t get_context_ppid(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t ppid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + ppid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_ppid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing ppid context info\n"); + return -1ULL; + } + + return ppid; +} + +char *get_context_comm(const struct bt_ctf_event *event) +{ + const struct definition *scope; + char *comm; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + comm = bt_ctf_get_char_array(bt_ctf_get_field(event, + scope, "_procname")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing comm context info\n"); + return NULL; + } + + return comm; +} + struct processtop *find_process_tid(struct lttngtop *ctx, int tid, char *comm) { gint i; @@ -46,14 +126,18 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, newproc->tid = tid; newproc->birth = timestamp; newproc->process_files_table = g_ptr_array_new(); + newproc->files_history = NULL; + newproc->totalfileread = 0; + newproc->totalfilewrite = 0; + newproc->fileread = 0; + newproc->filewrite = 0; + newproc->syscall_info = NULL; newproc->threads = g_ptr_array_new(); - newproc->perf = g_hash_table_new(g_direct_hash, g_direct_equal); - newproc->iostream = g_new0(struct iostream, 1); - newproc->iostream->ret_read = 0; - newproc->iostream->ret_write = 0; - newproc->iostream->ret_total = 0; - newproc->iostream->syscall_info = NULL; + newproc->perf = g_hash_table_new(g_str_hash, g_str_equal); g_ptr_array_add(ctx->process_table, newproc); + + ctx->nbnewthreads++; + ctx->nbthreads++; } newproc->comm = strdup(comm); @@ -84,8 +168,11 @@ void death_proc(struct lttngtop *ctx, int tid, char *comm, { struct processtop *tmp; tmp = find_process_tid(ctx, tid, comm); - if (tmp && strcmp(tmp->comm, comm) == 0) + if (tmp && strcmp(tmp->comm, comm) == 0) { tmp->death = timestamp; + ctx->nbdeadthreads++; + ctx->nbthreads--; + } } struct processtop* get_proc(struct lttngtop *ctx, int tid, char *comm, @@ -118,7 +205,7 @@ struct cputime* add_cpu(int cpu) newcpu = g_new0(struct cputime, 1); newcpu->id = cpu; newcpu->current_task = NULL; - newcpu->perf = g_hash_table_new(g_direct_hash, g_direct_equal); + newcpu->perf = g_hash_table_new(g_str_hash, g_str_equal); g_ptr_array_add(lttngtop.cpu_table, newcpu); @@ -176,7 +263,7 @@ void copy_perf_counter(gpointer key, gpointer value, gpointer new_table) newperf->count = ((struct perfcounter *) value)->count; newperf->visible = ((struct perfcounter *) value)->visible; newperf->sort = ((struct perfcounter *) value)->sort; - g_hash_table_insert((GHashTable *) new_table, key, newperf); + g_hash_table_insert((GHashTable *) new_table, strdup(key), newperf); } void rotate_perfcounter() { @@ -190,18 +277,56 @@ void rotate_perfcounter() { void cleanup_processtop() { - gint i; + gint i, j; struct processtop *tmp; + struct files *tmpf; /* a temporary file */ for (i = 0; i < lttngtop.process_table->len; i++) { tmp = g_ptr_array_index(lttngtop.process_table, i); tmp->totalcpunsec = 0; tmp->threadstotalcpunsec = 0; - tmp->iostream->ret_read = 0; - tmp->iostream->ret_write = 0; + tmp->fileread = 0; + tmp->filewrite = 0; + + for (j = 0; j < tmp->process_files_table->len; j++) { + tmpf = g_ptr_array_index(tmp->process_files_table, j); + if (tmpf != NULL) { + tmpf->read = 0; + tmpf->write = 0; + + if (tmpf->flag == __NR_close) + g_ptr_array_index( + tmp->process_files_table, j + ) = NULL; + } + } } } +void reset_global_counters() +{ + lttngtop.nbnewproc = 0; + lttngtop.nbdeadproc = 0; + lttngtop.nbnewthreads = 0; + lttngtop.nbdeadthreads = 0; + lttngtop.nbnewfiles = 0; + lttngtop.nbclosedfiles = 0; +} + +void copy_global_counters(struct lttngtop *dst) +{ + dst->nbproc = lttngtop.nbproc; + dst->nbnewproc = lttngtop.nbnewproc; + dst->nbdeadproc = lttngtop.nbdeadproc; + dst->nbthreads = lttngtop.nbthreads; + dst->nbnewthreads = lttngtop.nbnewthreads; + dst->nbdeadthreads = lttngtop.nbdeadthreads; + dst->nbfiles = lttngtop.nbfiles; + dst->nbnewfiles = lttngtop.nbnewfiles; + dst->nbclosedfiles = lttngtop.nbclosedfiles; + reset_global_counters(); +} + struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) { gint i, j; @@ -214,10 +339,11 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) dst = g_new0(struct lttngtop, 1); dst->start = start; dst->end = end; + copy_global_counters(dst); dst->process_table = g_ptr_array_new(); dst->files_table = g_ptr_array_new(); dst->cpu_table = g_ptr_array_new(); - dst->perf_list = g_hash_table_new(g_direct_hash, g_direct_equal); + dst->perf_list = g_hash_table_new(g_str_hash, g_str_equal); rotate_cputime(end); @@ -230,36 +356,39 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) new->threads = g_ptr_array_new(); new->comm = strdup(tmp->comm); new->process_files_table = g_ptr_array_new(); - new->perf = g_hash_table_new(g_direct_hash, g_direct_equal); + new->files_history = tmp->files_history; + new->perf = g_hash_table_new(g_str_hash, g_str_equal); g_hash_table_foreach(tmp->perf, copy_perf_counter, new->perf); - new->iostream = g_new0(struct iostream, 1); - memcpy(new->iostream, tmp->iostream, sizeof(struct iostream)); /* compute the stream speed */ - if (end - start != 0) - { - time = (end - start)/NSEC_PER_SEC; - new->iostream->ret_read = new->iostream->ret_read/(time); - new->iostream->ret_write = new->iostream->ret_write/(time); + if (end - start != 0) { + time = (end - start) / NSEC_PER_SEC; + new->fileread = new->fileread/(time); + new->filewrite = new->filewrite/(time); } for (j = 0; j < tmp->process_files_table->len; j++) { tmpfile = g_ptr_array_index(tmp->process_files_table, j); - newfile = g_new0(struct files, 1); - - memcpy(newfile, tmpfile, sizeof(struct files)); - - newfile->name = strdup(tmpfile->name); - newfile->ref = new; - - g_ptr_array_add(new->process_files_table, newfile); - g_ptr_array_add(dst->files_table, newfile); + newfile = malloc(sizeof(struct files)); + + if (tmpfile != NULL) { + memcpy(newfile, tmpfile, sizeof(struct files)); + newfile->name = strdup(tmpfile->name); + newfile->ref = new; + g_ptr_array_add(new->process_files_table, + newfile); + g_ptr_array_add(dst->files_table, newfile); + } else { + g_ptr_array_add(new->process_files_table, NULL); + g_ptr_array_add(dst->files_table, NULL); + } /* * if the process died during the last period, we remove all * files associated with if after the copy */ if (tmp->death > 0 && tmp->death < end) { + /* FIXME : close the files before */ g_ptr_array_remove(tmp->process_files_table, tmpfile); g_free(tmpfile); } @@ -271,10 +400,13 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) * the current process list after the copy */ if (tmp->death > 0 && tmp->death < end) { + fprintf(stderr, "removing : %ld : %d %s\n", end, tmp->tid, tmp->comm); g_ptr_array_remove(lttngtop.process_table, tmp); + /* FIXME : TRUE does not mean clears the object in it */ g_ptr_array_free(tmp->threads, TRUE); free(tmp->comm); g_ptr_array_free(tmp->process_files_table, TRUE); + /* FIXME : clear elements */ g_hash_table_destroy(tmp->perf); g_free(tmp); } @@ -285,7 +417,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) tmpcpu = g_ptr_array_index(lttngtop.cpu_table, i); newcpu = g_new0(struct cputime, 1); memcpy(newcpu, tmpcpu, sizeof(struct cputime)); - newcpu->perf = g_hash_table_new(g_direct_hash, g_direct_equal); + newcpu->perf = g_hash_table_new(g_str_hash, g_str_equal); g_hash_table_foreach(tmpcpu->perf, copy_perf_counter, newcpu->perf); /* * note : we don't care about the current process pointer in the copy @@ -293,6 +425,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) */ g_ptr_array_add(dst->cpu_table, newcpu); } + /* FIXME : better algo */ /* create the threads index if required */ for (i = 0; i < dst->process_table->len; i++) { tmp = g_ptr_array_index(dst->process_table, i);