genirq/matrix: Add tracepoints

Add tracepoints for the irq bitmap matrix allocator.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Juergen Gross <jgross@suse.com>
Tested-by: Yu Chen <yu.c.chen@intel.com>
Acked-by: Juergen Gross <jgross@suse.com>
Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Marc Zyngier <marc.zyngier@arm.com>
Cc: Alok Kataria <akataria@vmware.com>
Cc: Joerg Roedel <joro@8bytes.org>
Cc: "Rafael J. Wysocki" <rjw@rjwysocki.net>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Rui Zhang <rui.zhang@intel.com>
Cc: "K. Y. Srinivasan" <kys@microsoft.com>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Len Brown <lenb@kernel.org>
Link: https://lkml.kernel.org/r/20170913213153.279468022@linutronix.de

2 files changed, 216 insertions, 0 deletions

diff --git a/include/trace/events/irq_matrix.h b/include/trace/events/irq_matrix.h
new file mode 100644
index 000000000000..267d4cbbf360
--- /dev/null
+++ b/include/trace/events/irq_matrix.h
@@ -0,0 +1,201 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM irq_matrix
+
+#if !defined(_TRACE_IRQ_MATRIX_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_IRQ_MATRIX_H
+
+#include <linux/tracepoint.h>
+
+struct irq_matrix;
+struct cpumap;
+
+DECLARE_EVENT_CLASS(irq_matrix_global,
+
+        TP_PROTO(struct irq_matrix *matrix),
+
+        TP_ARGS(matrix),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   online_maps             )
+                __field(        unsigned int,   global_available        )
+                __field(        unsigned int,   global_reserved         )
+                __field(        unsigned int,   total_allocated         )
+        ),
+
+        TP_fast_assign(
+                __entry->online_maps            = matrix->online_maps;
+                __entry->global_available       = matrix->global_available;
+                __entry->global_reserved        = matrix->global_reserved;
+                __entry->total_allocated        = matrix->total_allocated;
+        ),
+
+        TP_printk("online_maps=%d global_avl=%u, global_rsvd=%u, total_alloc=%u",
+                  __entry->online_maps, __entry->global_available,
+                  __entry->global_reserved, __entry->total_allocated)
+);
+
+DECLARE_EVENT_CLASS(irq_matrix_global_update,
+
+        TP_PROTO(int bit, struct irq_matrix *matrix),
+
+        TP_ARGS(bit, matrix),
+
+        TP_STRUCT__entry(
+                __field(        int,            bit                     )
+                __field(        unsigned int,   online_maps             )
+                __field(        unsigned int,   global_available        )
+                __field(        unsigned int,   global_reserved         )
+                __field(        unsigned int,   total_allocated         )
+        ),
+
+        TP_fast_assign(
+                __entry->bit                    = bit;
+                __entry->online_maps            = matrix->online_maps;
+                __entry->global_available       = matrix->global_available;
+                __entry->global_reserved        = matrix->global_reserved;
+                __entry->total_allocated        = matrix->total_allocated;
+        ),
+
+        TP_printk("bit=%d online_maps=%d global_avl=%u, global_rsvd=%u, total_alloc=%u",
+                  __entry->bit, __entry->online_maps,
+                  __entry->global_available, __entry->global_reserved,
+                  __entry->total_allocated)
+);
+
+DECLARE_EVENT_CLASS(irq_matrix_cpu,
+
+        TP_PROTO(int bit, unsigned int cpu, struct irq_matrix *matrix,
+                 struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap),
+
+        TP_STRUCT__entry(
+                __field(        int,            bit                     )
+                __field(        unsigned int,   cpu                     )
+                __field(        bool,           online                  )
+                __field(        unsigned int,   available               )
+                __field(        unsigned int,   allocated               )
+                __field(        unsigned int,   managed                 )
+                __field(        unsigned int,   online_maps             )
+                __field(        unsigned int,   global_available        )
+                __field(        unsigned int,   global_reserved         )
+                __field(        unsigned int,   total_allocated         )
+        ),
+
+        TP_fast_assign(
+                __entry->bit                    = bit;
+                __entry->cpu                    = cpu;
+                __entry->online                 = cmap->online;
+                __entry->available              = cmap->available;
+                __entry->allocated              = cmap->allocated;
+                __entry->managed                = cmap->managed;
+                __entry->online_maps            = matrix->online_maps;
+                __entry->global_available       = matrix->global_available;
+                __entry->global_reserved        = matrix->global_reserved;
+                __entry->total_allocated        = matrix->total_allocated;
+        ),
+
+        TP_printk("bit=%d cpu=%u online=%d avl=%u alloc=%u managed=%u online_maps=%u global_avl=%u, global_rsvd=%u, total_alloc=%u",
+                  __entry->bit, __entry->cpu, __entry->online,
+                  __entry->available, __entry->allocated,
+                  __entry->managed, __entry->online_maps,
+                  __entry->global_available, __entry->global_reserved,
+                  __entry->total_allocated)
+);
+
+DEFINE_EVENT(irq_matrix_global, irq_matrix_online,
+
+        TP_PROTO(struct irq_matrix *matrix),
+
+        TP_ARGS(matrix)
+);
+
+DEFINE_EVENT(irq_matrix_global, irq_matrix_offline,
+
+        TP_PROTO(struct irq_matrix *matrix),
+
+        TP_ARGS(matrix)
+);
+
+DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve,
+
+        TP_PROTO(struct irq_matrix *matrix),
+
+        TP_ARGS(matrix)
+);
+
+DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved,
+
+        TP_PROTO(struct irq_matrix *matrix),
+
+        TP_ARGS(matrix)
+);
+
+DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system,
+
+        TP_PROTO(int bit, struct irq_matrix *matrix),
+
+        TP_ARGS(bit, matrix)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_reserved,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free,
+
+        TP_PROTO(int bit, unsigned int cpu,
+                 struct irq_matrix *matrix, struct cpumap *cmap),
+
+        TP_ARGS(bit, cpu, matrix, cmap)
+);
+
+
+#endif /*  _TRACE_IRQ_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/kernel/irq/matrix.c b/kernel/irq/matrix.c
index 7b2b4fbde1e2..a3cbbc8191c5 100644
--- a/kernel/irq/matrix.c
+++ b/kernel/irq/matrix.c
@@ -36,6 +36,9 @@ struct irq_matrix {
         unsigned long           system_map[IRQ_MATRIX_SIZE];
 };
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/irq_matrix.h>
+
 /**
  * irq_alloc_matrix - Allocate a irq_matrix structure and initialize it
  * @matrix_bits:        Number of matrix bits must be <= IRQ_MATRIX_BITS
@@ -84,6 +87,7 @@ void irq_matrix_online(struct irq_matrix *m)
         m->global_available += cm->available;
         cm->online = true;
         m->online_maps++;
+        trace_irq_matrix_online(m);
 }
 
 /**
@@ -98,6 +102,7 @@ void irq_matrix_offline(struct irq_matrix *m)
         m->global_available -= cm->available;
         cm->online = false;
         m->online_maps--;
+        trace_irq_matrix_offline(m);
 }
 
 static unsigned int matrix_alloc_area(struct irq_matrix *m, struct cpumap *cm,
@@ -145,6 +150,8 @@ void irq_matrix_assign_system(struct irq_matrix *m, unsigned int bit,
         }
         if (bit >= m->alloc_start && bit < m->alloc_end)
                 m->systembits_inalloc++;
+
+        trace_irq_matrix_assign_system(bit, m);
 }
 
 /**
@@ -172,6 +179,7 @@ int irq_matrix_reserve_managed(struct irq_matrix *m, const struct cpumask *msk)
                         cm->available--;
                         m->global_available--;
                 }
+                trace_irq_matrix_reserve_managed(bit, cpu, m, cm);
         }
         return 0;
 cleanup:
@@ -221,6 +229,7 @@ void irq_matrix_remove_managed(struct irq_matrix *m, const struct cpumask *msk)
                         cm->available++;
                         m->global_available++;
                 }
+                trace_irq_matrix_remove_managed(bit, cpu, m, cm);
         }
 }
 
@@ -242,6 +251,7 @@ int irq_matrix_alloc_managed(struct irq_matrix *m, unsigned int cpu)
         set_bit(bit, cm->alloc_map);
         cm->allocated++;
         m->total_allocated++;
+        trace_irq_matrix_alloc_managed(bit, cpu, m, cm);
         return bit;
 }
 
@@ -264,6 +274,7 @@ void irq_matrix_assign(struct irq_matrix *m, unsigned int bit)
         m->total_allocated++;
         cm->available--;
         m->global_available--;
+        trace_irq_matrix_assign(bit, smp_processor_id(), m, cm);
 }
 
 /**
@@ -282,6 +293,7 @@ void irq_matrix_reserve(struct irq_matrix *m)
                 pr_warn("Interrupt reservation exceeds available resources\n");
 
         m->global_reserved++;
+        trace_irq_matrix_reserve(m);
 }
 
 /**
@@ -296,6 +308,7 @@ void irq_matrix_reserve(struct irq_matrix *m)
 void irq_matrix_remove_reserved(struct irq_matrix *m)
 {
         m->global_reserved--;
+        trace_irq_matrix_remove_reserved(m);
 }
 
 /**
@@ -326,6 +339,7 @@ int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
                         if (reserved)
                                 m->global_reserved--;
                         *mapped_cpu = cpu;
+                        trace_irq_matrix_alloc(bit, cpu, m, cm);
                         return bit;
                 }
         }
@@ -357,6 +371,7 @@ void irq_matrix_free(struct irq_matrix *m, unsigned int cpu,
                         m->global_available++;
                 }
         }
+        trace_irq_matrix_free(bit, cpu, m, cm);
 }
 
 /**