static void report_event_triggers(struct buffer_instance *instance)
{
struct event_iter *iter;
char *path;
char *system;
enum event_iter_type type;
enum event_process processed = PROCESSED_NONE;
path = get_instance_file(instance, "events");
if (!path)
die("malloc");
iter = trace_event_iter_alloc(path);
processed = PROCESSED_NONE;
system = NULL;
while ((type = trace_event_iter_next(iter, path, system))) {
if (type == EVENT_ITER_SYSTEM) {
system = iter->system_dent->d_name;
continue;
}
process_event_trigger(path, iter, &processed);
}
trace_event_iter_free(iter);
tracecmd_put_tracing_file(path);
}
static int st_write_event_mapping(void)
{
uint64_t type = TRACE_RECORD_TYPE_MAPPING;
TraceEventIter iter;
TraceEvent *ev;
trace_event_iter_init(&iter, NULL);
while ((ev = trace_event_iter_next(&iter)) != NULL) {
uint64_t id = trace_event_get_id(ev);
const char *name = trace_event_get_name(ev);
uint32_t len = strlen(name);
if (fwrite(&type, sizeof(type), 1, trace_fp) != 1 ||
fwrite(&id, sizeof(id), 1, trace_fp) != 1 ||
fwrite(&len, sizeof(len), 1, trace_fp) != 1 ||
fwrite(name, len, 1, trace_fp) != 1) {
return -1;
}
}
return 0;
}
static bool check_events(bool has_vcpu, bool ignore_unavailable, bool is_pattern,
const char *name, Error **errp)
{
if (!is_pattern) {
TraceEvent *ev = trace_event_name(name);
/* error for non-existing event */
if (ev == NULL) {
error_setg(errp, "unknown event \"%s\"", name);
return false;
}
/* error for non-vcpu event */
if (has_vcpu && !trace_event_is_vcpu(ev)) {
error_setg(errp, "event \"%s\" is not vCPU-specific", name);
return false;
}
/* error for unavailable event */
if (!ignore_unavailable && !trace_event_get_state_static(ev)) {
error_setg(errp, "event \"%s\" is disabled", name);
return false;
}
return true;
} else {
/* error for unavailable events */
TraceEventIter iter;
TraceEvent *ev;
trace_event_iter_init(&iter, name);
while ((ev = trace_event_iter_next(&iter)) != NULL) {
if (!ignore_unavailable && !trace_event_get_state_static(ev)) {
error_setg(errp, "event \"%s\" is disabled", trace_event_get_name(ev));
return false;
}
}
return true;
}
}
void qmp_trace_event_set_state(const char *name, bool enable,
bool has_ignore_unavailable, bool ignore_unavailable,
bool has_vcpu, int64_t vcpu,
Error **errp)
{
Error *err = NULL;
TraceEventIter iter;
TraceEvent *ev;
bool is_pattern = trace_event_is_pattern(name);
CPUState *cpu;
/* Check provided vcpu */
cpu = get_cpu(has_vcpu, vcpu, &err);
if (err) {
error_propagate(errp, err);
return;
}
/* Check events */
if (!check_events(has_vcpu, has_ignore_unavailable && ignore_unavailable,
is_pattern, name, errp)) {
return;
}
/* Apply changes (all errors checked above) */
trace_event_iter_init(&iter, name);
while ((ev = trace_event_iter_next(&iter)) != NULL) {
if (!trace_event_get_state_static(ev) ||
(has_vcpu && !trace_event_is_vcpu(ev))) {
continue;
}
if (has_vcpu) {
trace_event_set_vcpu_state_dynamic(cpu, ev, enable);
} else {
trace_event_set_state_dynamic(ev, enable);
}
}
}
static void report_events(struct buffer_instance *instance)
{
struct event_iter *iter;
char *str;
char *cont;
char *path;
char *system;
enum event_iter_type type;
enum event_process processed = PROCESSED_NONE;
str = get_instance_file_content(instance, "events/enable");
if (!str)
return;
cont = strstrip(str);
printf("\nEvents:\n");
switch(*cont) {
case '1':
printf(" All enabled\n");
free(str);
return;
case '0':
printf(" All disabled\n");
free(str);
return;
}
free(str);
path = get_instance_file(instance, "events");
if (!path)
die("malloc");
iter = trace_event_iter_alloc(path);
while (trace_event_iter_next(iter, path, NULL)) {
process_event_enable(path, NULL, iter->system_dent->d_name, &processed);
}
reset_event_iter(iter);
processed = PROCESSED_NONE;
system = NULL;
while ((type = trace_event_iter_next(iter, path, system))) {
if (type == EVENT_ITER_SYSTEM) {
/* Only process systems that are not fully enabled */
if (!process_individual_events(path, iter))
continue;
system = iter->system_dent->d_name;
if (processed)
processed = PROCESSED_SYSTEM;
continue;
}
process_event_enable(path, iter->system_dent->d_name,
iter->event_dent->d_name, &processed);
}
trace_event_iter_free(iter);
if (!processed)
printf(" (none enabled)\n");
tracecmd_put_tracing_file(path);
}
TraceEventInfoList *qmp_trace_event_get_state(const char *name,
bool has_vcpu, int64_t vcpu,
Error **errp)
{
Error *err = NULL;
TraceEventInfoList *events = NULL;
TraceEventIter iter;
TraceEvent *ev;
bool is_pattern = trace_event_is_pattern(name);
CPUState *cpu;
/* Check provided vcpu */
cpu = get_cpu(has_vcpu, vcpu, &err);
if (err) {
error_propagate(errp, err);
return NULL;
}
/* Check events */
if (!check_events(has_vcpu, true, is_pattern, name, errp)) {
return NULL;
}
/* Get states (all errors checked above) */
trace_event_iter_init(&iter, name);
while ((ev = trace_event_iter_next(&iter)) != NULL) {
TraceEventInfoList *elem;
bool is_vcpu = trace_event_is_vcpu(ev);
if (has_vcpu && !is_vcpu) {
continue;
}
elem = g_new(TraceEventInfoList, 1);
elem->value = g_new(TraceEventInfo, 1);
elem->value->vcpu = is_vcpu;
elem->value->name = g_strdup(trace_event_get_name(ev));
if (!trace_event_get_state_static(ev)) {
elem->value->state = TRACE_EVENT_STATE_UNAVAILABLE;
} else {
if (has_vcpu) {
if (is_vcpu) {
if (trace_event_get_vcpu_state_dynamic(cpu, ev)) {
elem->value->state = TRACE_EVENT_STATE_ENABLED;
} else {
elem->value->state = TRACE_EVENT_STATE_DISABLED;
}
}
/* else: already skipped above */
} else {
if (trace_event_get_state_dynamic(ev)) {
elem->value->state = TRACE_EVENT_STATE_ENABLED;
} else {
elem->value->state = TRACE_EVENT_STATE_DISABLED;
}
}
}
elem->next = events;
events = elem;
}
return events;
}
