perf daemon: Add 'ping' command

Add a 'ping' command to verify that the 'perf record' session is up and
operational.

It's used in the following patches via test code to make sure 'perf
record' is ready to receive signals.

Example:

  # cat ~/.perfconfig
  [daemon]
  base=/opt/perfdata

  [session-cycles]
  run = -m 10M -e cycles --overwrite --switch-output -a

  [session-sched]
  run = -m 20M -e sched:* --overwrite --switch-output -a

Start the daemon:

  # perf daemon start

Ping all sessions:

  # perf daemon ping
  OK   cycles
  OK   sched

Ping specific session:

  # perf daemon ping --session sched
  OK   sched

Committer notes:

Fixed up bug pointed by clang:

Buggy:

  if (!pollfd.revents & POLLIN)

Correct code:

  if (!(pollfd.revents & POLLIN))

clang warning:

  builtin-daemon.c:560:6: error: logical not is only applied to the left hand side of this bitwise operator [-Werror,-Wlogical-not-parentheses]
          if (!pollfd.revents & POLLIN) {
              ^               ~
  builtin-daemon.c:560:6: note: add parentheses after the '!' to evaluate the bitwise operator first

Also use designated initialized with pollfd, i.e.:

  struct pollfd pollfd = { .events = POLLIN, };

Instead of:

  struct pollfd pollfd = { 0, };

To get past:

    builtin-daemon.c:510:30: error: missing field 'events' initializer [-Werror,-Wmissing-field-initializers]
            struct pollfd pollfd = { 0, };
                                        ^
    1 error generated.

Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Alexei Budankov <abudankov@huawei.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Michael Petlan <mpetlan@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: https://lore.kernel.org/r/20210208200908.1019149-16-jolsa@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/Documentation/perf-daemon.txt b/tools/perf/Documentation/perf-daemon.txt
index b1acd46..90b20be 100644 (file)
--- a/tools/perf/Documentation/perf-daemon.txt
+++ b/tools/perf/Documentation/perf-daemon.txt
@@ -15,6 +15,7 @@ SYNOPSIS
 'perf daemon start'  [<options>]
 'perf daemon stop'   [<options>]
 'perf daemon signal' [<options>]
+'perf daemon ping'   [<options>]
 
 
 DESCRIPTION
@@ -80,6 +81,14 @@ The signal command sends signal to configured sessions.
        Send signal to specific session.
 
 
+PING COMMAND
+------------
+The ping command sends control ping to configured sessions.
+
+--session::
+       Send ping to specific session.
+
+
 CONFIG FILE
 -----------
 The daemon is configured within standard perf config file by

diff --git a/tools/perf/builtin-daemon.c b/tools/perf/builtin-daemon.c
index 2c5e68b..fac8605 100644 (file)
--- a/tools/perf/builtin-daemon.c
+++ b/tools/perf/builtin-daemon.c
@@ -499,6 +499,77 @@ static int daemon__wait(struct daemon *daemon, int secs)
        return 0;
 }
 
+static int daemon_session__control(struct daemon_session *session,
+                                  const char *msg, bool do_ack)
+{
+       struct pollfd pollfd = { .events = POLLIN, };
+       char control_path[PATH_MAX];
+       char ack_path[PATH_MAX];
+       int control, ack = -1, len;
+       char buf[20];
+       int ret = -1;
+       ssize_t err;
+
+       /* open the control file */
+       scnprintf(control_path, sizeof(control_path), "%s/%s",
+                 session->base, SESSION_CONTROL);
+
+       control = open(control_path, O_WRONLY|O_NONBLOCK);
+       if (!control)
+               return -1;
+
+       if (do_ack) {
+               /* open the ack file */
+               scnprintf(ack_path, sizeof(ack_path), "%s/%s",
+                         session->base, SESSION_ACK);
+
+               ack = open(ack_path, O_RDONLY, O_NONBLOCK);
+               if (!ack) {
+                       close(control);
+                       return -1;
+               }
+       }
+
+       /* write the command */
+       len = strlen(msg);
+
+       err = writen(control, msg, len);
+       if (err != len) {
+               pr_err("failed: write to control pipe: %d (%s)\n",
+                      errno, control_path);
+               goto out;
+       }
+
+       if (!do_ack)
+               goto out;
+
+       /* wait for an ack */
+       pollfd.fd = ack;
+
+       if (!poll(&pollfd, 1, 2000)) {
+               pr_err("failed: control ack timeout\n");
+               goto out;
+       }
+
+       if (!(pollfd.revents & POLLIN)) {
+               pr_err("failed: did not received an ack\n");
+               goto out;
+       }
+
+       err = read(ack, buf, sizeof(buf));
+       if (err > 0)
+               ret = strcmp(buf, "ack\n");
+       else
+               perror("failed: read ack %d\n");
+
+out:
+       if (ack != -1)
+               close(ack);
+
+       close(control);
+       return ret;
+}
+
 static int setup_server_socket(struct daemon *daemon)
 {
        struct sockaddr_un addr;
@@ -549,6 +620,7 @@ enum {
        CMD_LIST   = 0,
        CMD_SIGNAL = 1,
        CMD_STOP   = 2,
+       CMD_PING   = 3,
        CMD_MAX,
 };
 
@@ -570,8 +642,25 @@ union cmd {
                int     sig;
                char    name[SESSION_MAX];
        } signal;
+
+       /* CMD_PING */
+       struct {
+               int     cmd;
+               char    name[SESSION_MAX];
+       } ping;
+};
+
+enum {
+       PING_OK   = 0,
+       PING_FAIL = 1,
+       PING_MAX,
 };
 
+static int daemon_session__ping(struct daemon_session *session)
+{
+       return daemon_session__control(session, "ping", true) ?  PING_FAIL : PING_OK;
+}
+
 static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
 {
        char csv_sep = cmd->list.csv_sep;
@@ -668,6 +757,34 @@ static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
        return 0;
 }
 
+static const char *ping_str[PING_MAX] = {
+       [PING_OK]   = "OK",
+       [PING_FAIL] = "FAIL",
+};
+
+static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
+{
+       struct daemon_session *session;
+       bool all = false, found = false;
+
+       all = !strcmp(cmd->ping.name, "all");
+
+       list_for_each_entry(session, &daemon->sessions, list) {
+               if (all || !strcmp(cmd->ping.name, session->name)) {
+                       int state = daemon_session__ping(session);
+
+                       fprintf(out, "%-4s %s\n", ping_str[state], session->name);
+                       found = true;
+               }
+       }
+
+       if (!found && !all) {
+               fprintf(out, "%-4s %s (not found)\n",
+                       ping_str[PING_FAIL], cmd->ping.name);
+       }
+       return 0;
+}
+
 static int handle_server_socket(struct daemon *daemon, int sock_fd)
 {
        int ret = -1, fd;
@@ -703,6 +820,9 @@ static int handle_server_socket(struct daemon *daemon, int sock_fd)
                ret = 0;
                pr_debug("perf daemon is exciting\n");
                break;
+       case CMD_PING:
+               ret = cmd_session_ping(daemon, &cmd, out);
+               break;
        default:
                break;
        }
@@ -1138,6 +1258,7 @@ static int __cmd_start(struct daemon *daemon, struct option parent_options[],
 
        signal(SIGINT, sig_handler);
        signal(SIGTERM, sig_handler);
+       signal(SIGPIPE, SIG_IGN);
 
        while (!done && !err) {
                err = daemon__reconfig(daemon);
@@ -1277,6 +1398,31 @@ static int __cmd_stop(struct daemon *daemon, struct option parent_options[],
        return send_cmd(daemon, &cmd);
 }
 
+static int __cmd_ping(struct daemon *daemon, struct option parent_options[],
+                     int argc, const char **argv)
+{
+       const char *name = "all";
+       struct option ping_options[] = {
+               OPT_STRING(0, "session", &name, "session",
+                       "Ping to specific session"),
+               OPT_PARENT(parent_options),
+               OPT_END()
+       };
+       union cmd cmd = { .cmd = CMD_PING, };
+
+       argc = parse_options(argc, argv, ping_options, daemon_usage, 0);
+       if (argc)
+               usage_with_options(daemon_usage, ping_options);
+
+       if (setup_config(daemon)) {
+               pr_err("failed: config not found\n");
+               return -1;
+       }
+
+       scnprintf(cmd.ping.name, sizeof(cmd.ping.name), "%s", name);
+       return send_cmd(daemon, &cmd);
+}
+
 int cmd_daemon(int argc, const char **argv)
 {
        struct option daemon_options[] = {
@@ -1303,6 +1449,8 @@ int cmd_daemon(int argc, const char **argv)
                        return __cmd_signal(&__daemon, daemon_options, argc, argv);
                else if (!strcmp(argv[0], "stop"))
                        return __cmd_stop(&__daemon, daemon_options, argc, argv);
+               else if (!strcmp(argv[0], "ping"))
+                       return __cmd_ping(&__daemon, daemon_options, argc, argv);
 
                pr_err("failed: unknown command '%s'\n", argv[0]);
                return -1;