X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=4858b21669c0ce556eaa4168d8883464957c24c5;hb=521a0efa430162f3b78b5cd569e730ed4c60bfc6;hp=00c37cb86149d5166749e71d9fe4c83962d87b51;hpb=f63ebe5196f36fcf40385d29cfc37288c4d70817;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index 00c37cb8..4858b216 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -49,7 +49,8 @@ GQuark LTT_FACILITY_KERNEL_ARCH, LTT_FACILITY_LIST, LTT_FACILITY_FS, - LTT_FACILITY_USER_GENERIC; + LTT_FACILITY_USER_GENERIC, + LTT_FACILITY_BLOCK; /* Events Quarks */ @@ -72,7 +73,9 @@ GQuark LTT_EVENT_STATEDUMP_END, LTT_EVENT_FUNCTION_ENTRY, LTT_EVENT_FUNCTION_EXIT, - LTT_EVENT_THREAD_BRAND; + LTT_EVENT_THREAD_BRAND, + LTT_EVENT_REQUEST_ISSUE, + LTT_EVENT_REQUEST_COMPLETE; /* Fields Quarks */ @@ -96,7 +99,10 @@ GQuark LTT_FIELD_SUBMODE, LTT_FIELD_STATUS, LTT_FIELD_THIS_FN, - LTT_FIELD_CALL_SITE; + LTT_FIELD_CALL_SITE, + LTT_FIELD_MINOR, + LTT_FIELD_MAJOR, + LTT_FIELD_OPERATION; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -127,6 +133,24 @@ LttvProcessType LTTV_STATE_USER_THREAD, LTTV_STATE_KERNEL_THREAD; +LttvCPUMode + LTTV_CPU_UNKNOWN, + LTTV_CPU_IDLE, + LTTV_CPU_BUSY, + LTTV_CPU_IRQ, + LTTV_CPU_TRAP; + +LttvIRQMode + LTTV_IRQ_UNKNOWN, + LTTV_IRQ_IDLE, + LTTV_IRQ_BUSY; + +LttvBdevMode + LTTV_BDEV_UNKNOWN, + LTTV_BDEV_IDLE, + LTTV_BDEV_BUSY_READING, + LTTV_BDEV_BUSY_WRITING; + static GQuark LTTV_STATE_TRACEFILES, LTTV_STATE_PROCESSES, @@ -138,7 +162,10 @@ static GQuark LTTV_STATE_TIME, LTTV_STATE_HOOKS, LTTV_STATE_NAME_TABLES, - LTTV_STATE_TRACE_STATE_USE_COUNT; + LTTV_STATE_TRACE_STATE_USE_COUNT, + LTTV_STATE_RESOURCE_CPUS, + LTTV_STATE_RESOURCE_IRQS, + LTTV_STATE_RESOURCE_BLKDEVS; static void create_max_time(LttvTraceState *tcs); @@ -159,6 +186,15 @@ static void lttv_state_free_process_table(GHashTable *processes); static void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp, GPtrArray *quarktable); +/* Resource function prototypes */ +static LttvBdevState *get_hashed_bdevstate(LttvTraceState *ts, guint16 devcode); +static LttvBdevState *bdevstate_new(void); +static void bdevstate_free(LttvBdevState *); +static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data); +static LttvBdevState *bdevstate_copy(LttvBdevState *bds); +static LttvBdevState *bdev_state_get(LttvTraceState *ts, guint16 devcode); + + void lttv_state_save(LttvTraceState *self, LttvAttribute *container) { LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container); @@ -218,7 +254,7 @@ static void lttv_state_free_usertraces(GHashTable *usertraces) static void restore_init_state(LttvTraceState *self) { - guint i, nb_cpus; + guint i, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -243,6 +279,7 @@ restore_init_state(LttvTraceState *self) //lttv_process_trace_seek_time(&self->parent, ltt_time_zero); nb_cpus = ltt_trace_get_num_cpu(self->parent.t); + nb_irqs = self->nb_irqs; /* Put the per cpu running_process to beginning state : process 0. */ for(i=0; i< nb_cpus; i++) { @@ -261,7 +298,21 @@ restore_init_state(LttvTraceState *self) //self->running_process[i]->state->s = LTTV_STATE_RUN; self->running_process[i]->cpu = i; + + /* reset cpu states */ + if(self->cpu_states[i].mode_stack->len > 0) + g_array_remove_range(self->cpu_states[i].mode_stack, 0, self->cpu_states[i].mode_stack->len); + } + + /* reset irq states */ + for(i=0; iirq_states[i].mode_stack->len > 0) + g_array_remove_range(self->irq_states[i].mode_stack, 0, self->irq_states[i].mode_stack->len); } + + /* reset bdev states */ + g_hash_table_foreach(self->bdev_states, bdevstate_free_cb, NULL); + g_hash_table_steal_all(self->bdev_states); #if 0 nb_tracefile = self->parent.tracefiles->len; @@ -376,7 +427,8 @@ end: static void init(LttvTracesetState *self, LttvTraceset *ts) { - guint i, j, nb_trace, nb_tracefile; + guint i, j, nb_trace, nb_tracefile, nb_cpu; + guint64 nb_irq; LttvTraceContext *tc; @@ -406,10 +458,29 @@ init(LttvTracesetState *self, LttvTraceset *ts) get_max_time(tcs); nb_tracefile = tc->tracefiles->len; + nb_cpu = ltt_trace_get_num_cpu(tc->t); + nb_irq = tcs->nb_irqs; tcs->processes = NULL; tcs->usertraces = NULL; - tcs->running_process = g_new(LttvProcessState*, - ltt_trace_get_num_cpu(tc->t)); + tcs->running_process = g_new(LttvProcessState*, nb_cpu); + + /* init cpu resource stuff */ + tcs->cpu_states = g_new(LttvCPUState, nb_cpu); + for(j = 0; jcpu_states[j].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvCPUMode)); + g_assert(tcs->cpu_states[j].mode_stack != NULL); + } + + /* init irq resource stuff */ + tcs->irq_states = g_new(LttvIRQState, nb_irq); + for(j = 0; jirq_states[j].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvIRQMode)); + g_assert(tcs->irq_states[j].mode_stack != NULL); + } + + /* init bdev resource stuff */ + tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal); + restore_init_state(tcs); for(j = 0 ; j < nb_tracefile ; j++) { tfcs = @@ -417,6 +488,7 @@ init(LttvTracesetState *self, LttvTraceset *ts) LttvTracefileContext*, j)); tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf); tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf); + tfcs->cpu_state = &(tcs->cpu_states[tfcs->cpu]); if(ltt_tracefile_tid(tfcs->parent.tf) != 0) { /* It's a Usertrace */ guint tid = ltt_tracefile_tid(tfcs->parent.tf); @@ -1057,6 +1129,143 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *processes) return new_processes; } +static LttvCPUState *lttv_state_copy_cpu_states(LttvCPUState *states, guint n) +{ + guint i,j; + LttvCPUState *retval; + + retval = g_malloc(n*sizeof(LttvCPUState)); + + for(i=0; ilen); + for(j=0; jlen; j++) { + g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j); + } + } + + return retval; +} + +static void lttv_state_free_cpu_states(LttvCPUState *states, guint n) +{ + guint i; + + for(i=0; ilen); + for(j=0; jlen; j++) { + g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j); + } + } + + return retval; +} + +static void lttv_state_free_irq_states(LttvIRQState *states, guint n) +{ + guint i; + + for(i=0; ibdev_states, &devcode_gint); + if(bdev == NULL) { + LttvBdevState *bdevstate = g_malloc(sizeof(LttvBdevState)); + bdevstate->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); + + gint * key = g_malloc(sizeof(gint)); + *key = devcode; + g_hash_table_insert(ts->bdev_states, key, bdevstate); + + bdev = bdevstate; + } + + return bdev; +} + +static LttvBdevState *bdevstate_new(void) +{ + LttvBdevState *retval; + retval = g_malloc(sizeof(LttvBdevState)); + retval->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); +} + +static void bdevstate_free(LttvBdevState *bds) +{ + g_array_free(bds->mode_stack, FALSE); + g_free(bds); +} + +static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data) +{ + LttvBdevState *bds = (LttvBdevState *) value; + + bdevstate_free(bds); +} + +static LttvBdevState *bdevstate_copy(LttvBdevState *bds) +{ + LttvBdevState *retval; + + retval = bdevstate_new(); + g_array_insert_vals(retval->mode_stack, 0, bds->mode_stack->data, bds->mode_stack->len); +} + +static void insert_and_copy_bdev_state(gpointer k, gpointer v, gpointer u) +{ + GHashTable *ht = (GHashTable *)u; + LttvBdevState *bds = (LttvBdevState *)v; + LttvBdevState *newbds; + + newbds = bdevstate_copy(v); + + g_hash_table_insert(u, k, newbds); +} + +static GHashTable *lttv_state_copy_blkdev_hashtable(GHashTable *ht) +{ + GHashTable *retval; + + retval = g_hash_table_new(g_int_hash, g_int_equal); + + g_hash_table_foreach(ht, insert_and_copy_bdev_state, retval); + + return retval; +} + +/* Free a hashtable and the LttvBdevState structures its values + * point to. */ + +static void lttv_state_free_blkdev_hashtable(GHashTable *ht) +{ + g_hash_table_foreach(ht, bdevstate_free_cb, NULL); + g_hash_table_destroy(ht); +} /* The saved state for each trace contains a member "processes", which stores a copy of the process table, and a member "tracefiles" with @@ -1066,7 +1275,7 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *processes) static void state_save(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, nb_cpus; + guint i, nb_tracefile, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -1138,12 +1347,34 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec); } } + + /* save the cpu state */ + { + guint size = sizeof(LttvCPUState)*nb_cpus; + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_cpu_states(self->cpu_states, nb_cpus); + } + + /* save the irq state */ + nb_irqs = self->nb_irqs; + { + guint size = sizeof(LttvCPUState)*nb_irqs; + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_IRQS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_irq_states(self->irq_states, nb_irqs); + } + + /* save the blkdev states */ + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_BLKDEVS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_blkdev_hashtable(self->bdev_states); } static void state_restore(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, pid, nb_cpus; + guint i, nb_tracefile, pid, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -1184,12 +1415,30 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) g_assert(self->running_process[i] != NULL); } - nb_tracefile = self->parent.tracefiles->len; //g_tree_destroy(tsc->pqueue); //tsc->pqueue = g_tree_new(compare_tracefile); + + /* restore cpu resource states */ + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_CPUS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_cpu_states(self->cpu_states, nb_cpus); + self->cpu_states = lttv_state_copy_cpu_states(*(value.v_pointer), nb_cpus); + /* restore irq resource states */ + nb_irqs = self->nb_irqs; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_IRQS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_irq_states(self->irq_states, nb_irqs); + self->irq_states = lttv_state_copy_irq_states(*(value.v_pointer), nb_irqs); + + /* restore the blkdev states */ + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_blkdev_hashtable(self->bdev_states); + self->bdev_states = lttv_state_copy_blkdev_hashtable(*(value.v_pointer)); + for(i = 0 ; i < nb_tracefile ; i++) { tfcs = LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles, @@ -1210,6 +1459,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) //g_assert(*(value.v_pointer) != NULL); ep = *(value.v_pointer); g_assert(tfcs->parent.t_context != NULL); + + tfcs->cpu_state = &self->cpu_states[tfcs->cpu]; LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs); g_tree_remove(tsc->pqueue, tfc); @@ -1575,6 +1826,67 @@ static void hash_table_check(GHashTable *table) #endif +/* clears the stack and sets the state passed as argument */ +static void cpu_set_base_mode(LttvCPUState *cpust, LttvCPUMode state) +{ + g_array_set_size(cpust->mode_stack, 1); + ((GQuark *)cpust->mode_stack->data)[0] = state; +} + +static void cpu_push_mode(LttvCPUState *cpust, LttvCPUMode state) +{ + g_array_set_size(cpust->mode_stack, cpust->mode_stack->len + 1); + ((GQuark *)cpust->mode_stack->data)[cpust->mode_stack->len - 1] = state; +} + +static void cpu_pop_mode(LttvCPUState *cpust) +{ + if(cpust->mode_stack->len <= 1) + cpu_set_base_mode(cpust, LTTV_CPU_UNKNOWN); + else + g_array_set_size(cpust->mode_stack, cpust->mode_stack->len - 1); +} + +/* clears the stack and sets the state passed as argument */ +static void bdev_set_base_mode(LttvBdevState *bdevst, LttvBdevMode state) +{ + g_array_set_size(bdevst->mode_stack, 1); + ((GQuark *)bdevst->mode_stack->data)[0] = state; +} + +static void bdev_push_mode(LttvBdevState *bdevst, LttvBdevMode state) +{ + g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len + 1); + ((GQuark *)bdevst->mode_stack->data)[bdevst->mode_stack->len - 1] = state; +} + +static void bdev_pop_mode(LttvBdevState *bdevst) +{ + if(bdevst->mode_stack->len <= 1) + bdev_set_base_mode(bdevst, LTTV_BDEV_UNKNOWN); + else + g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len - 1); +} + +static void irq_set_base_mode(LttvIRQState *irqst, LttvIRQMode state) +{ + g_array_set_size(irqst->mode_stack, 1); + ((GQuark *)irqst->mode_stack->data)[0] = state; +} + +static void irq_push_mode(LttvIRQState *irqst, LttvIRQMode state) +{ + g_array_set_size(irqst->mode_stack, irqst->mode_stack->len + 1); + ((GQuark *)irqst->mode_stack->data)[irqst->mode_stack->len - 1] = state; +} + +static void irq_pop_mode(LttvIRQState *irqst) +{ + if(irqst->mode_stack->len <= 1) + irq_set_base_mode(irqst, LTTV_IRQ_UNKNOWN); + else + g_array_set_size(irqst->mode_stack, irqst->mode_stack->len - 1); +} static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, guint state_id) @@ -1934,22 +2246,29 @@ static gboolean trap_entry(void *hook_data, void *call_data) } push_state(s, LTTV_STATE_TRAP, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_TRAP); + return FALSE; } - static gboolean trap_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; pop_state(s, LTTV_STATE_TRAP); + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + return FALSE; } - static gboolean irq_entry(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); guint8 fac_id = ltt_event_facility_id(e); guint8 ev_id = ltt_event_eventtype_id(e); @@ -1976,6 +2295,14 @@ static gboolean irq_entry(void *hook_data, void *call_data) /* Do something with the info about being in user or system mode when int? */ push_state(s, LTTV_STATE_IRQ, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_IRQ); + + /* update irq status */ + s->cpu_state->last_irq = irq; + irq_push_mode(&ts->irq_states[irq], LTTV_IRQ_BUSY); + return FALSE; } @@ -1992,8 +2319,16 @@ static gboolean soft_irq_exit(void *hook_data, void *call_data) static gboolean irq_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; pop_state(s, LTTV_STATE_IRQ); + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + + /* update irq status */ + irq_pop_mode(&ts->irq_states[s->cpu_state->last_irq]); + return FALSE; } @@ -2029,6 +2364,52 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data) return FALSE; } +static gboolean bdev_request_issue(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + LttEvent *e = ltt_tracefile_get_event(s->parent.tf); + guint8 fac_id = ltt_event_facility_id(e); + guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + + guint major = ltt_event_get_long_unsigned(e, thf->f1); + guint minor = ltt_event_get_long_unsigned(e, thf->f2); + guint oper = ltt_event_get_long_unsigned(e, thf->f3); + guint16 devcode = MKDEV(major,minor); + + /* have we seen this block device before? */ + gpointer bdev = get_hashed_bdevstate(ts, devcode); + + if(oper == 0) + bdev_push_mode(bdev, LTTV_BDEV_BUSY_READING); + else + bdev_push_mode(bdev, LTTV_BDEV_BUSY_WRITING); + + return FALSE; +} + +static gboolean bdev_request_complete(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + LttEvent *e = ltt_tracefile_get_event(s->parent.tf); + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + + guint major = ltt_event_get_long_unsigned(e, thf->f1); + guint minor = ltt_event_get_long_unsigned(e, thf->f2); + guint oper = ltt_event_get_long_unsigned(e, thf->f3); + guint16 devcode = MKDEV(major,minor); + + /* have we seen this block device before? */ + gpointer bdev = get_hashed_bdevstate(ts, devcode); + + /* update block device */ + bdev_pop_mode(bdev); + + return FALSE; +} + static void push_function(LttvTracefileState *tfs, guint64 funcptr) { guint64 *new_func; @@ -2124,11 +2505,11 @@ static gboolean schedchange(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; guint pid_in, pid_out; - gint state_out; + gint64 state_out; pid_out = ltt_event_get_unsigned(e, thf->f1); pid_in = ltt_event_get_unsigned(e, thf->f2); - state_out = ltt_event_get_int(e, thf->f3); + state_out = ltt_event_get_long_int(e, thf->f3); if(likely(process != NULL)) { @@ -2181,6 +2562,13 @@ static gboolean schedchange(void *hook_data, void *call_data) process->usertrace->cpu = cpu; // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf); process->state->change = s->parent.timestamp; + + /* update cpu status */ + if(pid_in == 0) + cpu_set_base_mode(s->cpu_state, LTTV_CPU_IDLE); + else + cpu_set_base_mode(s->cpu_state, LTTV_CPU_BUSY); + return FALSE; } @@ -2271,10 +2659,11 @@ static gboolean process_kernel_thread(void *hook_data, void *call_data) LttvExecutionState *es; /* PID */ - pid = ltt_event_get_unsigned(e, thf->f1); + pid = (guint)ltt_event_get_long_unsigned(e, thf->f1); s->parent.target_pid = pid; - process = lttv_state_find_process(ts, ANY_CPU, pid); + process = lttv_state_find_process_or_create(ts, ANY_CPU, pid, + <t_time_zero); process->execution_stack = g_array_set_size(process->execution_stack, 1); es = process->state = @@ -2379,7 +2768,7 @@ static gboolean process_exec(void *hook_data, void *call_data) process->name = g_quark_from_string(null_term_name); #endif //0 - process->name = ltt_event_get_string(e, thf->f1); + process->name = g_quark_from_string(ltt_event_get_string(e, thf->f1)); process->brand = LTTV_STATE_UNBRANDED; //g_free(null_term_name); return FALSE; @@ -2780,6 +3169,18 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) statedump_end, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); if(ret) hn--; + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_ISSUE, + LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION, + bdev_request_issue, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; + + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_COMPLETE, + LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION, + bdev_request_complete, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; + ret = lttv_trace_find_hook(ts->parent.t, LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY, LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, @@ -3461,6 +3862,9 @@ static void module_init() LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables"); LTTV_STATE_TRACE_STATE_USE_COUNT = g_quark_from_string("trace_state_use_count"); + LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu resource states"); + LTTV_STATE_RESOURCE_IRQS = g_quark_from_string("irq resource states"); + LTTV_STATE_RESOURCE_BLKDEVS = g_quark_from_string("blkdevs resource states"); LTT_FACILITY_KERNEL = g_quark_from_string("kernel"); @@ -3468,6 +3872,7 @@ static void module_init() LTT_FACILITY_FS = g_quark_from_string("fs"); LTT_FACILITY_LIST = g_quark_from_string("list"); LTT_FACILITY_USER_GENERIC = g_quark_from_string("user_generic"); + LTT_FACILITY_BLOCK = g_quark_from_string("block"); LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); @@ -3489,6 +3894,8 @@ static void module_init() LTT_EVENT_FUNCTION_ENTRY = g_quark_from_string("function_entry"); LTT_EVENT_FUNCTION_EXIT = g_quark_from_string("function_exit"); LTT_EVENT_THREAD_BRAND = g_quark_from_string("thread_brand"); + LTT_EVENT_REQUEST_ISSUE = g_quark_from_string("_blk_request_issue"); + LTT_EVENT_REQUEST_COMPLETE = g_quark_from_string("_blk_request_complete"); LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id"); @@ -3511,7 +3918,24 @@ static void module_init() LTT_FIELD_STATUS = g_quark_from_string("status"); LTT_FIELD_THIS_FN = g_quark_from_string("this_fn"); LTT_FIELD_CALL_SITE = g_quark_from_string("call_site"); + LTT_FIELD_MAJOR = g_quark_from_string("major"); + LTT_FIELD_MINOR = g_quark_from_string("minor"); + LTT_FIELD_OPERATION = g_quark_from_string("direction"); + LTTV_CPU_UNKNOWN = g_quark_from_string("unknown"); + LTTV_CPU_IDLE = g_quark_from_string("idle"); + LTTV_CPU_BUSY = g_quark_from_string("busy"); + LTTV_CPU_IRQ = g_quark_from_string("irq"); + LTTV_CPU_TRAP = g_quark_from_string("trap"); + + LTTV_IRQ_UNKNOWN = g_quark_from_string("unknown"); + LTTV_IRQ_IDLE = g_quark_from_string("idle"); + LTTV_IRQ_BUSY = g_quark_from_string("busy"); + + LTTV_BDEV_UNKNOWN = g_quark_from_string("unknown"); + LTTV_BDEV_IDLE = g_quark_from_string("idle"); + LTTV_BDEV_BUSY_READING = g_quark_from_string("busy_reading"); + LTTV_BDEV_BUSY_WRITING = g_quark_from_string("busy_writing"); } static void module_destroy()