[RFC PATCH 0/4] Add a tracepoint for DTL entries

@@ -154,6 +154,17 @@ struct dtl_entry {
 #define DISPATCH_LOG_BYTES	4096	/* bytes per cpu */
 #define N_DISPATCH_LOG		(DISPATCH_LOG_BYTES / sizeof(struct dtl_entry))
 
+/*
+ * Dispatch trace log event enable mask:
+ *   0x1: voluntary virtual processor waits
+ *   0x2: time-slice preempts
+ *   0x4: virtual partition memory page faults
+ */
+#define DTL_LOG_CEDE		0x1
+#define DTL_LOG_PREEMPT		0x2
+#define DTL_LOG_FAULT		0x4
+#define DTL_LOG_ALL		(DTL_LOG_CEDE | DTL_LOG_PREEMPT | DTL_LOG_FAULT)
+
 extern struct kmem_cache *dtl_cache;
 
 /*

@@ -40,13 +40,7 @@ struct dtl {
 };
 static DEFINE_PER_CPU(struct dtl, cpu_dtl);
 
-/*
- * Dispatch trace log event mask:
- * 0x7: 0x1: voluntary virtual processor waits
- *      0x2: time-slice preempts
- *      0x4: virtual partition memory page faults
- */
-static u8 dtl_event_mask = 0x7;
+static u8 dtl_event_mask = DTL_LOG_ALL;
 
 
 /*

@@ -125,7 +125,7 @@ void vpa_init(int cpu)
 			pr_err("WARNING: DTL registration of cpu %d (hw %d) "
 			       "failed with %ld\n", smp_processor_id(),
 			       hwcpu, ret);
-		lppaca_of(cpu).dtl_enable_mask = 2;
+		lppaca_of(cpu).dtl_enable_mask = DTL_LOG_PREEMPT;
 	}
 }
 

@@ -293,7 +293,7 @@ static int alloc_dispatch_logs(void)
 		pr_err("WARNING: DTL registration of cpu %d (hw %d) failed "
 		       "with %d\n", smp_processor_id(),
 		       hard_smp_processor_id(), ret);
-	get_paca()->lppaca_ptr->dtl_enable_mask = 2;
+	get_paca()->lppaca_ptr->dtl_enable_mask = DTL_LOG_PREEMPT;
 
 	return 0;
 }

@@ -55,7 +55,6 @@ struct dtl_ring {
 	struct dtl_entry *write_ptr;
 	struct dtl_entry *buf;
 	struct dtl_entry *buf_end;
-	u8	saved_dtl_mask;
 };
 
 static DEFINE_PER_CPU(struct dtl_ring, dtl_rings);

@@ -105,7 +104,6 @@ static int dtl_start(struct dtl *dtl)
 	dtlr->write_ptr = dtl->buf;
 
 	/* enable event logging */
-	dtlr->saved_dtl_mask = lppaca_of(dtl->cpu).dtl_enable_mask;
 	lppaca_of(dtl->cpu).dtl_enable_mask |= dtl_event_mask;
 
 	dtl_consumer = consume_dtle;

@@ -123,7 +121,7 @@ static void dtl_stop(struct dtl *dtl)
 	dtlr->buf = NULL;
 
 	/* restore dtl_enable_mask */
-	lppaca_of(dtl->cpu).dtl_enable_mask = dtlr->saved_dtl_mask;
+	lppaca_of(dtl->cpu).dtl_enable_mask = DTL_LOG_PREEMPT;
 
 	if (atomic_dec_and_test(&dtl_count))
 		dtl_consumer = NULL;

@@ -101,6 +101,59 @@ TRACE_EVENT_FN_COND(hcall_exit,
 
 	hcall_tracepoint_regfunc, hcall_tracepoint_unregfunc
 );
+
+extern int dtl_entry_tracepoint_regfunc(void);
+extern void dtl_entry_tracepoint_unregfunc(void);
+extern u8 compute_dispatch_distance(unsigned int pcpu);
+
+TRACE_EVENT_FN(dtl_entry,
+
+	TP_PROTO(u8 dispatch_reason, u8 preempt_reason, u16 processor_id,
+		u32 enqueue_to_dispatch_time, u32 ready_to_enqueue_time,
+		u32 waiting_to_ready_time, u64 timebase, u64 fault_addr,
+		u64 srr0, u64 srr1),
+
+	TP_ARGS(dispatch_reason, preempt_reason, processor_id,
+		enqueue_to_dispatch_time, ready_to_enqueue_time,
+		waiting_to_ready_time, timebase, fault_addr,
+		srr0, srr1),
+
+	TP_STRUCT__entry(
+		__field(u8, dispatch_reason)
+		__field(u8, preempt_reason)
+		__field(u16, processor_id)
+		__field(u32, enqueue_to_dispatch_time)
+		__field(u32, ready_to_enqueue_time)
+		__field(u32, waiting_to_ready_time)
+		__field(u64, timebase)
+		__field(u64, fault_addr)
+		__field(u64, srr0)
+		__field(u64, srr1)
+		__field(u8, distance)
+	),
+
+	TP_fast_assign(
+		__entry->dispatch_reason = dispatch_reason;
+		__entry->preempt_reason = preempt_reason;
+		__entry->processor_id = processor_id;
+		__entry->enqueue_to_dispatch_time = enqueue_to_dispatch_time;
+		__entry->ready_to_enqueue_time = ready_to_enqueue_time;
+		__entry->waiting_to_ready_time = waiting_to_ready_time;
+		__entry->timebase = timebase;
+		__entry->fault_addr = fault_addr;
+		__entry->srr0 = srr0;
+		__entry->srr1 = srr1;
+		__entry->distance = compute_dispatch_distance(processor_id);
+	),
+
+	TP_printk("dispatch_reason=%u preempt_reason=%u processor_id=%u enq_to_disp=%u ready_to_enq=%u wait_to_ready=%u tb=%llu fault_addr=0x%llx srr0=0x%llx srr1=0x%llx distance=%u",
+		__entry->dispatch_reason, __entry->preempt_reason, __entry->processor_id,
+		__entry->enqueue_to_dispatch_time, __entry->ready_to_enqueue_time,
+		__entry->waiting_to_ready_time, __entry->timebase, __entry->fault_addr,
+		__entry->srr0, __entry->srr1, __entry->distance),
+
+	dtl_entry_tracepoint_regfunc, dtl_entry_tracepoint_unregfunc
+);
 #endif
 
 #ifdef CONFIG_PPC_POWERNV

@@ -220,6 +220,15 @@ static u64 scan_dispatch_log(u64 stop_tb)
 			break;
 		if (dtl_consumer)
 			dtl_consumer(dtl, i);
+		trace_dtl_entry(dtl->dispatch_reason, dtl->preempt_reason,
+				be16_to_cpu(dtl->processor_id),
+				be32_to_cpu(dtl->enqueue_to_dispatch_time),
+				be32_to_cpu(dtl->ready_to_enqueue_time),
+				be32_to_cpu(dtl->waiting_to_ready_time),
+				be64_to_cpu(dtl->timebase),
+				be64_to_cpu(dtl->fault_addr),
+				be64_to_cpu(dtl->srr0),
+				be64_to_cpu(dtl->srr1));
 		stolen += tb_delta;
 		++i;
 		++dtl;

@@ -41,6 +41,7 @@
 #include <asm/setup.h>
 #include <asm/vdso.h>
 #include <asm/drmem.h>
+#include <asm/trace.h>
 
 static int numa_enabled = 1;
 

@@ -1078,6 +1079,9 @@ static int prrn_enabled;
 static void reset_topology_timer(void);
 static int topology_timer_secs = 1;
 static int topology_inited;
+static __be32 vcpu_associativity[NR_CPUS][VPHN_ASSOC_BUFSIZE];
+static __be32 pcpu_associativity[NR_CPUS][VPHN_ASSOC_BUFSIZE];
+static unsigned int associativity_depth;
 
 /*
  * Change polling interval for associativity changes.

@@ -1157,14 +1161,12 @@ static int update_cpu_associativity_changes_mask(void)
  * Retrieve the new associativity information for a virtual processor's
  * home node.
  */
-static long hcall_vphn(unsigned long cpu, __be32 *associativity)
+static long hcall_vphn(unsigned long cpu, unsigned long flags, __be32 *associativity)
 {
 	long rc;
 	long retbuf[PLPAR_HCALL9_BUFSIZE] = {0};
-	u64 flags = 1;
-	int hwcpu = get_hard_smp_processor_id(cpu);
 
-	rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, retbuf, flags, hwcpu);
+	rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, retbuf, flags, cpu);
 	vphn_unpack_associativity(retbuf, associativity);
 
 	return rc;

@@ -1175,7 +1177,7 @@ static long vphn_get_associativity(unsigned long cpu,
 {
 	long rc;
 
-	rc = hcall_vphn(cpu, associativity);
+	rc = hcall_vphn(get_hard_smp_processor_id(cpu), 1, associativity);
 
 	switch (rc) {
 	case H_FUNCTION:

@@ -1200,7 +1202,7 @@ static long vphn_get_associativity(unsigned long cpu,
 
 int find_and_online_cpu_nid(int cpu)
 {
-	__be32 associativity[VPHN_ASSOC_BUFSIZE] = {0};
+	__be32 *associativity = vcpu_associativity[cpu];
 	int new_nid;
 
 	/* Use associativity from first thread for all siblings */

@@ -1234,6 +1236,86 @@ int find_and_online_cpu_nid(int cpu)
 	return new_nid;
 }
 
+static unsigned int find_possible_pcpus(void)
+{
+	struct device_node *rtas;
+	unsigned int max_depth, num_pcpus = 0;
+
+	rtas = of_find_node_by_path("/rtas");
+	if (min_common_depth <= 0 || !rtas)
+		return 0;
+
+	if (!of_property_read_u32(rtas,
+				"ibm,max-associativity-domains",
+				&max_depth))
+		of_property_read_u32_index(rtas,
+					   "ibm,max-associativity-domains",
+					   max_depth, &num_pcpus);
+
+	of_node_put(rtas);
+
+	return num_pcpus;
+}
+
+int dtl_entry_tracepoint_regfunc(void)
+{
+	unsigned int i, num_pcpus, pcpu_associativity_depth = 0;
+	long rc;
+
+	num_pcpus = find_possible_pcpus();
+	if (num_pcpus <= 0)
+		num_pcpus = NR_CPUS;
+	else
+		/*
+		 * The OF property reports the maximum cpu number.
+		 * We instead want the maximum number of cpus.
+		 */
+		num_pcpus++;
+
+	for (i = 0; i < NR_CPUS; i++) {
+		pcpu_associativity[i][0] = NR_CPUS;
+		if (i < num_pcpus && vphn_enabled) {
+			rc = hcall_vphn(i, 2, pcpu_associativity[i]);
+			if (!pcpu_associativity_depth && rc == H_SUCCESS)
+				pcpu_associativity_depth = pcpu_associativity[i][0];
+		}
+	}
+
+	if (vphn_enabled)
+		associativity_depth = min(pcpu_associativity_depth,
+				vcpu_associativity[smp_processor_id()][0]);
+
+	if (set_dtl_mask(-1, DTL_LOG_ALL))
+		return -EBUSY;
+
+	return 0;
+}
+
+void dtl_entry_tracepoint_unregfunc(void)
+{
+	reset_dtl_mask(-1);
+}
+
+u8 compute_dispatch_distance(unsigned int pcpu)
+{
+	__be32 *pcpu_assoc, *vcpu_assoc;
+	unsigned int i, distance = associativity_depth;
+
+	vcpu_assoc = vcpu_associativity[smp_processor_id()];
+	pcpu_assoc = pcpu_associativity[pcpu];
+
+	if (!vphn_enabled || pcpu_assoc[0] == NR_CPUS)
+		return 255;
+
+	for (i = 1; i <= associativity_depth; i++)
+		if (vcpu_assoc[i] == pcpu_assoc[i])
+			distance--;
+		else
+			break;
+
+	return distance;
+}
+
 /*
  * Update the CPU maps and sysfs entries for a single CPU when its NUMA
  * characteristics change. This function doesn't perform any locking and is

@@ -165,6 +165,10 @@ struct dtl_entry {
 #define DTL_LOG_FAULT		0x4
 #define DTL_LOG_ALL		(DTL_LOG_CEDE | DTL_LOG_PREEMPT | DTL_LOG_FAULT)
 
+extern u8 dtl_mask;
+int set_dtl_mask(int cpu, int mask);
+void reset_dtl_mask(int cpu);
+
 extern struct kmem_cache *dtl_cache;
 
 /*

@@ -104,7 +104,8 @@ static int dtl_start(struct dtl *dtl)
 	dtlr->write_ptr = dtl->buf;
 
 	/* enable event logging */
-	lppaca_of(dtl->cpu).dtl_enable_mask |= dtl_event_mask;
+	if (set_dtl_mask(dtl->cpu, dtl_event_mask))
+		return -EBUSY;
 
 	dtl_consumer = consume_dtle;
 	atomic_inc(&dtl_count);

@@ -121,7 +122,7 @@ static void dtl_stop(struct dtl *dtl)
 	dtlr->buf = NULL;
 
 	/* restore dtl_enable_mask */
-	lppaca_of(dtl->cpu).dtl_enable_mask = DTL_LOG_PREEMPT;
+	reset_dtl_mask(dtl->cpu);
 
 	if (atomic_dec_and_test(&dtl_count))
 		dtl_consumer = NULL;

@@ -58,12 +58,74 @@
 #define HBR_AVPN	0x0200000000000000UL
 #define HBR_ANDCOND	0x0100000000000000UL
 
+u8 dtl_mask = DTL_LOG_PREEMPT;
+static u8 dtl_mask_global_refctr, dtl_mask_percpu_inuse;
+static DEFINE_MUTEX(dtl_mask_mutex);
 
 /* in hvCall.S */
 EXPORT_SYMBOL(plpar_hcall);
 EXPORT_SYMBOL(plpar_hcall9);
 EXPORT_SYMBOL(plpar_hcall_norets);
 
+int set_dtl_mask(int cpu, int mask)
+{
+	int rc = 0;
+
+	mutex_lock(&dtl_mask_mutex);
+
+	if ((cpu == -1 && dtl_mask_percpu_inuse) ||
+	    (cpu >= 0 && dtl_mask_global_refctr)) {
+		rc = -1;
+		goto out;
+	}
+
+	if (cpu >= 0) {
+		dtl_mask_percpu_inuse++;
+		lppaca_of(cpu).dtl_enable_mask = mask;
+		goto out;
+	}
+
+	if (dtl_mask_global_refctr && mask != dtl_mask) {
+		rc = -1;
+		goto out;
+	}
+
+	if (!dtl_mask_global_refctr) {
+		dtl_mask = mask;
+		for_each_present_cpu(cpu)
+			lppaca_of(cpu).dtl_enable_mask = mask;
+	}
+
+	dtl_mask_global_refctr++;
+
+out:
+	mutex_unlock(&dtl_mask_mutex);
+
+	return rc;
+}
+
+void reset_dtl_mask(int cpu)
+{
+	mutex_lock(&dtl_mask_mutex);
+
+	if (cpu >= 0) {
+		dtl_mask_percpu_inuse--;
+		lppaca_of(cpu).dtl_enable_mask = DTL_LOG_PREEMPT;
+		goto out;
+	}
+
+	dtl_mask_global_refctr--;
+
+	if (!dtl_mask_global_refctr) {
+		dtl_mask = DTL_LOG_PREEMPT;
+		for_each_present_cpu(cpu)
+			lppaca_of(cpu).dtl_enable_mask = dtl_mask;
+	}
+
+out:
+	mutex_unlock(&dtl_mask_mutex);
+}
+
 void vpa_init(int cpu)
 {
 	int hwcpu = get_hard_smp_processor_id(cpu);

@@ -125,7 +187,7 @@ void vpa_init(int cpu)
 			pr_err("WARNING: DTL registration of cpu %d (hw %d) "
 			       "failed with %ld\n", smp_processor_id(),
 			       hwcpu, ret);
-		lppaca_of(cpu).dtl_enable_mask = DTL_LOG_PREEMPT;
+		lppaca_of(cpu).dtl_enable_mask = dtl_mask;
 	}
 }
 

@@ -293,7 +293,7 @@ static int alloc_dispatch_logs(void)
 		pr_err("WARNING: DTL registration of cpu %d (hw %d) failed "
 		       "with %d\n", smp_processor_id(),
 		       hard_smp_processor_id(), ret);
-	get_paca()->lppaca_ptr->dtl_enable_mask = DTL_LOG_PREEMPT;
+	get_paca()->lppaca_ptr->dtl_enable_mask = dtl_mask;
 
 	return 0;
 }