Skip to contentSkip to conversation

perf inject --jit: Remove //anon mmap events

PATCH Superseded Steve MacLean 2 participants 2 messages Oct 31, 2019 perf events

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 perf inject --jit: Remove //anon mmap events

From: Steve MacLean <[email protected]>

While a JIT is jitting code it will eventually need to commit more pages and change these pages to executable permissions.

Typically the JIT will want these colocated to minimize branch displacements.

The kernel will coalesce these anonymous mapping with identical permissions before sending an MMAP event for the new pages. This means the mmap event for the new pages will include the older pages.

These anonymous mmap events will obscure the jitdump injected pseudo events. This means that the jitdump generated symbols, machine code, debugging info, and unwind info will no longer be used.

Observations:

When a process emits a jit dump marker and a jitdump file, the perf-xxx.map file represents inferior information which has been superceded by the jitdump jit-xxx.dump file.

Further the '//anon*' mmap events are only required for the legacy perf-xxx.map mapping.

When attaching to an existing process, the synthetic anon map events are given a time stamp of -1. These should not obscure the jitdump events which have an actual time.

Summary:

Use thread->priv to store whether a jitdump file has been processed

During "perf inject --jit", discard "//anon*" mmap events for any pid which has sucessfully processed a jitdump file.

Committer testing:

// jitdump case
perf record <app with jitdump>
perf inject --jit --input perf.data --output perfjit.data

// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'

// no jitdump case
perf record <app without jitdump>
perf inject --jit --input perf.data --output perfjit.data

// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events not removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'

Repro:

This issue was discovered while testing the initial CoreCLR jitdump implementation. https://github.com/dotnet/coreclr/pull/26897.

Cc Peter Zijlstra <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
Cc Mark Rutland <[email protected]>
Cc Alexander Shishkin <[email protected]>
Cc Jiri Olsa <[email protected]>
Cc Namhyung Kim <[email protected]>
Cc Stephane Eranian <[email protected]>
---
 tools/perf/builtin-inject.c |  4 ++--
 tools/perf/util/jitdump.c   | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+), 2 deletions(-)
tools/perf/builtin-inject.c +2 -2
index 372ecb3..0f38862 100644
@@ -263,7 +263,7 @@ static int perf_event__jit_repipe_mmap(struct perf_tool *tool,
 	 * if jit marker, then inject jit mmaps and generate ELF images
 	 */
 	ret = jit_process(inject->session, &inject->output, machine,
-			  event->mmap.filename, sample->pid, &n);
+			  event->mmap.filename, event->mmap.pid, &n);
 	if (ret < 0)
 		return ret;
 	if (ret) {
@@ -301,7 +301,7 @@ static int perf_event__jit_repipe_mmap2(struct perf_tool *tool,
 	 * if jit marker, then inject jit mmaps and generate ELF images
 	 */
 	ret = jit_process(inject->session, &inject->output, machine,
-			  event->mmap2.filename, sample->pid, &n);
+			  event->mmap2.filename, event->mmap2.pid, &n);
 	if (ret < 0)
 		return ret;
 	if (ret) {
tools/perf/util/jitdump.c +38 -0
index e3ccb0c..c36d19b 100644
@@ -26,6 +26,7 @@
 #include "jit.h"
 #include "jitdump.h"
 #include "genelf.h"
+#include "thread.h"
 
 #include <linux/ctype.h>
 #include <linux/zalloc.h>
@@ -749,6 +750,34 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 	return 0;
 }
 
+static void jit_add_pid(struct machine *machine, pid_t pid)
+{
+	struct thread *thread = machine__findnew_thread(machine, pid, pid);
+
+	if (!thread)
+	{
+		pr_err("jit_add_pid() thread not found\n");
+
+		return;
+	}
+
+	thread->priv = (void *) 1;
+}
+
+static bool jit_has_pid(struct machine *machine, pid_t pid)
+{
+	struct thread *thread = machine__findnew_thread(machine, pid, pid);
+
+	if (!thread)
+	{
+		pr_err("jit_has_pid() thread not found\n");
+
+		return 0;
+	}
+
+	return (bool) thread->priv;
+}
+
 int
 jit_process(struct perf_session *session,
 	    struct perf_data *output,
@@ -765,7 +794,15 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 	 * first, detect marker mmap (i.e., the jitdump mmap)
 	 */
 	if (jit_detect(filename, pid))
+	{
+		/*
+		 * Strip //anon* mmaps if we processed a jitdump for this pid
+		 */
+		if (jit_has_pid(machine, pid) && (strncmp(filename, "//anon", 6) == 0))
+			return 1;
+
 		return 0;
+	}
 
 	memset(&jd, 0, sizeof(jd));
 
@@ -784,6 +821,7 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 
 	ret = jit_inject(&jd, filename);
 	if (!ret) {
+		jit_add_pid(machine, pid);
 		*nbytes = jd.bytes_written;
 		ret = 1;
 	}
Signature · 1 line
1.8.3.1
#1 lore raw

Em Wed, Oct 30, 2019 at 06:05:12PM -0700, Steve MacLean escreveu:

Quoted 5 lines

From: Steve MacLean <[email protected]>

tools/perf/util/jitdump.c +0 -0
@@ -749,6 +750,34 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 	return 0;
 }
 

tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 762

Quoted 10 lines
tools/perf/util/jitdump.c +10 -0
+static void jit_add_pid(struct machine *machine, pid_t pid)
+{
+	struct thread *thread = machine__findnew_thread(machine, pid, pid);
+
+	if (!thread)
+	{
+		pr_err("jit_add_pid() thread not found\n");
+
+		return;
+	}

Can you please follow the coding style used in tools/? Its mostly the same as for the kernel sources.

I.e. above you need to have it as:

	if (!thread) {
		pr_err("jit_add_pid() thread not found\n");
		return;
	}

There also consider using __funct__ and showing the pid that wasn't found.

Review static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 764

Quoted 2 lines
(quoted diff) +2 -0
+
+	thread->priv = (void *) 1;

No space after the cast.

Quoted 4 lines
tools/perf/util/jitdump.c +4 -0
+}
+
+static bool jit_has_pid(struct machine *machine, pid_t pid)
+{

tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 778

Quoted 10 lines
tools/perf/util/jitdump.c +10 -0
+	struct thread *thread = machine__findnew_thread(machine, pid, pid);
+
+	if (!thread)
+	{
+		pr_err("jit_has_pid() thread not found\n");
+
+		return 0;
+	}
+
+	return (bool) thread->priv;

Same style problems and the only way for machine__findnew_thread() to fail is if the system is under severe memory exhaustion, what you probably want to use here is machine__find_thread(), that will fail if the pid isn't found, the findnew methods, in the machine class or elsewhere will return an existing thread _or_ create and insert it, then return the newly added/inserted object.

tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 797

Quoted 10 lines
tools/perf/util/jitdump.c +3 -0
+}
+
 int
 jit_process(struct perf_session *session,
 	    struct perf_data *output,
@@ -765,7 +794,15 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 	 * first, detect marker mmap (i.e., the jitdump mmap)
 	 */
 	if (jit_detect(filename, pid))
+	{

if () {

tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 800

Quoted 3 lines
tools/perf/util/jitdump.c +3 -0
+		/*
+		 * Strip //anon* mmaps if we processed a jitdump for this pid
+		 */

// can be used, not strictly required tho, the way you used is acceptable.

Quoted 16 lines
tools/perf/util/jitdump.c +5 -0
+		if (jit_has_pid(machine, pid) && (strncmp(filename, "//anon", 6) == 0))
+			return 1;
+
 		return 0;
+	}
 
 	memset(&jd, 0, sizeof(jd));
 
@@ -784,6 +821,7 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 
 	ret = jit_inject(&jd, filename);
 	if (!ret) {
+		jit_add_pid(machine, pid);
 		*nbytes = jd.bytes_written;
 		ret = 1;
 	}