Skip to contentSkip to conversation

uprobes: turn trace_uprobe's nhit counter to be per-CPU one

PATCH In review Andrii Nakryiko 4 participants 7 messages Aug 13, 2024 – Sep 4, 2024

Subsystems (2)
lore
Share & tools
lore

Andrii Nakryiko

author maintainer
#0 lore raw

PATCH v3 1/1 uprobes: turn trace_uprobe's nhit counter to be per-CPU one

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Solve both problems by making this a per-CPU counter.

---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -3
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
 	char				*filename;
 	unsigned long			offset;
 	unsigned long			ref_ctr_offset;
-	unsigned long			nhit;
+	unsigned long __percpu		*nhits;
 	struct trace_probe		tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	if (!tu)
 		return ERR_PTR(-ENOMEM);
 
+	tu->nhits = alloc_percpu(unsigned long);
+	if (!tu->nhits) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
 	ret = trace_probe_init(&tu->tp, event, group, true, nargs);
 	if (ret < 0)
 		goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	return tu;
 
 error:
+	free_percpu(tu->nhits);
 	kfree(tu);
 
 	return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
 	path_put(&tu->path);
 	trace_probe_cleanup(&tu->tp);
 	kfree(tu->filename);
+	free_percpu(tu->nhits);
 	kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
 	struct dyn_event *ev = v;
 	struct trace_uprobe *tu;
+	unsigned long nhits;
+	int cpu;
 
 	if (!is_trace_uprobe(ev))
 		return 0;
 
 	tu = to_trace_uprobe(ev);
+
+	nhits = 0;
+	for_each_possible_cpu(cpu) {
+		nhits += per_cpu(*tu->nhits, cpu);
+	}
+
 	seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-			trace_probe_name(&tu->tp), tu->nhit);
+		   trace_probe_name(&tu->tp), nhits);
 	return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 	int ret = 0;
 
 	tu = container_of(con, struct trace_uprobe, consumer);
-	tu->nhit++;
+
+	this_cpu_inc(*tu->nhits);
 
 	udd.tu = tu;
 	udd.bp_addr = instruction_pointer(regs);
Signature · 1 line
2.43.5
#1 lore raw
Quoted 8 lines · Andrii Nakryiko

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Quoted 8 lines

Solve both problems by making this a per-CPU counter.

---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

Is there anything else I'm expected to do about this patch? If not, can this please be applied? Thanks!

Quoted 86 lines
kernel/trace/trace_uprobe.c +21 -4
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
        char                            *filename;
        unsigned long                   offset;
        unsigned long                   ref_ctr_offset;
-       unsigned long                   nhit;
+       unsigned long __percpu          *nhits;
        struct trace_probe              tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
        if (!tu)
                return ERR_PTR(-ENOMEM);
 
+       tu->nhits = alloc_percpu(unsigned long);
+       if (!tu->nhits) {
+               ret = -ENOMEM;
+               goto error;
+       }
+
        ret = trace_probe_init(&tu->tp, event, group, true, nargs);
        if (ret < 0)
                goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
        return tu;
 
 error:
+       free_percpu(tu->nhits);
        kfree(tu);
 
        return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
        path_put(&tu->path);
        trace_probe_cleanup(&tu->tp);
        kfree(tu->filename);
+       free_percpu(tu->nhits);
        kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
        struct dyn_event *ev = v;
        struct trace_uprobe *tu;
+       unsigned long nhits;
+       int cpu;
 
        if (!is_trace_uprobe(ev))
                return 0;
 
        tu = to_trace_uprobe(ev);
+
+       nhits = 0;
+       for_each_possible_cpu(cpu) {
+               nhits += per_cpu(*tu->nhits, cpu);
+       }
+
        seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-                       trace_probe_name(&tu->tp), tu->nhit);
+                  trace_probe_name(&tu->tp), nhits);
        return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
        int ret = 0;
 
        tu = container_of(con, struct trace_uprobe, consumer);
-       tu->nhit++;
+
+       this_cpu_inc(*tu->nhits);
 
        udd.tu = tu;
        udd.bp_addr = instruction_pointer(regs);
--

2.43.5

Reviewed-by on v3 1/1
#2 lore raw
In reply to Andrii Nakryiko
Quoted 11 lines · Andrii Nakryiko

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Solve both problems by making this a per-CPU counter.

lgtm, fwiw

jirka

Quoted 90 lines
---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -3
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
 	char				*filename;
 	unsigned long			offset;
 	unsigned long			ref_ctr_offset;
-	unsigned long			nhit;
+	unsigned long __percpu		*nhits;
 	struct trace_probe		tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	if (!tu)
 		return ERR_PTR(-ENOMEM);
 
+	tu->nhits = alloc_percpu(unsigned long);
+	if (!tu->nhits) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
 	ret = trace_probe_init(&tu->tp, event, group, true, nargs);
 	if (ret < 0)
 		goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	return tu;
 
 error:
+	free_percpu(tu->nhits);
 	kfree(tu);
 
 	return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
 	path_put(&tu->path);
 	trace_probe_cleanup(&tu->tp);
 	kfree(tu->filename);
+	free_percpu(tu->nhits);
 	kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
 	struct dyn_event *ev = v;
 	struct trace_uprobe *tu;
+	unsigned long nhits;
+	int cpu;
 
 	if (!is_trace_uprobe(ev))
 		return 0;
 
 	tu = to_trace_uprobe(ev);
+
+	nhits = 0;
+	for_each_possible_cpu(cpu) {
+		nhits += per_cpu(*tu->nhits, cpu);
+	}
+
 	seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-			trace_probe_name(&tu->tp), tu->nhit);
+		   trace_probe_name(&tu->tp), nhits);
 	return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 	int ret = 0;
 
 	tu = container_of(con, struct trace_uprobe, consumer);
-	tu->nhit++;
+
+	this_cpu_inc(*tu->nhits);
 
 	udd.tu = tu;
 	udd.bp_addr = instruction_pointer(regs);
Signature · 1 line
2.43.5
#3 lore raw
In reply to Andrii Nakryiko
Quoted 9 lines · On Tue, 13 Aug 2024 13:34:09 -0700 Andrii Nakryiko <[email protected]> wrote:

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Solve both problems by making this a per-CPU counter.

Looks good to me. Let me pick it.

Quoted 92 lines
---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -3
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
 	char				*filename;
 	unsigned long			offset;
 	unsigned long			ref_ctr_offset;
-	unsigned long			nhit;
+	unsigned long __percpu		*nhits;
 	struct trace_probe		tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	if (!tu)
 		return ERR_PTR(-ENOMEM);
 
+	tu->nhits = alloc_percpu(unsigned long);
+	if (!tu->nhits) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
 	ret = trace_probe_init(&tu->tp, event, group, true, nargs);
 	if (ret < 0)
 		goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	return tu;
 
 error:
+	free_percpu(tu->nhits);
 	kfree(tu);
 
 	return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
 	path_put(&tu->path);
 	trace_probe_cleanup(&tu->tp);
 	kfree(tu->filename);
+	free_percpu(tu->nhits);
 	kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
 	struct dyn_event *ev = v;
 	struct trace_uprobe *tu;
+	unsigned long nhits;
+	int cpu;
 
 	if (!is_trace_uprobe(ev))
 		return 0;
 
 	tu = to_trace_uprobe(ev);
+
+	nhits = 0;
+	for_each_possible_cpu(cpu) {
+		nhits += per_cpu(*tu->nhits, cpu);
+	}
+
 	seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-			trace_probe_name(&tu->tp), tu->nhit);
+		   trace_probe_name(&tu->tp), nhits);
 	return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 	int ret = 0;
 
 	tu = container_of(con, struct trace_uprobe, consumer);
-	tu->nhit++;
+
+	this_cpu_inc(*tu->nhits);
 
 	udd.tu = tu;
 	udd.bp_addr = instruction_pointer(regs);
Signature · 1 line
2.43.5
Signature · 1 line
Masami Hiramatsu (Google) <[email protected]>
#4 lore raw
In reply to Andrii Nakryiko
Quoted 9 lines · On Tue, 13 Aug 2024 13:34:09 -0700 Andrii Nakryiko <[email protected]> wrote:

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Solve both problems by making this a per-CPU counter.

Looks good to me. Let me pick it to linux-trace probes/for-next.

Thank you,

Quoted 92 lines
---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -3
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
 	char				*filename;
 	unsigned long			offset;
 	unsigned long			ref_ctr_offset;
-	unsigned long			nhit;
+	unsigned long __percpu		*nhits;
 	struct trace_probe		tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	if (!tu)
 		return ERR_PTR(-ENOMEM);
 
+	tu->nhits = alloc_percpu(unsigned long);
+	if (!tu->nhits) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
 	ret = trace_probe_init(&tu->tp, event, group, true, nargs);
 	if (ret < 0)
 		goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
 	return tu;
 
 error:
+	free_percpu(tu->nhits);
 	kfree(tu);
 
 	return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
 	path_put(&tu->path);
 	trace_probe_cleanup(&tu->tp);
 	kfree(tu->filename);
+	free_percpu(tu->nhits);
 	kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
 	struct dyn_event *ev = v;
 	struct trace_uprobe *tu;
+	unsigned long nhits;
+	int cpu;
 
 	if (!is_trace_uprobe(ev))
 		return 0;
 
 	tu = to_trace_uprobe(ev);
+
+	nhits = 0;
+	for_each_possible_cpu(cpu) {
+		nhits += per_cpu(*tu->nhits, cpu);
+	}
+
 	seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-			trace_probe_name(&tu->tp), tu->nhit);
+		   trace_probe_name(&tu->tp), nhits);
 	return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
 	int ret = 0;
 
 	tu = container_of(con, struct trace_uprobe, consumer);
-	tu->nhit++;
+
+	this_cpu_inc(*tu->nhits);
 
 	udd.tu = tu;
 	udd.bp_addr = instruction_pointer(regs);
Signature · 1 line
2.43.5
Signature · 1 line
Masami Hiramatsu (Google) <[email protected]>
#5 lore raw
Quoted 7 lines · Masami Hiramatsu
Quoted 3 lines · On Tue, 13 Aug 2024 13:34:09 -0700 Andrii Nakryiko <[email protected]> wrote:

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Quoted 9 lines
Quoted 6 lines

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Solve both problems by making this a per-CPU counter.

Looks good to me. Let me pick it to linux-trace probes/for-next.

Thanks! I just checked linux-trace repo, doesn't seem like this was applied yet, is that right? Or am I checking in the wrong place?

Quoted 100 lines

Thank you,

Quoted 90 lines
---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -4
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
      char                            *filename;
      unsigned long                   offset;
      unsigned long                   ref_ctr_offset;
-     unsigned long                   nhit;
+     unsigned long __percpu          *nhits;
      struct trace_probe              tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
      if (!tu)
              return ERR_PTR(-ENOMEM);
 
+     tu->nhits = alloc_percpu(unsigned long);
+     if (!tu->nhits) {
+             ret = -ENOMEM;
+             goto error;
+     }
+
      ret = trace_probe_init(&tu->tp, event, group, true, nargs);
      if (ret < 0)
              goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
      return tu;
 
 error:
+     free_percpu(tu->nhits);
      kfree(tu);
 
      return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
      path_put(&tu->path);
      trace_probe_cleanup(&tu->tp);
      kfree(tu->filename);
+     free_percpu(tu->nhits);
      kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
      struct dyn_event *ev = v;
      struct trace_uprobe *tu;
+     unsigned long nhits;
+     int cpu;
 
      if (!is_trace_uprobe(ev))
              return 0;
 
      tu = to_trace_uprobe(ev);
+
+     nhits = 0;
+     for_each_possible_cpu(cpu) {
+             nhits += per_cpu(*tu->nhits, cpu);
+     }
+
      seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-                     trace_probe_name(&tu->tp), tu->nhit);
+                trace_probe_name(&tu->tp), nhits);
      return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
      int ret = 0;
 
      tu = container_of(con, struct trace_uprobe, consumer);
-     tu->nhit++;
+
+     this_cpu_inc(*tu->nhits);
 
      udd.tu = tu;
      udd.bp_addr = instruction_pointer(regs);
--
Quoted 2 lines

2.43.5

--
Masami Hiramatsu (Google) <[email protected]>

#6 lore raw
Quoted 12 lines · On Thu, 29 Aug 2024 10:28:24 -0700 Andrii Nakryiko <[email protected]>…
Quoted 11 lines · Masami Hiramatsu
Quoted 7 lines · On Tue, 13 Aug 2024 13:34:09 -0700 Andrii Nakryiko <[email protected]> wrote:

trace_uprobe->nhit counter is not incremented atomically, so its value is questionable in when uprobe is hit on multiple CPUs simultaneously.

Also, doing this shared counter increment across many CPUs causes heavy cache line bouncing, limiting uprobe/uretprobe performance scaling with number of CPUs.

Quoted 8 lines
Quoted 5 lines
Quoted 2 lines

Solve both problems by making this a per-CPU counter.

Looks good to me. Let me pick it to linux-trace probes/for-next.

Thanks! I just checked linux-trace repo, doesn't seem like this was applied yet, is that right? Or am I checking in the wrong place?

Sorry, I missed to push probes/for-next. Let me push it.

Thank you,

Quoted 101 lines
Quoted 101 lines

Thank you,

Quoted 90 lines
---
 kernel/trace/trace_uprobe.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
kernel/trace/trace_uprobe.c +21 -4
index c98e3b3386ba..c3df411a2684 100644
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/rculist.h>
 #include <linux/filter.h>
+#include <linux/percpu.h>
 
 #include "trace_dynevent.h"
 #include "trace_probe.h"
@@ -62,7 +63,7 @@ struct trace_uprobe {
      char                            *filename;
      unsigned long                   offset;
      unsigned long                   ref_ctr_offset;
-     unsigned long                   nhit;
+     unsigned long __percpu          *nhits;
      struct trace_probe              tp;
 };
 
@@ -337,6 +338,12 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
      if (!tu)
              return ERR_PTR(-ENOMEM);
 
+     tu->nhits = alloc_percpu(unsigned long);
+     if (!tu->nhits) {
+             ret = -ENOMEM;
+             goto error;
+     }
+
      ret = trace_probe_init(&tu->tp, event, group, true, nargs);
      if (ret < 0)
              goto error;
@@ -349,6 +356,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)
      return tu;
 
 error:
+     free_percpu(tu->nhits);
      kfree(tu);
 
      return ERR_PTR(ret);
@@ -362,6 +370,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
      path_put(&tu->path);
      trace_probe_cleanup(&tu->tp);
      kfree(tu->filename);
+     free_percpu(tu->nhits);
      kfree(tu);
 }
 
@@ -815,13 +824,21 @@ static int probes_profile_seq_show(struct seq_file *m, void *v)
 {
      struct dyn_event *ev = v;
      struct trace_uprobe *tu;
+     unsigned long nhits;
+     int cpu;
 
      if (!is_trace_uprobe(ev))
              return 0;
 
      tu = to_trace_uprobe(ev);
+
+     nhits = 0;
+     for_each_possible_cpu(cpu) {
+             nhits += per_cpu(*tu->nhits, cpu);
+     }
+
      seq_printf(m, "  %s %-44s %15lu\n", tu->filename,
-                     trace_probe_name(&tu->tp), tu->nhit);
+                trace_probe_name(&tu->tp), nhits);
      return 0;
 }
 
@@ -1512,7 +1529,8 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
      int ret = 0;
 
      tu = container_of(con, struct trace_uprobe, consumer);
-     tu->nhit++;
+
+     this_cpu_inc(*tu->nhits);
 
      udd.tu = tu;
      udd.bp_addr = instruction_pointer(regs);
--
Quoted 2 lines

2.43.5

--
Masami Hiramatsu (Google) <[email protected]>

Signature · 1 line
Masami Hiramatsu (Google) <[email protected]>