Create a new class named 'trigger' to model the state of a trigger and
implement auxtrace_snapshot with it.
auxtrace_record__snapshot_started and auxtrace_snapshot_err are absorbed.
'trigger' defines 4 state transitioning functions ('on', 'released',
'toggle' and 'colddown') and 2 state query function ('is_released') and
('is_toggled'). The state 'ON' and 'OFF' take higher priority than
'RELEASED' and 'TOGGLED'. A trigger must be 'on' before 'enable' and
'disable' take effect. A trigger can be colddown after being triggered.
Signed-off-by: Wang Nan <[email protected]>
Cc: Adrian Hunter <[email protected]>
Cc: He Kuang <[email protected]>
Cc: Jiri Olsa <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Namhyung Kim <[email protected]>
Cc: Zefan Li <[email protected]>
Cc: [email protected]
Link:
http://lkml.kernel.org/r/[email protected]
[ Moved the trigger definitions to trigger.h ]
Signed-off-by: Arnaldo Carvalho de Melo <[email protected]>
---
tools/perf/builtin-record.c | 73 ++++++++-----------------------
tools/perf/util/trigger.h | 103 ++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 122 insertions(+), 54 deletions(-)
create mode 100644 tools/perf/util/trigger.h
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 3239a6e..cfaa2df 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -34,6 +34,7 @@
#include "util/parse-regs-options.h"
#include "util/llvm-utils.h"
#include "util/bpf-loader.h"
+#include "util/trigger.h"
#include "asm/bug.h"
#include <unistd.h>
@@ -127,44 +128,7 @@ static volatile int done;
static volatile int signr = -1;
static volatile int child_finished;
-static volatile enum {
- AUXTRACE_SNAPSHOT_OFF = -1,
- AUXTRACE_SNAPSHOT_DISABLED = 0,
- AUXTRACE_SNAPSHOT_ENABLED = 1,
-} auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_OFF;
-
-static inline void
-auxtrace_snapshot_on(void)
-{
- auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_DISABLED;
-}
-
-static inline void
-auxtrace_snapshot_enable(void)
-{
- if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
- return;
- auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_ENABLED;
-}
-
-static inline void
-auxtrace_snapshot_disable(void)
-{
- if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
- return;
- auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_DISABLED;
-}
-
-static inline bool
-auxtrace_snapshot_is_enabled(void)
-{
- if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
- return false;
- return auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_ENABLED;
-}
-
-static volatile int auxtrace_snapshot_err;
-static volatile int auxtrace_record__snapshot_started;
+static DEFINE_TRIGGER(auxtrace_snapshot, OFF);
static void sig_handler(int sig)
{
@@ -282,11 +246,12 @@ static void record__read_auxtrace_snapshot(struct record
*rec)
{
pr_debug("Recording AUX area tracing snapshot\n");
if (record__auxtrace_read_snapshot_all(rec) < 0) {
- auxtrace_snapshot_err = -1;
+ auxtrace_snapshot_error();
} else {
- auxtrace_snapshot_err =
auxtrace_record__snapshot_finish(rec->itr);
- if (!auxtrace_snapshot_err)
- auxtrace_snapshot_enable();
+ if (auxtrace_record__snapshot_finish(rec->itr))
+ auxtrace_snapshot_error();
+ else
+ auxtrace_snapshot_release();
}
}
@@ -815,21 +780,21 @@ static int __cmd_record(struct record *rec, int argc,
const char **argv)
perf_evlist__enable(rec->evlist);
}
- auxtrace_snapshot_enable();
+ auxtrace_snapshot_release();
for (;;) {
unsigned long long hits = rec->samples;
if (record__mmap_read_all(rec) < 0) {
- auxtrace_snapshot_disable();
+ auxtrace_snapshot_error();
err = -1;
goto out_child;
}
- if (auxtrace_record__snapshot_started) {
- auxtrace_record__snapshot_started = 0;
- if (!auxtrace_snapshot_err)
+ if (auxtrace_snapshot_is_toggled()) {
+ auxtrace_snapshot_colddown();
+ if (!auxtrace_snapshot_is_error())
record__read_auxtrace_snapshot(rec);
- if (auxtrace_snapshot_err) {
+ if (auxtrace_snapshot_is_error()) {
pr_err("AUX area tracing snapshot failed\n");
err = -1;
goto out_child;
@@ -858,12 +823,12 @@ static int __cmd_record(struct record *rec, int argc,
const char **argv)
* disable events in this case.
*/
if (done && !disabled && !target__none(&opts->target)) {
- auxtrace_snapshot_disable();
+ auxtrace_snapshot_off();
perf_evlist__disable(rec->evlist);
disabled = true;
}
}
- auxtrace_snapshot_disable();
+ auxtrace_snapshot_off();
if (forks && workload_exec_errno) {
char msg[STRERR_BUFSIZE];
@@ -1442,9 +1407,9 @@ out_symbol_exit:
static void snapshot_sig_handler(int sig __maybe_unused)
{
- if (!auxtrace_snapshot_is_enabled())
+ if (!auxtrace_snapshot_is_released())
return;
- auxtrace_snapshot_disable();
- auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
- auxtrace_record__snapshot_started = 1;
+ auxtrace_snapshot_toggle();
+ if (auxtrace_record__snapshot_start(record.itr))
+ auxtrace_snapshot_error();
}
diff --git a/tools/perf/util/trigger.h b/tools/perf/util/trigger.h
new file mode 100644
index 0000000..162c1c8
--- /dev/null
+++ b/tools/perf/util/trigger.h
@@ -0,0 +1,103 @@
+#ifndef __TRIGGER_H_
+#define __TRIGGER_H_ 1
+
+struct trigger {
+ volatile enum {
+ TRIGGER_OFF = -1,
+ TRIGGER_RELEASED = 0,
+ TRIGGER_TOGGLED = 1,
+ TRIGGER_COLDDOWN = 2,
+ } state;
+ volatile bool error;
+};
+
+static inline void trigger_on(struct trigger *s)
+{
+ if (s->error)
+ return;
+ s->state = TRIGGER_RELEASED;
+}
+
+static inline void trigger_release(struct trigger *s)
+{
+ if (s->error)
+ return;
+ if (s->state != TRIGGER_OFF)
+ s->state = TRIGGER_RELEASED;
+}
+
+static inline void trigger_toggle(struct trigger *s)
+{
+ if (s->error)
+ return;
+ if (s->state != TRIGGER_OFF)
+ s->state = TRIGGER_TOGGLED;
+}
+
+static inline void trigger_colddown(struct trigger *s)
+{
+ if (s->error)
+ return;
+ if (s->state == TRIGGER_TOGGLED)
+ s->state = TRIGGER_COLDDOWN;
+}
+
+static inline void trigger_off(struct trigger *s)
+{
+ if (s->error)
+ return;
+ if (s->state != TRIGGER_OFF)
+ s->state = TRIGGER_OFF;
+}
+
+static inline void trigger_error(struct trigger *s)
+{
+ if (s->error)
+ return;
+ trigger_off(s);
+ s->error = true;
+}
+
+static inline bool trigger_is_released(struct trigger *s)
+{
+ if (s->error)
+ return false;
+ if (s->state != TRIGGER_OFF)
+ return s->state == TRIGGER_RELEASED;
+ return false;
+}
+
+static inline bool trigger_is_toggled(struct trigger *s)
+{
+ if (s->error)
+ return false;
+ if (s->state != TRIGGER_OFF)
+ return s->state == TRIGGER_TOGGLED;
+ return false;
+}
+
+static inline bool trigger_is_error(struct trigger *s)
+{
+ return s->error;
+}
+
+#define __TRIGGER_VAR(n) n##_state
+#define __DEF_TRIGGER_VOID_FUNC(n, op) \
+static inline void n##_##op(void) {trigger_##op(&__TRIGGER_VAR(n)); }
+
+#define __DEF_TRIGGER_FUNC(n, type, op) \
+static inline type n##_##op(void) {return trigger_##op(&__TRIGGER_VAR(n)); }
+
+#define DEFINE_TRIGGER(n, def) \
+struct trigger n##_state = {.state = TRIGGER_##def, .error = false,};\
+__DEF_TRIGGER_VOID_FUNC(n, on) \
+__DEF_TRIGGER_VOID_FUNC(n, release) \
+__DEF_TRIGGER_VOID_FUNC(n, toggle) \
+__DEF_TRIGGER_VOID_FUNC(n, colddown) \
+__DEF_TRIGGER_VOID_FUNC(n, off) \
+__DEF_TRIGGER_VOID_FUNC(n, error) \
+__DEF_TRIGGER_FUNC(n, bool, is_released) \
+__DEF_TRIGGER_FUNC(n, bool, is_toggled) \
+__DEF_TRIGGER_FUNC(n, bool, is_error)
+
+#endif
--
1.8.3.4
