* @return The widget created.
*/
GtkWidget *
-h_guicontrolflow(Tab *tab)
+h_guicontrolflow(LttvPlugin *plugin)
{
+ LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
+ Tab *tab = ptab->tab;
g_info("h_guicontrolflow, %p", tab);
- ControlFlowData *control_flow_data = guicontrolflow(tab) ;
+ ControlFlowData *control_flow_data = guicontrolflow(ptab);
control_flow_data->tab = tab;
/* Create a popup legend */
GtkWidget *
-h_legend(Tab *tab)
+h_legend(LttvPlugin *plugin)
{
+ LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
+ Tab *tab = ptab->tab;
g_info("h_legend, %p", tab);
GtkWindow *legend = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ gint target_pid_saved = tfc->target_pid;
LttTime evtime = ltt_event_time(e);
+ LttvFilter *filter = control_flow_data->filter;
/* we are in a schedchange, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
pid_in = ltt_event_get_long_unsigned(e, thf->f2);
}
- {
+ tfc->target_pid = pid_out;
+ if(!filter || !filter->head ||
+ lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc)) {
/* For the pid_out */
/* First, check if the current process is in the state computation
* process list. If it is there, that means we must add it right now and
* draw items from the beginning of the read for it. If it is not
* present, it's a new process and it was not present : it will
* be added after the state update. */
- guint cpu = ltt_tracefile_num(tfc->tf);
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
LttvProcessState *process = ts->running_process[cpu];
/* unknown state, bad current pid */
if(process->pid != pid_out)
process = lttv_state_find_process(ts,
- ltt_tracefile_num(tfc->tf), pid_out);
+ tfs->cpu, pid_out);
if(process != NULL) {
/* Well, the process_out existed : we must get it in the process hash
pid_out,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(hashed_process_data == NULL)
{
g_assert(pid_out == 0 || pid_out != process->ppid);
processlist_add(process_list,
drawing,
pid_out,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
}
}
- {
+ tfc->target_pid = pid_in;
+ if(!filter || !filter->head ||
+ lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc)) {
/* For the pid_in */
/* First, check if the current process is in the state computation
* process list. If it is there, that means we must add it right now and
* be added after the state update. */
LttvProcessState *process;
process = lttv_state_find_process(ts,
- ltt_tracefile_num(tfc->tf), pid_in);
+ tfs->cpu, pid_in);
+ guint trace_num = ts->parent.index;
if(process != NULL) {
/* Well, the process existed : we must get it in the process hash
hashed_process_data = processlist_get_process_data(process_list,
pid_in,
- ltt_tracefile_num(tfc->tf),
+ tfs->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(hashed_process_data == NULL)
{
g_assert(pid_in == 0 || pid_in != process->ppid);
processlist_add(process_list,
drawing,
pid_in,
- ltt_tracefile_num(tfc->tf),
+ process->tgid,
+ tfs->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
} else
g_warning("Cannot find pin_in in schedchange %u", pid_in);
}
+ tfc->target_pid = target_pid_saved;
return 0;
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
/* Add process to process list (if not present) */
/* Find process pid_in in the list... */
//process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
//process_in = tfs->process;
- guint cpu = ltt_tracefile_num(tfc->tf);
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
process_in = ts->running_process[cpu];
/* It should exist, because we are after the state update. */
#ifdef EXTRA_CHECK
pid_in,
process_in->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(hashed_process_data_in == NULL)
{
g_assert(pid_in == 0 || pid_in != process_in->ppid);
processlist_add(process_list,
drawing,
pid_in,
+ process_in->tgid,
process_in->cpu,
process_in->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process_in->name,
+ process_in->brand,
&pl_height,
&process_info,
&hashed_process_data_in);
gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
- process_list->current_hash_data[process_in->cpu] =
+ process_list->current_hash_data[trace_num][process_in->cpu] =
hashed_process_data_in;
if(ltt_time_compare(hashed_process_data_in->next_good_time,
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
/* we are in a execmode, before the state update. We must draw the
*/
/* For the pid */
//LttvProcessState *process = tfs->process;
- guint cpu = ltt_tracefile_num(tfc->tf);
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
LttvProcessState *process = ts->running_process[cpu];
g_assert(process != NULL);
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- if(likely(process_list->current_hash_data[cpu] != NULL)) {
- hashed_process_data = process_list->current_hash_data[cpu];
+ if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
+ hashed_process_data = process_list->current_hash_data[trace_num][cpu];
} else {
hashed_process_data = processlist_get_process_data(process_list,
pid,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(unlikely(hashed_process_data == NULL))
{
g_assert(pid == 0 || pid != process->ppid);
processlist_add(process_list,
drawing,
pid,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
- process_list->current_hash_data[process->cpu] =
+ process_list->current_hash_data[trace_num][process->cpu] =
hashed_process_data;
}
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
/* Add process to process list (if not present) */
//LttvProcessState *process = tfs->process;
- guint cpu = ltt_tracefile_num(tfc->tf);
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
LttvProcessState *process = ts->running_process[cpu];
guint pid = process->pid;
LttTime birth;
birth = process->creation_time;
- if(likely(process_list->current_hash_data[cpu] != NULL)) {
- hashed_process_data = process_list->current_hash_data[cpu];
+ if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
+ hashed_process_data = process_list->current_hash_data[trace_num][cpu];
} else {
hashed_process_data = processlist_get_process_data(process_list,
pid,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(unlikely(hashed_process_data == NULL))
{
g_assert(pid == 0 || pid != process->ppid);
processlist_add(process_list,
drawing,
pid,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
+ guint trace_num = ts->parent.index;
guint pid;
{
pid,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(unlikely(hashed_process_data == NULL))
{
g_assert(pid == 0 || pid != process->ppid);
processlist_add(process_list,
drawing,
pid,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
guint child_pid;
g_assert(process_child != NULL);
birth = process_child->creation_time;
+ guint trace_num = ts->parent.index;
/* Cannot use current process, because this action is done by the parent
* on its child. */
child_pid,
process_child->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(likely(hashed_process_data_child == NULL))
{
g_assert(child_pid == 0 || child_pid != process_child->ppid);
processlist_add(process_list,
drawing,
child_pid,
+ process_child->tgid,
process_child->cpu,
process_child->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process_child->name,
+ process_child->brand,
&pl_height,
&process_info,
&hashed_process_data_child);
-1,
pl_height);
gtk_widget_queue_draw(drawing->drawing_area);
+ } else {
+ processlist_set_ppid(process_list, process_child->ppid,
+ hashed_process_data_child);
+ processlist_set_tgid(process_list, process_child->tgid,
+ hashed_process_data_child);
}
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
/* Add process to process list (if not present) */
//LttvProcessState *process = tfs->process;
- guint cpu = ltt_tracefile_num(tfc->tf);
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
LttvProcessState *process = ts->running_process[cpu];
/* It should exist, because we are after the state update. */
birth = process->creation_time;
- if(likely(process_list->current_hash_data[cpu] != NULL) ){
- hashed_process_data = process_list->current_hash_data[cpu];
+ if(likely(process_list->current_hash_data[trace_num][cpu] != NULL) ){
+ hashed_process_data = process_list->current_hash_data[trace_num][cpu];
} else {
hashed_process_data = processlist_get_process_data(process_list,
pid,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(unlikely(hashed_process_data == NULL))
{
g_assert(pid == 0 || pid != process->ppid);
processlist_add(process_list,
drawing,
pid,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
}
/* Set the current process */
- process_list->current_hash_data[process->cpu] =
+ process_list->current_hash_data[trace_num][process->cpu] =
hashed_process_data;
}
LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
- guint cpu = ltt_tracefile_num(tfc->tf);
+ LttEvent *e;
+ e = ltt_tracefile_get_event(tfc->tf);
+
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
LttvProcessState *process = ts->running_process[cpu];
g_assert(process != NULL);
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- if(likely(process_list->current_hash_data[cpu] != NULL)) {
- hashed_process_data = process_list->current_hash_data[cpu];
+ if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
+ hashed_process_data = process_list->current_hash_data[trace_num][cpu];
} else {
hashed_process_data = processlist_get_process_data(process_list,
pid,
process->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(unlikely(hashed_process_data == NULL))
{
g_assert(pid == 0 || pid != process->ppid);
processlist_add(process_list,
drawing,
pid,
+ process->tgid,
process->cpu,
process->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process->name,
+ process->brand,
&pl_height,
&process_info,
&hashed_process_data);
gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
- process_list->current_hash_data[process->cpu] =
+ process_list->current_hash_data[trace_num][process->cpu] =
hashed_process_data;
}
}
+/* Get the filename of the process to print */
+int after_user_generic_thread_brand_hook(void *hook_data, void *call_data)
+{
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
+ EventsRequest *events_request = (EventsRequest*)thf->hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+
+ LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
+
+ LttEvent *e;
+ e = ltt_tracefile_get_event(tfc->tf);
+
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
+ guint cpu = tfs->cpu;
+ guint trace_num = ts->parent.index;
+ LttvProcessState *process = ts->running_process[cpu];
+ g_assert(process != NULL);
+
+ guint pid = process->pid;
+
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list = control_flow_data->process_list;
+ LttTime birth = process->creation_time;
+
+ if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
+ hashed_process_data = process_list->current_hash_data[trace_num][cpu];
+ } else {
+ hashed_process_data = processlist_get_process_data(process_list,
+ pid,
+ process->cpu,
+ &birth,
+ trace_num);
+ if(unlikely(hashed_process_data == NULL))
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ ProcessInfo *process_info;
+ /* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
+ processlist_add(process_list,
+ drawing,
+ pid,
+ process->tgid,
+ process->cpu,
+ process->ppid,
+ &birth,
+ trace_num,
+ process->name,
+ process->brand,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[trace_num][process->cpu] =
+ hashed_process_data;
+ }
+
+ processlist_set_brand(process_list, process->brand, hashed_process_data);
+
+ return 0;
+
+}
+
+
/* after_event_enum_process_hook
*
* Create the processlist entry for the child process. Put the last
LttEvent *e;
e = ltt_tracefile_get_event(tfc->tf);
+ LttvFilter *filter = control_flow_data->filter;
+ if(filter != NULL && filter->head != NULL)
+ if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
+ tfc->t_context->t,tfc))
+ return FALSE;
+
LttTime evtime = ltt_event_time(e);
/* Add process to process list (if not present) */
HashedProcessData *hashed_process_data_in = NULL;
ProcessList *process_list = control_flow_data->process_list;
+ guint trace_num = ts->parent.index;
guint pid_in;
{
/* Find process pid_in in the list... */
process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
//process_in = tfs->process;
- //guint cpu = ltt_tracefile_num(tfc->tf);
+ //guint cpu = tfs->cpu;
+ //guint trace_num = ts->parent.index;
//process_in = ts->running_process[cpu];
/* It should exist, because we are after the state update. */
#ifdef EXTRA_CHECK
pid_in,
process_in->cpu,
&birth,
- tfc->t_context->index);
+ trace_num);
if(hashed_process_data_in == NULL)
{
if(pid_in != 0 && pid_in == process_in->ppid)
processlist_add(process_list,
drawing,
pid_in,
+ process_in->tgid,
process_in->cpu,
process_in->ppid,
&birth,
- tfc->t_context->index,
+ trace_num,
process_in->name,
+ process_in->brand,
&pl_height,
&process_info,
&hashed_process_data_in);
pl_height);
gtk_widget_queue_draw(drawing->drawing_area);
} else {
- processlist_set_name(process_list, process_in->name,
- hashed_process_data_in);
- processlist_set_ppid(process_list, process_in->ppid,
- hashed_process_data_in);
+ processlist_set_name(process_list, process_in->name,
+ hashed_process_data_in);
+ processlist_set_ppid(process_list, process_in->ppid,
+ hashed_process_data_in);
+ processlist_set_tgid(process_list, process_in->tgid,
+ hashed_process_data_in);
}
return 0;
}
for(i=0;i<tc->tracefiles->len;i++) {
tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i);
if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU
- && ltt_tracefile_num(tfc->tf) == process_info->cpu)
+ && tfs->cpu == process_info->cpu)
break;
}
LttTime end_time;
ProcessList *process_list = control_flow_data->process_list;
+ guint i;
+ LttvTraceset *traceset = tsc->ts;
+ guint nb_trace = lttv_traceset_number(traceset);
+
+ /* Only execute when called for the first trace's events request */
+ if(!process_list->current_hash_data) return;
+ for(i = 0 ; i < nb_trace ; i++) {
+ g_free(process_list->current_hash_data[i]);
+ }
g_free(process_list->current_hash_data);
process_list->current_hash_data = NULL;
-
+
if(tfc != NULL)
end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
else /* end of traceset, or position now out of request : end */
projects / lttv.git / blobdiff