/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM osnoise

#if !defined(_OSNOISE_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)

#ifndef _OSNOISE_TRACE_H
#define _OSNOISE_TRACE_H
/*
 * osnoise sample structure definition. Used to store the statistics of a
 * sample run.
 */
struct osnoise_sample {
        u64                     runtime;        /* runtime */
        u64                     noise;          /* noise */
        u64                     max_sample;     /* max single noise sample */
        int                     hw_count;       /* # HW (incl. hypervisor) interference */
        int                     nmi_count;      /* # NMIs during this sample */
        int                     irq_count;      /* # IRQs during this sample */
        int                     softirq_count;  /* # softirqs during this sample */
        int                     thread_count;   /* # threads during this sample */
};

#ifdef CONFIG_TIMERLAT_TRACER
/*
 * timerlat sample structure definition. Used to store the statistics of
 * a sample run.
 */
struct timerlat_sample {
        u64                     timer_latency;  /* timer_latency */
        unsigned int            seqnum;         /* unique sequence */
        int                     context;        /* timer context */
};
#endif // CONFIG_TIMERLAT_TRACER
#endif // _OSNOISE_TRACE_H

#include <linux/tracepoint.h>
TRACE_EVENT(osnoise_sample,

        TP_PROTO(struct osnoise_sample *s),

        TP_ARGS(s),

        TP_STRUCT__entry(
                __field(        u64,            runtime )
                __field(        u64,            noise   )
                __field(        u64,            max_sample      )
                __field(        int,            hw_count        )
                __field(        int,            irq_count       )
                __field(        int,            nmi_count       )
                __field(        int,            softirq_count   )
                __field(        int,            thread_count    )
        ),

        TP_fast_assign(
                __entry->runtime = s->runtime;
                __entry->noise = s->noise;
                __entry->max_sample = s->max_sample;
                __entry->hw_count = s->hw_count;
                __entry->irq_count = s->irq_count;
                __entry->nmi_count = s->nmi_count;
                __entry->softirq_count = s->softirq_count;
                __entry->thread_count = s->thread_count;
        ),

        TP_printk("runtime=%llu noise=%llu max_sample=%llu hw_count=%d"
                  " irq_count=%d nmi_count=%d softirq_count=%d"
                  " thread_count=%d",
                  __entry->runtime,
                  __entry->noise,
                  __entry->max_sample,
                  __entry->hw_count,
                  __entry->irq_count,
                  __entry->nmi_count,
                  __entry->softirq_count,
                  __entry->thread_count)
);

#ifdef CONFIG_TIMERLAT_TRACER
TRACE_EVENT(timerlat_sample,

        TP_PROTO(struct timerlat_sample *s),

        TP_ARGS(s),

        TP_STRUCT__entry(
                __field(        u64,            timer_latency   )
                __field(        unsigned int,   seqnum          )
                __field(        int,            context         )
        ),

        TP_fast_assign(
                __entry->timer_latency = s->timer_latency;
                __entry->seqnum = s->seqnum;
                __entry->context = s->context;
        ),

        TP_printk("timer_latency=%llu seqnum=%u context=%d",
                  __entry->timer_latency,
                  __entry->seqnum,
                  __entry->context)
);
#endif // CONFIG_TIMERLAT_TRACER

TRACE_EVENT(thread_noise,

        TP_PROTO(struct task_struct *t, u64 start, u64 duration),

        TP_ARGS(t, start, duration),

        TP_STRUCT__entry(
                __array(        char,           comm,   TASK_COMM_LEN)
                __field(        u64,            start   )
                __field(        u64,            duration)
                __field(        pid_t,          pid     )
        ),

        TP_fast_assign(
                memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
                __entry->pid = t->pid;
                __entry->start = start;
                __entry->duration = duration;
        ),

        TP_printk("%8s:%d start %llu.%09u duration %llu ns",
                __entry->comm,
                __entry->pid,
                __print_ns_to_secs(__entry->start),
                __print_ns_without_secs(__entry->start),
                __entry->duration)
);

TRACE_EVENT(softirq_noise,

        TP_PROTO(int vector, u64 start, u64 duration),

        TP_ARGS(vector, start, duration),

        TP_STRUCT__entry(
                __field(        u64,            start   )
                __field(        u64,            duration)
                __field(        int,            vector  )
        ),

        TP_fast_assign(
                __entry->vector = vector;
                __entry->start = start;
                __entry->duration = duration;
        ),

        TP_printk("%8s:%d start %llu.%09u duration %llu ns",
                show_softirq_name(__entry->vector),
                __entry->vector,
                __print_ns_to_secs(__entry->start),
                __print_ns_without_secs(__entry->start),
                __entry->duration)
);

TRACE_EVENT(irq_noise,

        TP_PROTO(int vector, const char *desc, u64 start, u64 duration),

        TP_ARGS(vector, desc, start, duration),

        TP_STRUCT__entry(
                __field(        u64,            start   )
                __field(        u64,            duration)
                __string(       desc,           desc    )
                __field(        int,            vector  )

        ),

        TP_fast_assign(
                __assign_str(desc);
                __entry->vector = vector;
                __entry->start = start;
                __entry->duration = duration;
        ),

        TP_printk("%s:%d start %llu.%09u duration %llu ns",
                __get_str(desc),
                __entry->vector,
                __print_ns_to_secs(__entry->start),
                __print_ns_without_secs(__entry->start),
                __entry->duration)
);

TRACE_EVENT(nmi_noise,

        TP_PROTO(u64 start, u64 duration),

        TP_ARGS(start, duration),

        TP_STRUCT__entry(
                __field(        u64,            start   )
                __field(        u64,            duration)
        ),

        TP_fast_assign(
                __entry->start = start;
                __entry->duration = duration;
        ),

        TP_printk("start %llu.%09u duration %llu ns",
                __print_ns_to_secs(__entry->start),
                __print_ns_without_secs(__entry->start),
                __entry->duration)
);

TRACE_EVENT(sample_threshold,

        TP_PROTO(u64 start, u64 duration, u64 interference),

        TP_ARGS(start, duration, interference),

        TP_STRUCT__entry(
                __field(        u64,            start   )
                __field(        u64,            duration)
                __field(        u64,            interference)
        ),

        TP_fast_assign(
                __entry->start = start;
                __entry->duration = duration;
                __entry->interference = interference;
        ),

        TP_printk("start %llu.%09u duration %llu ns interference %llu",
                __print_ns_to_secs(__entry->start),
                __print_ns_without_secs(__entry->start),
                __entry->duration,
                __entry->interference)
);

#endif /* _TRACE_OSNOISE_H */

/* This part must be outside protection */
#include <trace/define_trace.h>