Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1218714 > unrolled thread

[PATCH 1/5] perf probe: Split add_perf_probe_events()

Started byNamhyung Kim <namhyung@kernel.org>
First post2015-09-04 10:00 +0200
Last post2015-09-04 14:20 +0200
Articles 9 — 2 participants

Back to article view | Back to linux.kernel

Contents

  [PATCH 1/5] perf probe: Split add_perf_probe_events() Namhyung Kim <namhyung@kernel.org> - 2015-09-04 10:00 +0200
    [PATCH 3/5] perf probe: Move print logic into cmd_probe() Namhyung Kim <namhyung@kernel.org> - 2015-09-04 10:00 +0200
      RE: [PATCH 3/5] perf probe: Move print logic into cmd_probe() 平松雅巳 / HIRAMATU，MASAMI   <masami.hiramatsu.pt@hitachi.com> - 2015-09-04 13:50 +0200
    [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event Namhyung Kim <namhyung@kernel.org> - 2015-09-04 10:00 +0200
      RE: [PATCH 2/5] perf probe: Attach trace_probe_event with  perf_probe_event 平松雅巳 / HIRAMATU，MASAMI   <masami.hiramatsu.pt@hitachi.com> - 2015-09-04 13:40 +0200
        Re: [PATCH 2/5] perf probe: Attach trace_probe_event with  perf_probe_event Namhyung Kim <namhyung@kernel.org> - 2015-09-04 14:00 +0200
    [PATCH 4/5] perf probe: Split del_perf_probe_events() Namhyung Kim <namhyung@kernel.org> - 2015-09-04 10:00 +0200
      RE: [PATCH 4/5] perf probe: Split del_perf_probe_events() 平松雅巳 / HIRAMATU，MASAMI   <masami.hiramatsu.pt@hitachi.com> - 2015-09-04 14:00 +0200
        Re: [PATCH 4/5] perf probe: Split del_perf_probe_events() Namhyung Kim <namhyung@kernel.org> - 2015-09-04 14:20 +0200

#1218714 — [PATCH 1/5] perf probe: Split add_perf_probe_events()

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 10:00 +0200
Subject[PATCH 1/5] perf probe: Split add_perf_probe_events()
Message-ID<q4U4G-4eq-9@gated-at.bofh.it>
The add_perf_probe_events() does 3 things:

 1. convert all perf events to trace events
 2. add all trace events to kernel
 3. cleanup all trace events

But sometimes we need to do something with the trace events.  So split
the funtion into three, so that it can access intermediate trace events
via struct __event_package if needed.

Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
---
 tools/perf/util/probe-event.c | 39 +++++++++++++++++++++++++++++++++++----
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index eb5f18b75402..2c762f41e7a5 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -2765,9 +2765,10 @@ struct __event_package {
 	int				ntevs;
 };
 
-int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
+static int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs,
+				     struct __event_package **ppkgs)
 {
-	int i, j, ret;
+	int i, ret;
 	struct __event_package *pkgs;
 
 	ret = 0;
@@ -2792,12 +2793,21 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 		ret  = convert_to_probe_trace_events(pkgs[i].pev,
 						     &pkgs[i].tevs);
 		if (ret < 0)
-			goto end;
+			return ret;
 		pkgs[i].ntevs = ret;
 	}
 	/* This just release blacklist only if allocated */
 	kprobe_blacklist__release();
 
+	*ppkgs = pkgs;
+
+	return 0;
+}
+
+static int apply_perf_probe_events(struct __event_package *pkgs, int npevs)
+{
+	int i, ret = 0;
+
 	/* Loop 2: add all events */
 	for (i = 0; i < npevs; i++) {
 		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
@@ -2806,7 +2816,16 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 		if (ret < 0)
 			break;
 	}
-end:
+	return ret;
+}
+
+static void cleanup_perf_probe_events(struct __event_package *pkgs, int npevs)
+{
+	int i, j;
+
+	if (pkgs == NULL)
+		return;
+
 	/* Loop 3: cleanup and free trace events  */
 	for (i = 0; i < npevs; i++) {
 		for (j = 0; j < pkgs[i].ntevs; j++)
@@ -2815,6 +2834,18 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 	}
 	free(pkgs);
 	exit_symbol_maps();
+}
+
+int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
+{
+	int ret;
+	struct __event_package *pkgs = NULL;
+
+	ret = convert_perf_probe_events(pevs, npevs, &pkgs);
+	if (ret == 0)
+		ret = apply_perf_probe_events(pkgs, npevs);
+
+	cleanup_perf_probe_events(pkgs, npevs);
 
 	return ret;
 }
-- 
2.5.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1218716 — [PATCH 3/5] perf probe: Move print logic into cmd_probe()

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 10:00 +0200
Subject[PATCH 3/5] perf probe: Move print logic into cmd_probe()
Message-ID<q4U4H-4eq-21@gated-at.bofh.it>
In reply to#1218714
Showing actual trace event when adding perf events is only needed in
perf probe command.  But the add functionality itself can be used by
other places.  So move the printing code into the cmd_probe().

Also it combines the output if more than one event is added.

Before:
  $ sudo perf probe -a do_fork -a do_exit
  Added new event:
  probe:do_fork        (on do_fork)

  You can now use it in all perf tools, such as:

      perf record -e probe:do_fork -aR sleep 1

  Added new events:
  probe:do_exit        (on do_exit)
  probe:do_exit_1      (on do_exit)

  You can now use it in all perf tools, such as:

      perf record -e probe:do_exit_1 -aR sleep 1

After:
  $ sudo perf probe -a do_fork -a do_exit
  Added new events:
  probe:do_fork        (on do_fork)
  probe:do_exit        (on do_exit)
  probe:do_exit_1      (on do_exit)

  You can now use it in all perf tools, such as:

      perf record -e probe:do_exit_1 -aR sleep 1

Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
---
 tools/perf/builtin-probe.c    | 48 ++++++++++++++++++++++++++++++++++++++++++-
 tools/perf/util/probe-event.c | 22 +++-----------------
 tools/perf/util/probe-event.h |  3 +++
 3 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index b81cec33b4b2..b8cf6cb7e1bf 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -311,6 +311,52 @@ static void pr_err_with_code(const char *msg, int err)
 	pr_err("\n");
 }
 
+static int perf_add_probe_events(struct perf_probe_event *pevs, int npevs)
+{
+	int ret;
+	int i, k;
+	const char *event = NULL, *group = NULL;
+
+	ret = convert_perf_probe_events(pevs, npevs);
+	if (ret < 0)
+		goto out_cleanup;
+
+	ret = apply_perf_probe_events(pevs, npevs);
+	if (ret < 0)
+		goto out_cleanup;
+
+	for (i = k = 0; i < npevs; i++)
+		k += pevs[i].ntevs;
+
+	pr_info("Added new event%s\n", (k > 1) ? "s:" : ":");
+	for (i = 0; i < npevs; i++) {
+		struct perf_probe_event *pev = &pevs[i];
+
+		for (k = 0; k < pev->ntevs; k++) {
+			struct probe_trace_event *tev = &pev->tevs[k];
+
+			/* We use tev's name for showing new events */
+			show_perf_probe_event(tev->group, tev->event, pev,
+					      tev->point.module, false);
+
+			/* Save the last valid name */
+			event = tev->event;
+			group = tev->group;
+		}
+	}
+
+	/* Note that it is possible to skip all events because of blacklist */
+	if (event) {
+		/* Show how to use the event. */
+		pr_info("\nYou can now use it in all perf tools, such as:\n\n");
+		pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", group, event);
+	}
+
+out_cleanup:
+	cleanup_perf_probe_events(pevs, npevs);
+	return ret;
+}
+
 static int
 __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
 {
@@ -496,7 +542,7 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
 			usage_with_options(probe_usage, options);
 		}
 
-		ret = add_perf_probe_events(params.events, params.nevents);
+		ret = perf_add_probe_events(params.events, params.nevents);
 		if (ret < 0) {
 			pr_err_with_code("  Error: Failed to add events.", ret);
 			return ret;
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 0d3a051b9202..01b9a5bd9449 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -2180,9 +2180,9 @@ static int perf_probe_event__sprintf(const char *group, const char *event,
 }
 
 /* Show an event */
-static int show_perf_probe_event(const char *group, const char *event,
-				 struct perf_probe_event *pev,
-				 const char *module, bool use_stdout)
+int show_perf_probe_event(const char *group, const char *event,
+			  struct perf_probe_event *pev,
+			  const char *module, bool use_stdout)
 {
 	struct strbuf buf = STRBUF_INIT;
 	int ret;
@@ -2399,7 +2399,6 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 {
 	int i, fd, ret;
 	struct probe_trace_event *tev = NULL;
-	const char *event = NULL, *group = NULL;
 	struct strlist *namelist;
 
 	fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0));
@@ -2415,7 +2414,6 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 	}
 
 	ret = 0;
-	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
 	for (i = 0; i < ntevs; i++) {
 		tev = &tevs[i];
 		/* Skip if the symbol is out of .text or blacklisted */
@@ -2432,13 +2430,6 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 		if (ret < 0)
 			break;
 
-		/* We use tev's name for showing new events */
-		show_perf_probe_event(tev->group, tev->event, pev,
-				      tev->point.module, false);
-		/* Save the last valid name */
-		event = tev->event;
-		group = tev->group;
-
 		/*
 		 * Probes after the first probe which comes from same
 		 * user input are always allowed to add suffix, because
@@ -2450,13 +2441,6 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 	if (ret == -EINVAL && pev->uprobes)
 		warn_uprobe_event_compat(tev);
 
-	/* Note that it is possible to skip all events because of blacklist */
-	if (ret >= 0 && event) {
-		/* Show how to use the event. */
-		pr_info("\nYou can now use it in all perf tools, such as:\n\n");
-		pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", group, event);
-	}
-
 	strlist__delete(namelist);
 close_out:
 	close(fd);
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 70c327bd61de..610f743671e1 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -144,6 +144,9 @@ extern int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 extern int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 extern void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 extern int del_perf_probe_events(struct strfilter *filter);
+extern int show_perf_probe_event(const char *group, const char *event,
+				 struct perf_probe_event *pev,
+				 const char *module, bool use_stdout);
 extern int show_perf_probe_events(struct strfilter *filter);
 extern int show_line_range(struct line_range *lr, const char *module,
 			   bool user);
-- 
2.5.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218850 — RE: [PATCH 3/5] perf probe: Move print logic into cmd_probe()

From平松雅巳 / HIRAMATU，MASAMI <masami.hiramatsu.pt@hitachi.com>
Date2015-09-04 13:50 +0200
SubjectRE: [PATCH 3/5] perf probe: Move print logic into cmd_probe()
Message-ID<q4XFg-Zz-3@gated-at.bofh.it>
In reply to#1218716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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218718 — [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 10:00 +0200
Subject[PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event
Message-ID<q4U4H-4eq-23@gated-at.bofh.it>
In reply to#1218714
This patch drops struct __event_package structure.  Instead, it adds
trace_probe_event into 'struct perf_probe_event'.

trace_probe_event information gives further patches a chance to access
actual probe points and actual arguments.  Using them, perf probe can
get whole list of added probes and print them at once.

Other users like upcoming bpf_loader will be able to attach one bpf
program to different probing points of an inline functions (which has
multiple probing points) and glob functions.  Moreover, by reading
arguments information, bpf code for reading those arguments can be
generated.

Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Wang Nan <wangnan0@huawei.com>
[namhyung: extract necessary part from the existing patch]
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
---
 tools/perf/util/probe-event.c | 57 +++++++++++++------------------------------
 tools/perf/util/probe-event.h |  5 ++++
 2 files changed, 22 insertions(+), 40 deletions(-)

diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 2c762f41e7a5..0d3a051b9202 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -2759,59 +2759,39 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
 	return find_probe_trace_events_from_map(pev, tevs);
 }
 
-struct __event_package {
-	struct perf_probe_event		*pev;
-	struct probe_trace_event	*tevs;
-	int				ntevs;
-};
-
-static int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs,
-				     struct __event_package **ppkgs)
+int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 {
 	int i, ret;
-	struct __event_package *pkgs;
-
-	ret = 0;
-	pkgs = zalloc(sizeof(struct __event_package) * npevs);
-
-	if (pkgs == NULL)
-		return -ENOMEM;
 
 	ret = init_symbol_maps(pevs->uprobes);
-	if (ret < 0) {
-		free(pkgs);
+	if (ret < 0)
 		return ret;
-	}
 
 	/* Loop 1: convert all events */
 	for (i = 0; i < npevs; i++) {
-		pkgs[i].pev = &pevs[i];
 		/* Init kprobe blacklist if needed */
-		if (!pkgs[i].pev->uprobes)
+		if (!pevs[i].uprobes)
 			kprobe_blacklist__init();
 		/* Convert with or without debuginfo */
-		ret  = convert_to_probe_trace_events(pkgs[i].pev,
-						     &pkgs[i].tevs);
+		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
 		if (ret < 0)
 			return ret;
-		pkgs[i].ntevs = ret;
+		pevs[i].ntevs = ret;
 	}
 	/* This just release blacklist only if allocated */
 	kprobe_blacklist__release();
 
-	*ppkgs = pkgs;
-
 	return 0;
 }
 
-static int apply_perf_probe_events(struct __event_package *pkgs, int npevs)
+int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 {
 	int i, ret = 0;
 
 	/* Loop 2: add all events */
 	for (i = 0; i < npevs; i++) {
-		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
-					       pkgs[i].ntevs,
+		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
+					       pevs[i].ntevs,
 					       probe_conf.force_add);
 		if (ret < 0)
 			break;
@@ -2819,33 +2799,30 @@ static int apply_perf_probe_events(struct __event_package *pkgs, int npevs)
 	return ret;
 }
 
-static void cleanup_perf_probe_events(struct __event_package *pkgs, int npevs)
+void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 {
 	int i, j;
 
-	if (pkgs == NULL)
-		return;
-
 	/* Loop 3: cleanup and free trace events  */
 	for (i = 0; i < npevs; i++) {
-		for (j = 0; j < pkgs[i].ntevs; j++)
-			clear_probe_trace_event(&pkgs[i].tevs[j]);
-		zfree(&pkgs[i].tevs);
+		for (j = 0; j < pevs[i].ntevs; j++)
+			clear_probe_trace_event(&pevs[i].tevs[j]);
+		zfree(&pevs[i].tevs);
+		pevs[i].ntevs = 0;
 	}
-	free(pkgs);
+
 	exit_symbol_maps();
 }
 
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 {
 	int ret;
-	struct __event_package *pkgs = NULL;
 
-	ret = convert_perf_probe_events(pevs, npevs, &pkgs);
+	ret = convert_perf_probe_events(pevs, npevs);
 	if (ret == 0)
-		ret = apply_perf_probe_events(pkgs, npevs);
+		ret = apply_perf_probe_events(pevs, npevs);
 
-	cleanup_perf_probe_events(pkgs, npevs);
+	cleanup_perf_probe_events(pevs, npevs);
 
 	return ret;
 }
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 6e7ec68a4aa8..70c327bd61de 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -87,6 +87,8 @@ struct perf_probe_event {
 	bool			uprobes;	/* Uprobe event flag */
 	char			*target;	/* Target binary */
 	struct perf_probe_arg	*args;	/* Arguments */
+	struct probe_trace_event *tevs;
+	int			ntevs;
 };
 
 /* Line range */
@@ -138,6 +140,9 @@ extern void line_range__clear(struct line_range *lr);
 extern int line_range__init(struct line_range *lr);
 
 extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs);
+extern int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs);
+extern int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs);
+extern void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 extern int del_perf_probe_events(struct strfilter *filter);
 extern int show_perf_probe_events(struct strfilter *filter);
 extern int show_line_range(struct line_range *lr, const char *module,
-- 
2.5.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218849 — RE: [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event

From平松雅巳 / HIRAMATU，MASAMI <masami.hiramatsu.pt@hitachi.com>
Date2015-09-04 13:40 +0200
SubjectRE: [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event
Message-ID<q4XvA-Oj-21@gated-at.bofh.it>
In reply to#1218718
PiBGcm9tOiBOYW1oeXVuZyBLaW0gW21haWx0bzpuYW1oeXVuZ0BrZXJuZWwub3JnXQ0KPiANCj4g
VGhpcyBwYXRjaCBkcm9wcyBzdHJ1Y3QgX19ldmVudF9wYWNrYWdlIHN0cnVjdHVyZS4gIEluc3Rl
YWQsIGl0IGFkZHMNCj4gdHJhY2VfcHJvYmVfZXZlbnQgaW50byAnc3RydWN0IHBlcmZfcHJvYmVf
ZXZlbnQnLg0KPiANCj4gdHJhY2VfcHJvYmVfZXZlbnQgaW5mb3JtYXRpb24gZ2l2ZXMgZnVydGhl
ciBwYXRjaGVzIGEgY2hhbmNlIHRvIGFjY2Vzcw0KPiBhY3R1YWwgcHJvYmUgcG9pbnRzIGFuZCBh
Y3R1YWwgYXJndW1lbnRzLiAgVXNpbmcgdGhlbSwgcGVyZiBwcm9iZSBjYW4NCj4gZ2V0IHdob2xl
IGxpc3Qgb2YgYWRkZWQgcHJvYmVzIGFuZCBwcmludCB0aGVtIGF0IG9uY2UuDQo+IA0KPiBPdGhl
ciB1c2VycyBsaWtlIHVwY29taW5nIGJwZl9sb2FkZXIgd2lsbCBiZSBhYmxlIHRvIGF0dGFjaCBv
bmUgYnBmDQo+IHByb2dyYW0gdG8gZGlmZmVyZW50IHByb2JpbmcgcG9pbnRzIG9mIGFuIGlubGlu
ZSBmdW5jdGlvbnMgKHdoaWNoIGhhcw0KPiBtdWx0aXBsZSBwcm9iaW5nIHBvaW50cykgYW5kIGds
b2IgZnVuY3Rpb25zLiAgTW9yZW92ZXIsIGJ5IHJlYWRpbmcNCj4gYXJndW1lbnRzIGluZm9ybWF0
aW9uLCBicGYgY29kZSBmb3IgcmVhZGluZyB0aG9zZSBhcmd1bWVudHMgY2FuIGJlDQo+IGdlbmVy
YXRlZC4NCg0KTG9va3MgZ29vZCB0byBtZS4NCg0KQWNrZWQtYnk6IE1hc2FtaSBIaXJhbWF0c3Ug
PG1hc2FtaS5oaXJhbWF0c3UucHRAaGl0YWNoaS5jb20+DQoNClRoYW5rcyENCg0KPiANCj4gQ2M6
IE1hc2FtaSBIaXJhbWF0c3UgPG1hc2FtaS5oaXJhbWF0c3UucHRAaGl0YWNoaS5jb20+DQo+IFNp
Z25lZC1vZmYtYnk6IFdhbmcgTmFuIDx3YW5nbmFuMEBodWF3ZWkuY29tPg0KPiBbbmFtaHl1bmc6
IGV4dHJhY3QgbmVjZXNzYXJ5IHBhcnQgZnJvbSB0aGUgZXhpc3RpbmcgcGF0Y2hdDQo+IFNpZ25l
ZC1vZmYtYnk6IE5hbWh5dW5nIEtpbSA8bmFtaHl1bmdAa2VybmVsLm9yZz4NCj4gLS0tDQo+ICB0
b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYyB8IDU3ICsrKysrKysrKysrKystLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0NCj4gIHRvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5oIHwg
IDUgKysrKw0KPiAgMiBmaWxlcyBjaGFuZ2VkLCAyMiBpbnNlcnRpb25zKCspLCA0MCBkZWxldGlv
bnMoLSkNCj4gDQo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYyBi
L3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jDQo+IGluZGV4IDJjNzYyZjQxZTdhNS4uMGQz
YTA1MWI5MjAyIDEwMDY0NA0KPiAtLS0gYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYw0K
PiArKysgYi90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYw0KPiBAQCAtMjc1OSw1OSArMjc1
OSwzOSBAQCBzdGF0aWMgaW50IGNvbnZlcnRfdG9fcHJvYmVfdHJhY2VfZXZlbnRzKHN0cnVjdCBw
ZXJmX3Byb2JlX2V2ZW50ICpwZXYsDQo+ICAJcmV0dXJuIGZpbmRfcHJvYmVfdHJhY2VfZXZlbnRz
X2Zyb21fbWFwKHBldiwgdGV2cyk7DQo+ICB9DQo+IA0KPiAtc3RydWN0IF9fZXZlbnRfcGFja2Fn
ZSB7DQo+IC0Jc3RydWN0IHBlcmZfcHJvYmVfZXZlbnQJCSpwZXY7DQo+IC0Jc3RydWN0IHByb2Jl
X3RyYWNlX2V2ZW50CSp0ZXZzOw0KPiAtCWludAkJCQludGV2czsNCj4gLX07DQo+IC0NCj4gLXN0
YXRpYyBpbnQgY29udmVydF9wZXJmX3Byb2JlX2V2ZW50cyhzdHJ1Y3QgcGVyZl9wcm9iZV9ldmVu
dCAqcGV2cywgaW50IG5wZXZzLA0KPiAtCQkJCSAgICAgc3RydWN0IF9fZXZlbnRfcGFja2FnZSAq
KnBwa2dzKQ0KPiAraW50IGNvbnZlcnRfcGVyZl9wcm9iZV9ldmVudHMoc3RydWN0IHBlcmZfcHJv
YmVfZXZlbnQgKnBldnMsIGludCBucGV2cykNCj4gIHsNCj4gIAlpbnQgaSwgcmV0Ow0KPiAtCXN0
cnVjdCBfX2V2ZW50X3BhY2thZ2UgKnBrZ3M7DQo+IC0NCj4gLQlyZXQgPSAwOw0KPiAtCXBrZ3Mg
PSB6YWxsb2Moc2l6ZW9mKHN0cnVjdCBfX2V2ZW50X3BhY2thZ2UpICogbnBldnMpOw0KPiAtDQo+
IC0JaWYgKHBrZ3MgPT0gTlVMTCkNCj4gLQkJcmV0dXJuIC1FTk9NRU07DQo+IA0KPiAgCXJldCA9
IGluaXRfc3ltYm9sX21hcHMocGV2cy0+dXByb2Jlcyk7DQo+IC0JaWYgKHJldCA8IDApIHsNCj4g
LQkJZnJlZShwa2dzKTsNCj4gKwlpZiAocmV0IDwgMCkNCj4gIAkJcmV0dXJuIHJldDsNCj4gLQl9
DQo+IA0KPiAgCS8qIExvb3AgMTogY29udmVydCBhbGwgZXZlbnRzICovDQo+ICAJZm9yIChpID0g
MDsgaSA8IG5wZXZzOyBpKyspIHsNCj4gLQkJcGtnc1tpXS5wZXYgPSAmcGV2c1tpXTsNCj4gIAkJ
LyogSW5pdCBrcHJvYmUgYmxhY2tsaXN0IGlmIG5lZWRlZCAqLw0KPiAtCQlpZiAoIXBrZ3NbaV0u
cGV2LT51cHJvYmVzKQ0KPiArCQlpZiAoIXBldnNbaV0udXByb2JlcykNCj4gIAkJCWtwcm9iZV9i
bGFja2xpc3RfX2luaXQoKTsNCj4gIAkJLyogQ29udmVydCB3aXRoIG9yIHdpdGhvdXQgZGVidWdp
bmZvICovDQo+IC0JCXJldCAgPSBjb252ZXJ0X3RvX3Byb2JlX3RyYWNlX2V2ZW50cyhwa2dzW2ld
LnBldiwNCj4gLQkJCQkJCSAgICAgJnBrZ3NbaV0udGV2cyk7DQo+ICsJCXJldCAgPSBjb252ZXJ0
X3RvX3Byb2JlX3RyYWNlX2V2ZW50cygmcGV2c1tpXSwgJnBldnNbaV0udGV2cyk7DQo+ICAJCWlm
IChyZXQgPCAwKQ0KPiAgCQkJcmV0dXJuIHJldDsNCj4gLQkJcGtnc1tpXS5udGV2cyA9IHJldDsN
Cj4gKwkJcGV2c1tpXS5udGV2cyA9IHJldDsNCj4gIAl9DQo+ICAJLyogVGhpcyBqdXN0IHJlbGVh
c2UgYmxhY2tsaXN0IG9ubHkgaWYgYWxsb2NhdGVkICovDQo+ICAJa3Byb2JlX2JsYWNrbGlzdF9f
cmVsZWFzZSgpOw0KPiANCj4gLQkqcHBrZ3MgPSBwa2dzOw0KPiAtDQo+ICAJcmV0dXJuIDA7DQo+
ICB9DQo+IA0KPiAtc3RhdGljIGludCBhcHBseV9wZXJmX3Byb2JlX2V2ZW50cyhzdHJ1Y3QgX19l
dmVudF9wYWNrYWdlICpwa2dzLCBpbnQgbnBldnMpDQo+ICtpbnQgYXBwbHlfcGVyZl9wcm9iZV9l
dmVudHMoc3RydWN0IHBlcmZfcHJvYmVfZXZlbnQgKnBldnMsIGludCBucGV2cykNCj4gIHsNCj4g
IAlpbnQgaSwgcmV0ID0gMDsNCj4gDQo+ICAJLyogTG9vcCAyOiBhZGQgYWxsIGV2ZW50cyAqLw0K
PiAgCWZvciAoaSA9IDA7IGkgPCBucGV2czsgaSsrKSB7DQo+IC0JCXJldCA9IF9fYWRkX3Byb2Jl
X3RyYWNlX2V2ZW50cyhwa2dzW2ldLnBldiwgcGtnc1tpXS50ZXZzLA0KPiAtCQkJCQkgICAgICAg
cGtnc1tpXS5udGV2cywNCj4gKwkJcmV0ID0gX19hZGRfcHJvYmVfdHJhY2VfZXZlbnRzKCZwZXZz
W2ldLCBwZXZzW2ldLnRldnMsDQo+ICsJCQkJCSAgICAgICBwZXZzW2ldLm50ZXZzLA0KPiAgCQkJ
CQkgICAgICAgcHJvYmVfY29uZi5mb3JjZV9hZGQpOw0KPiAgCQlpZiAocmV0IDwgMCkNCj4gIAkJ
CWJyZWFrOw0KPiBAQCAtMjgxOSwzMyArMjc5OSwzMCBAQCBzdGF0aWMgaW50IGFwcGx5X3BlcmZf
cHJvYmVfZXZlbnRzKHN0cnVjdCBfX2V2ZW50X3BhY2thZ2UgKnBrZ3MsIGludCBucGV2cykNCj4g
IAlyZXR1cm4gcmV0Ow0KPiAgfQ0KPiANCj4gLXN0YXRpYyB2b2lkIGNsZWFudXBfcGVyZl9wcm9i
ZV9ldmVudHMoc3RydWN0IF9fZXZlbnRfcGFja2FnZSAqcGtncywgaW50IG5wZXZzKQ0KPiArdm9p
ZCBjbGVhbnVwX3BlcmZfcHJvYmVfZXZlbnRzKHN0cnVjdCBwZXJmX3Byb2JlX2V2ZW50ICpwZXZz
LCBpbnQgbnBldnMpDQo+ICB7DQo+ICAJaW50IGksIGo7DQo+IA0KPiAtCWlmIChwa2dzID09IE5V
TEwpDQo+IC0JCXJldHVybjsNCj4gLQ0KPiAgCS8qIExvb3AgMzogY2xlYW51cCBhbmQgZnJlZSB0
cmFjZSBldmVudHMgICovDQo+ICAJZm9yIChpID0gMDsgaSA8IG5wZXZzOyBpKyspIHsNCj4gLQkJ
Zm9yIChqID0gMDsgaiA8IHBrZ3NbaV0ubnRldnM7IGorKykNCj4gLQkJCWNsZWFyX3Byb2JlX3Ry
YWNlX2V2ZW50KCZwa2dzW2ldLnRldnNbal0pOw0KPiAtCQl6ZnJlZSgmcGtnc1tpXS50ZXZzKTsN
Cj4gKwkJZm9yIChqID0gMDsgaiA8IHBldnNbaV0ubnRldnM7IGorKykNCj4gKwkJCWNsZWFyX3By
b2JlX3RyYWNlX2V2ZW50KCZwZXZzW2ldLnRldnNbal0pOw0KPiArCQl6ZnJlZSgmcGV2c1tpXS50
ZXZzKTsNCj4gKwkJcGV2c1tpXS5udGV2cyA9IDA7DQo+ICAJfQ0KPiAtCWZyZWUocGtncyk7DQo+
ICsNCj4gIAlleGl0X3N5bWJvbF9tYXBzKCk7DQo+ICB9DQo+IA0KPiAgaW50IGFkZF9wZXJmX3By
b2JlX2V2ZW50cyhzdHJ1Y3QgcGVyZl9wcm9iZV9ldmVudCAqcGV2cywgaW50IG5wZXZzKQ0KPiAg
ew0KPiAgCWludCByZXQ7DQo+IC0Jc3RydWN0IF9fZXZlbnRfcGFja2FnZSAqcGtncyA9IE5VTEw7
DQo+IA0KPiAtCXJldCA9IGNvbnZlcnRfcGVyZl9wcm9iZV9ldmVudHMocGV2cywgbnBldnMsICZw
a2dzKTsNCj4gKwlyZXQgPSBjb252ZXJ0X3BlcmZfcHJvYmVfZXZlbnRzKHBldnMsIG5wZXZzKTsN
Cj4gIAlpZiAocmV0ID09IDApDQo+IC0JCXJldCA9IGFwcGx5X3BlcmZfcHJvYmVfZXZlbnRzKHBr
Z3MsIG5wZXZzKTsNCj4gKwkJcmV0ID0gYXBwbHlfcGVyZl9wcm9iZV9ldmVudHMocGV2cywgbnBl
dnMpOw0KPiANCj4gLQljbGVhbnVwX3BlcmZfcHJvYmVfZXZlbnRzKHBrZ3MsIG5wZXZzKTsNCj4g
KwljbGVhbnVwX3BlcmZfcHJvYmVfZXZlbnRzKHBldnMsIG5wZXZzKTsNCj4gDQo+ICAJcmV0dXJu
IHJldDsNCj4gIH0NCj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5o
IGIvdG9vbHMvcGVyZi91dGlsL3Byb2JlLWV2ZW50LmgNCj4gaW5kZXggNmU3ZWM2OGE0YWE4Li43
MGMzMjdiZDYxZGUgMTAwNjQ0DQo+IC0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5o
DQo+ICsrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5oDQo+IEBAIC04Nyw2ICs4Nyw4
IEBAIHN0cnVjdCBwZXJmX3Byb2JlX2V2ZW50IHsNCj4gIAlib29sCQkJdXByb2JlczsJLyogVXBy
b2JlIGV2ZW50IGZsYWcgKi8NCj4gIAljaGFyCQkJKnRhcmdldDsJLyogVGFyZ2V0IGJpbmFyeSAq
Lw0KPiAgCXN0cnVjdCBwZXJmX3Byb2JlX2FyZwkqYXJnczsJLyogQXJndW1lbnRzICovDQo+ICsJ
c3RydWN0IHByb2JlX3RyYWNlX2V2ZW50ICp0ZXZzOw0KPiArCWludAkJCW50ZXZzOw0KPiAgfTsN
Cj4gDQo+ICAvKiBMaW5lIHJhbmdlICovDQo+IEBAIC0xMzgsNiArMTQwLDkgQEAgZXh0ZXJuIHZv
aWQgbGluZV9yYW5nZV9fY2xlYXIoc3RydWN0IGxpbmVfcmFuZ2UgKmxyKTsNCj4gIGV4dGVybiBp
bnQgbGluZV9yYW5nZV9faW5pdChzdHJ1Y3QgbGluZV9yYW5nZSAqbHIpOw0KPiANCj4gIGV4dGVy
biBpbnQgYWRkX3BlcmZfcHJvYmVfZXZlbnRzKHN0cnVjdCBwZXJmX3Byb2JlX2V2ZW50ICpwZXZz
LCBpbnQgbnBldnMpOw0KPiArZXh0ZXJuIGludCBjb252ZXJ0X3BlcmZfcHJvYmVfZXZlbnRzKHN0
cnVjdCBwZXJmX3Byb2JlX2V2ZW50ICpwZXZzLCBpbnQgbnBldnMpOw0KPiArZXh0ZXJuIGludCBh
cHBseV9wZXJmX3Byb2JlX2V2ZW50cyhzdHJ1Y3QgcGVyZl9wcm9iZV9ldmVudCAqcGV2cywgaW50
IG5wZXZzKTsNCj4gK2V4dGVybiB2b2lkIGNsZWFudXBfcGVyZl9wcm9iZV9ldmVudHMoc3RydWN0
IHBlcmZfcHJvYmVfZXZlbnQgKnBldnMsIGludCBucGV2cyk7DQo+ICBleHRlcm4gaW50IGRlbF9w
ZXJmX3Byb2JlX2V2ZW50cyhzdHJ1Y3Qgc3RyZmlsdGVyICpmaWx0ZXIpOw0KPiAgZXh0ZXJuIGlu
dCBzaG93X3BlcmZfcHJvYmVfZXZlbnRzKHN0cnVjdCBzdHJmaWx0ZXIgKmZpbHRlcik7DQo+ICBl
eHRlcm4gaW50IHNob3dfbGluZV9yYW5nZShzdHJ1Y3QgbGluZV9yYW5nZSAqbHIsIGNvbnN0IGNo
YXIgKm1vZHVsZSwNCj4gLS0NCj4gMi41LjANCg0K
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218856 — Re: [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 14:00 +0200
SubjectRe: [PATCH 2/5] perf probe: Attach trace_probe_event with perf_probe_event
Message-ID<q4XOV-1aO-9@gated-at.bofh.it>
In reply to#1218849
On Fri, Sep 04, 2015 at 11:36:56AM +0000, 平松雅巳 / HIRAMATU，MASAMI wrote:
> > From: Namhyung Kim [mailto:namhyung@kernel.org]

Oh, this patch is came from Wang Nan.  I missed to update the author,
will change in v2.


> > 
> > This patch drops struct __event_package structure.  Instead, it adds
> > trace_probe_event into 'struct perf_probe_event'.
> > 
> > trace_probe_event information gives further patches a chance to access
> > actual probe points and actual arguments.  Using them, perf probe can
> > get whole list of added probes and print them at once.
> > 
> > Other users like upcoming bpf_loader will be able to attach one bpf
> > program to different probing points of an inline functions (which has
> > multiple probing points) and glob functions.  Moreover, by reading
> > arguments information, bpf code for reading those arguments can be
> > generated.
> 
> Looks good to me.
> 
> Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>

Thanks
Namhyung
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218720 — [PATCH 4/5] perf probe: Split del_perf_probe_events()

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 10:00 +0200
Subject[PATCH 4/5] perf probe: Split del_perf_probe_events()
Message-ID<q4U4H-4eq-29@gated-at.bofh.it>
In reply to#1218714
The del_perf_probe_events() does 2 things:

1. find existing events which match to filter
2. delete such trace events from kernel

But sometimes we need to do something with the trace events.  So split
the funtion into two, so that it can access intermediate trace events
name using strlist if needed.

Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
---
 tools/perf/util/probe-file.c | 40 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
index bbb243717ec8..f00b0df56dfe 100644
--- a/tools/perf/util/probe-file.c
+++ b/tools/perf/util/probe-file.c
@@ -275,7 +275,8 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
 	return ret;
 }
 
-int probe_file__del_events(int fd, struct strfilter *filter)
+static int probe_file__get_events(int fd, struct strfilter *filter,
+				  struct strlist *plist)
 {
 	struct strlist *namelist;
 	struct str_node *ent;
@@ -290,12 +291,43 @@ int probe_file__del_events(int fd, struct strfilter *filter)
 		p = strchr(ent->s, ':');
 		if ((p && strfilter__compare(filter, p + 1)) ||
 		    strfilter__compare(filter, ent->s)) {
-			ret = __del_trace_probe_event(fd, ent);
-			if (ret < 0)
-				break;
+			strlist__add(plist, ent->s);
+			ret = 0;
 		}
 	}
 	strlist__delete(namelist);
 
 	return ret;
 }
+
+static int probe_file__del_strlist(int fd, struct strlist *namelist)
+{
+	int ret = 0;
+	struct str_node *ent;
+
+	strlist__for_each(ent, namelist) {
+		ret = __del_trace_probe_event(fd, ent);
+		if (ret < 0)
+			break;
+	}
+	return ret;
+}
+
+int probe_file__del_events(int fd, struct strfilter *filter)
+{
+	struct strlist *namelist;
+	int ret;
+
+	namelist = strlist__new(NULL, NULL);
+	if (!namelist)
+		return -ENOMEM;
+
+	ret = probe_file__get_events(fd, filter, namelist);
+	if (ret < 0)
+		return ret;
+
+	ret = probe_file__del_strlist(fd, namelist);
+	strlist__delete(namelist);
+
+	return ret;
+}
-- 
2.5.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218860 — RE: [PATCH 4/5] perf probe: Split del_perf_probe_events()

From平松雅巳 / HIRAMATU，MASAMI <masami.hiramatsu.pt@hitachi.com>
Date2015-09-04 14:00 +0200
SubjectRE: [PATCH 4/5] perf probe: Split del_perf_probe_events()
Message-ID<q4XOW-1aO-25@gated-at.bofh.it>
In reply to#1218720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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1218876 — Re: [PATCH 4/5] perf probe: Split del_perf_probe_events()

FromNamhyung Kim <namhyung@kernel.org>
Date2015-09-04 14:20 +0200
SubjectRe: [PATCH 4/5] perf probe: Split del_perf_probe_events()
Message-ID<q4Y8i-1MD-9@gated-at.bofh.it>
In reply to#1218860
On Fri, Sep 04, 2015 at 11:52:33AM +0000, 平松雅巳 / HIRAMATU，MASAMI wrote:
> > From: Namhyung Kim [mailto:namhyung@kernel.org]
> > 
> > The del_perf_probe_events() does 2 things:
> > 
> > 1. find existing events which match to filter
> > 2. delete such trace events from kernel
> > 
> > But sometimes we need to do something with the trace events.  So split
> > the funtion into two, so that it can access intermediate trace events
> > name using strlist if needed.
> > 
> 
> Ok, but I think it might be better merged to 5/5.

I'm fine with merging them.  Arnaldo, I'll keep it separate now just
in case, but you can merge them if you want.

Thanks,
Namhyung


> 
> Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
> 
> Thanks,
> 
> 
> > Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
> > Signed-off-by: Namhyung Kim <namhyung@kernel.org>
> > ---
> >  tools/perf/util/probe-file.c | 40 ++++++++++++++++++++++++++++++++++++----
> >  1 file changed, 36 insertions(+), 4 deletions(-)
> > 
> > diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
> > index bbb243717ec8..f00b0df56dfe 100644
> > --- a/tools/perf/util/probe-file.c
> > +++ b/tools/perf/util/probe-file.c
> > @@ -275,7 +275,8 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
> >  	return ret;
> >  }
> > 
> > -int probe_file__del_events(int fd, struct strfilter *filter)
> > +static int probe_file__get_events(int fd, struct strfilter *filter,
> > +				  struct strlist *plist)
> >  {
> >  	struct strlist *namelist;
> >  	struct str_node *ent;
> > @@ -290,12 +291,43 @@ int probe_file__del_events(int fd, struct strfilter *filter)
> >  		p = strchr(ent->s, ':');
> >  		if ((p && strfilter__compare(filter, p + 1)) ||
> >  		    strfilter__compare(filter, ent->s)) {
> > -			ret = __del_trace_probe_event(fd, ent);
> > -			if (ret < 0)
> > -				break;
> > +			strlist__add(plist, ent->s);
> > +			ret = 0;
> >  		}
> >  	}
> >  	strlist__delete(namelist);
> > 
> >  	return ret;
> >  }
> > +
> > +static int probe_file__del_strlist(int fd, struct strlist *namelist)
> > +{
> > +	int ret = 0;
> > +	struct str_node *ent;
> > +
> > +	strlist__for_each(ent, namelist) {
> > +		ret = __del_trace_probe_event(fd, ent);
> > +		if (ret < 0)
> > +			break;
> > +	}
> > +	return ret;
> > +}
> > +
> > +int probe_file__del_events(int fd, struct strfilter *filter)
> > +{
> > +	struct strlist *namelist;
> > +	int ret;
> > +
> > +	namelist = strlist__new(NULL, NULL);
> > +	if (!namelist)
> > +		return -ENOMEM;
> > +
> > +	ret = probe_file__get_events(fd, filter, namelist);
> > +	if (ret < 0)
> > +		return ret;
> > +
> > +	ret = probe_file__del_strlist(fd, namelist);
> > +	strlist__delete(namelist);
> > +
> > +	return ret;
> > +}
> > --
> > 2.5.0
> 
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web