libtracefs(3) Manual Page

#include <unistd.h>
#include <tracefs.h>
#include <stdbool.h>
#include <signal.h>

struct my_struct {
        bool            stopped;
};

#define MAX_COUNT 500000
static int counter;

static int callback(struct tep_event *event, struct tep_record *record,
                    int cpu, void *data)
{
        struct my_struct *my_data = data;
        static struct trace_seq seq;

        if (counter++ > MAX_COUNT) {
                my_data->stopped = true;
                return 1;
        }

        if (!seq.buffer)
                trace_seq_init(&seq);

        tep_print_event(event->tep, &seq, record, "%16s-%-5d [%03d] %6.1000d %s: %s\n",
                        TEP_PRINT_COMM, TEP_PRINT_PID, TEP_PRINT_CPU,
                        TEP_PRINT_TIME, TEP_PRINT_NAME, TEP_PRINT_INFO);
        trace_seq_terminate(&seq);
        trace_seq_do_printf(&seq);
        trace_seq_reset(&seq);
        return 0;
}

static int sched_callback(struct tep_event *event, struct tep_record *record,
                          int cpu, void *data)
{
        static struct tep_format_field *prev_pid;
        static struct tep_format_field *next_pid;
        unsigned long long pid;
        int this_pid = *(int *)data;

        if (!prev_pid) {
                prev_pid = tep_find_field(event, "prev_pid");
                next_pid = tep_find_field(event, "next_pid");
                if (!prev_pid || !next_pid) {
                        fprintf(stderr, "No pid fields??\n");
                        return -1;
                }
        }

        tep_read_number_field(prev_pid, record->data, &pid);
        if (pid == this_pid)
                printf("WE ARE LEAVING!\n");
        tep_read_number_field(next_pid, record->data, &pid);
        if (pid == this_pid)
                printf("WE ARE ARRIVING!\n");
        return 0;
}

static int missed_callback(struct tep_event *event, struct tep_record *record,
                           int cpu, void *data)
{
        printf("OOPS! cpu %d dropped ", cpu);
        if (record->missed_events > 0)
                printf("%lld ", record->missed_events);
        printf("events\n");
        return 0;
}

static struct tracefs_instance *instance;
static struct my_struct my_data;

static void sig(int s)
{
        tracefs_iterate_stop(instance);
        my_data.stopped = true;
}

int main (int argc, char **argv, char **env)
{
        struct tep_handle *tep;
        int this_pid = getpid();

        instance = tracefs_instance_create("my-buffer");
        if (!instance)
                return -1;

        signal(SIGINT, sig);

        tracefs_event_enable(instance, NULL, NULL);
        sleep(1);
        tracefs_event_disable(instance, NULL, NULL);
        tep = tracefs_local_events(NULL);
        tep_load_plugins(tep);
        tracefs_follow_missed_events(instance, missed_callback, NULL);
        tracefs_follow_event(tep, instance, "sched", "sched_switch", sched_callback, &this_pid);
        tracefs_iterate_raw_events(tep, instance, NULL, 0, callback, &my_data);

        /* Note, the clear here is to show how to clear all followers
         * in case tracefs_iterate_raw_events() is called again, but
         * does not want to include the followers. It's not needed
         * here because tracefs_instance_free() will clean them up.
         */
        tracefs_follow_event_clear(instance, NULL, NULL);
        tracefs_follow_missed_events_clear(instance);

        tracefs_instance_destroy(instance);
        tracefs_instance_free(instance);

        if (my_data.stopped) {
                if (counter > MAX_COUNT)
                        printf("Finished max count\n");
                else
                        printf("Finished via signal\n");
        }

        return 0;
}