tools/perf/builtin-daemon.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <internal/lib.h>
   3 #include <subcmd/parse-options.h>
   4 #include <api/fd/array.h>
   5 #include <api/fs/fs.h>
   6 #include <linux/zalloc.h>
   7 #include <linux/string.h>
   8 #include <linux/limits.h>
   9 #include <linux/string.h>
  10 #include <string.h>
  11 #include <sys/file.h>
  12 #include <signal.h>
  13 #include <stdlib.h>
  14 #include <time.h>
  15 #include <stdio.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18 #include <sys/inotify.h>
  19 #include <libgen.h>
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <sys/un.h>
  23 #include <sys/stat.h>
  24 #include <sys/signalfd.h>
  25 #include <sys/wait.h>
  26 #include <poll.h>
  27 #include <sys/stat.h>
  28 #include "builtin.h"
  29 #include "perf.h"
  30 #include "debug.h"
  31 #include "config.h"
  32 #include "util.h"
  33
  34 #define SESSION_OUTPUT  "output"
  35 #define SESSION_CONTROL "control"
  36 #define SESSION_ACK     "ack"
  37
  38 /*
  39  * Session states:
  40  *
  41  *   OK       - session is up and running
  42  *   RECONFIG - session is pending for reconfiguration,
  43  *              new values are already loaded in session object
  44  *   KILL     - session is pending to be killed
  45  *
  46  * Session object life and its state is maintained by
  47  * following functions:
  48  *
  49  *  setup_server_config
  50  *    - reads config file and setup session objects
  51  *      with following states:
  52  *
  53  *      OK       - no change needed
  54  *      RECONFIG - session needs to be changed
  55  *                 (run variable changed)
  56  *      KILL     - session needs to be killed
  57  *                 (session is no longer in config file)
  58  *
  59  *  daemon__reconfig
  60  *    - scans session objects and does following actions
  61  *      for states:
  62  *
  63  *      OK       - skip
  64  *      RECONFIG - session is killed and re-run with new config
  65  *      KILL     - session is killed
  66  *
  67  *    - all sessions have OK state on the function exit
  68  */
  69 enum daemon_session_state {
  70         OK,
  71         RECONFIG,
  72         KILL,
  73 };
  74
  75 struct daemon_session {
  76         char                            *base;
  77         char                            *name;
  78         char                            *run;
  79         char                            *control;
  80         int                              pid;
  81         struct list_head                 list;
  82         enum daemon_session_state        state;
  83 };
  84
  85 struct daemon {
  86         const char              *config;
  87         char                    *config_real;
  88         char                    *config_base;
  89         const char              *csv_sep;
  90         const char              *base_user;
  91         char                    *base;
  92         struct list_head         sessions;
  93         FILE                    *out;
  94         char                     perf[PATH_MAX];
  95         int                      signal_fd;
  96 };
  97
  98 static struct daemon __daemon = {
  99         .sessions = LIST_HEAD_INIT(__daemon.sessions),
 100 };
 101
 102 static const char * const daemon_usage[] = {
 103         "perf daemon start [<options>]",
 104         "perf daemon [<options>]",
 105         NULL
 106 };
 107
 108 static bool done;
 109
 110 static void sig_handler(int sig __maybe_unused)
 111 {
 112         done = true;
 113 }
 114
 115 static struct daemon_session *daemon__add_session(struct daemon *config, char *name)
 116 {
 117         struct daemon_session *session = zalloc(sizeof(*session));
 118
 119         if (!session)
 120                 return NULL;
 121
 122         session->name = strdup(name);
 123         if (!session->name) {
 124                 free(session);
 125                 return NULL;
 126         }
 127
 128         session->pid = -1;
 129         list_add_tail(&session->list, &config->sessions);
 130         return session;
 131 }
 132
 133 static struct daemon_session *daemon__find_session(struct daemon *daemon, char *name)
 134 {
 135         struct daemon_session *session;
 136
 137         list_for_each_entry(session, &daemon->sessions, list) {
 138                 if (!strcmp(session->name, name))
 139                         return session;
 140         }
 141
 142         return NULL;
 143 }
 144
 145 static int get_session_name(const char *var, char *session, int len)
 146 {
 147         const char *p = var + sizeof("session-") - 1;
 148
 149         while (*p != '.' && *p != 0x0 && len--)
 150                 *session++ = *p++;
 151
 152         *session = 0;
 153         return *p == '.' ? 0 : -EINVAL;
 154 }
 155
 156 static int session_config(struct daemon *daemon, const char *var, const char *value)
 157 {
 158         struct daemon_session *session;
 159         char name[100];
 160
 161         if (get_session_name(var, name, sizeof(name)))
 162                 return -EINVAL;
 163
 164         var = strchr(var, '.');
 165         if (!var)
 166                 return -EINVAL;
 167
 168         var++;
 169
 170         session = daemon__find_session(daemon, name);
 171
 172         if (!session) {
 173                 /* New session is defined. */
 174                 session = daemon__add_session(daemon, name);
 175                 if (!session)
 176                         return -ENOMEM;
 177
 178                 pr_debug("reconfig: found new session %s\n", name);
 179
 180                 /* Trigger reconfig to start it. */
 181                 session->state = RECONFIG;
 182         } else if (session->state == KILL) {
 183                 /* Current session is defined, no action needed. */
 184                 pr_debug("reconfig: found current session %s\n", name);
 185                 session->state = OK;
 186         }
 187
 188         if (!strcmp(var, "run")) {
 189                 bool same = false;
 190
 191                 if (session->run)
 192                         same = !strcmp(session->run, value);
 193
 194                 if (!same) {
 195                         if (session->run) {
 196                                 free(session->run);
 197                                 pr_debug("reconfig: session %s is changed\n", name);
 198                         }
 199
 200                         session->run = strdup(value);
 201                         if (!session->run)
 202                                 return -ENOMEM;
 203
 204                         /*
 205                          * Either new or changed run value is defined,
 206                          * trigger reconfig for the session.
 207                          */
 208                         session->state = RECONFIG;
 209                 }
 210         }
 211
 212         return 0;
 213 }
 214
 215 static int server_config(const char *var, const char *value, void *cb)
 216 {
 217         struct daemon *daemon = cb;
 218
 219         if (strstarts(var, "session-")) {
 220                 return session_config(daemon, var, value);
 221         } else if (!strcmp(var, "daemon.base") && !daemon->base_user) {
 222                 if (daemon->base && strcmp(daemon->base, value)) {
 223                         pr_err("failed: can't redefine base, bailing out\n");
 224                         return -EINVAL;
 225                 }
 226                 daemon->base = strdup(value);
 227                 if (!daemon->base)
 228                         return -ENOMEM;
 229         }
 230
 231         return 0;
 232 }
 233
 234 static int client_config(const char *var, const char *value, void *cb)
 235 {
 236         struct daemon *daemon = cb;
 237
 238         if (!strcmp(var, "daemon.base") && !daemon->base_user) {
 239                 daemon->base = strdup(value);
 240                 if (!daemon->base)
 241                         return -ENOMEM;
 242         }
 243
 244         return 0;
 245 }
 246
 247 static int check_base(struct daemon *daemon)
 248 {
 249         struct stat st;
 250
 251         if (!daemon->base) {
 252                 pr_err("failed: base not defined\n");
 253                 return -EINVAL;
 254         }
 255
 256         if (stat(daemon->base, &st)) {
 257                 switch (errno) {
 258                 case EACCES:
 259                         pr_err("failed: permission denied for '%s' base\n",
 260                                daemon->base);
 261                         return -EACCES;
 262                 case ENOENT:
 263                         pr_err("failed: base '%s' does not exists\n",
 264                                daemon->base);
 265                         return -EACCES;
 266                 default:
 267                         pr_err("failed: can't access base '%s': %s\n",
 268                                daemon->base, strerror(errno));
 269                         return -errno;
 270                 }
 271         }
 272
 273         if ((st.st_mode & S_IFMT) != S_IFDIR) {
 274                 pr_err("failed: base '%s' is not directory\n",
 275                        daemon->base);
 276                 return -EINVAL;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static int setup_client_config(struct daemon *daemon)
 283 {
 284         struct perf_config_set *set = perf_config_set__load_file(daemon->config_real);
 285         int err = -ENOMEM;
 286
 287         if (set) {
 288                 err = perf_config_set(set, client_config, daemon);
 289                 perf_config_set__delete(set);
 290         }
 291
 292         return err ?: check_base(daemon);
 293 }
 294
 295 static int setup_server_config(struct daemon *daemon)
 296 {
 297         struct perf_config_set *set;
 298         struct daemon_session *session;
 299         int err = -ENOMEM;
 300
 301         pr_debug("reconfig: started\n");
 302
 303         /*
 304          * Mark all sessions for kill, the server config
 305          * will set following states, see explanation at
 306          * enum daemon_session_state declaration.
 307          */
 308         list_for_each_entry(session, &daemon->sessions, list)
 309                 session->state = KILL;
 310
 311         set = perf_config_set__load_file(daemon->config_real);
 312         if (set) {
 313                 err = perf_config_set(set, server_config, daemon);
 314                 perf_config_set__delete(set);
 315         }
 316
 317         return err ?: check_base(daemon);
 318 }
 319
 320 static int daemon_session__run(struct daemon_session *session,
 321                                struct daemon *daemon)
 322 {
 323         char buf[PATH_MAX];
 324         char **argv;
 325         int argc, fd;
 326
 327         if (asprintf(&session->base, "%s/session-%s",
 328                      daemon->base, session->name) < 0) {
 329                 perror("failed: asprintf");
 330                 return -1;
 331         }
 332
 333         if (mkdir(session->base, 0755) && errno != EEXIST) {
 334                 perror("failed: mkdir");
 335                 return -1;
 336         }
 337
 338         session->pid = fork();
 339         if (session->pid < 0)
 340                 return -1;
 341         if (session->pid > 0) {
 342                 pr_info("reconfig: ruining session [%s:%d]: %s\n",
 343                         session->name, session->pid, session->run);
 344                 return 0;
 345         }
 346
 347         if (chdir(session->base)) {
 348                 perror("failed: chdir");
 349                 return -1;
 350         }
 351
 352         fd = open("/dev/null", O_RDONLY);
 353         if (fd < 0) {
 354                 perror("failed: open /dev/null");
 355                 return -1;
 356         }
 357
 358         dup2(fd, 0);
 359         close(fd);
 360
 361         fd = open(SESSION_OUTPUT, O_RDWR|O_CREAT|O_TRUNC, 0644);
 362         if (fd < 0) {
 363                 perror("failed: open session output");
 364                 return -1;
 365         }
 366
 367         dup2(fd, 1);
 368         dup2(fd, 2);
 369         close(fd);
 370
 371         if (mkfifo(SESSION_CONTROL, O_RDWR) && errno != EEXIST) {
 372                 perror("failed: create control fifo");
 373                 return -1;
 374         }
 375
 376         if (mkfifo(SESSION_ACK, O_RDWR) && errno != EEXIST) {
 377                 perror("failed: create ack fifo");
 378                 return -1;
 379         }
 380
 381         scnprintf(buf, sizeof(buf), "%s record --control=fifo:%s,%s %s",
 382                   daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);
 383
 384         argv = argv_split(buf, &argc);
 385         if (!argv)
 386                 exit(-1);
 387
 388         exit(execve(daemon->perf, argv, NULL));
 389         return -1;
 390 }
 391
 392 static pid_t handle_signalfd(struct daemon *daemon)
 393 {
 394         struct daemon_session *session;
 395         struct signalfd_siginfo si;
 396         ssize_t err;
 397         int status;
 398         pid_t pid;
 399
 400         err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
 401         if (err != sizeof(struct signalfd_siginfo))
 402                 return -1;
 403
 404         list_for_each_entry(session, &daemon->sessions, list) {
 405
 406                 if (session->pid != (int) si.ssi_pid)
 407                         continue;
 408
 409                 pid = waitpid(session->pid, &status, 0);
 410                 if (pid == session->pid) {
 411                         if (WIFEXITED(status)) {
 412                                 pr_info("session '%s' exited, status=%d\n",
 413                                         session->name, WEXITSTATUS(status));
 414                         } else if (WIFSIGNALED(status)) {
 415                                 pr_info("session '%s' killed (signal %d)\n",
 416                                         session->name, WTERMSIG(status));
 417                         } else if (WIFSTOPPED(status)) {
 418                                 pr_info("session '%s' stopped (signal %d)\n",
 419                                         session->name, WSTOPSIG(status));
 420                         } else {
 421                                 pr_info("session '%s' Unexpected status (0x%x)\n",
 422                                         session->name, status);
 423                         }
 424                 }
 425
 426                 session->state = KILL;
 427                 session->pid = -1;
 428                 return pid;
 429         }
 430
 431         return 0;
 432 }
 433
 434 static int daemon_session__wait(struct daemon_session *session, struct daemon *daemon,
 435                                 int secs)
 436 {
 437         struct pollfd pollfd = {
 438                 .fd     = daemon->signal_fd,
 439                 .events = POLLIN,
 440         };
 441         pid_t wpid = 0, pid = session->pid;
 442         time_t start;
 443
 444         start = time(NULL);
 445
 446         do {
 447                 int err = poll(&pollfd, 1, 1000);
 448
 449                 if (err > 0) {
 450                         wpid = handle_signalfd(daemon);
 451                 } else if (err < 0) {
 452                         perror("failed: poll\n");
 453                         return -1;
 454                 }
 455
 456                 if (start + secs < time(NULL))
 457                         return -1;
 458         } while (wpid != pid);
 459
 460         return 0;
 461 }
 462
 463 static bool daemon__has_alive_session(struct daemon *daemon)
 464 {
 465         struct daemon_session *session;
 466
 467         list_for_each_entry(session, &daemon->sessions, list) {
 468                 if (session->pid != -1)
 469                         return true;
 470         }
 471
 472         return false;
 473 }
 474
 475 static int daemon__wait(struct daemon *daemon, int secs)
 476 {
 477         struct pollfd pollfd = {
 478                 .fd     = daemon->signal_fd,
 479                 .events = POLLIN,
 480         };
 481         time_t start;
 482
 483         start = time(NULL);
 484
 485         do {
 486                 int err = poll(&pollfd, 1, 1000);
 487
 488                 if (err > 0) {
 489                         handle_signalfd(daemon);
 490                 } else if (err < 0) {
 491                         perror("failed: poll\n");
 492                         return -1;
 493                 }
 494
 495                 if (start + secs < time(NULL))
 496                         return -1;
 497         } while (daemon__has_alive_session(daemon));
 498
 499         return 0;
 500 }
 501
 502 static int daemon_session__control(struct daemon_session *session,
 503                                    const char *msg, bool do_ack)
 504 {
 505         struct pollfd pollfd = { .events = POLLIN, };
 506         char control_path[PATH_MAX];
 507         char ack_path[PATH_MAX];
 508         int control, ack = -1, len;
 509         char buf[20];
 510         int ret = -1;
 511         ssize_t err;
 512
 513         /* open the control file */
 514         scnprintf(control_path, sizeof(control_path), "%s/%s",
 515                   session->base, SESSION_CONTROL);
 516
 517         control = open(control_path, O_WRONLY|O_NONBLOCK);
 518         if (!control)
 519                 return -1;
 520
 521         if (do_ack) {
 522                 /* open the ack file */
 523                 scnprintf(ack_path, sizeof(ack_path), "%s/%s",
 524                           session->base, SESSION_ACK);
 525
 526                 ack = open(ack_path, O_RDONLY, O_NONBLOCK);
 527                 if (!ack) {
 528                         close(control);
 529                         return -1;
 530                 }
 531         }
 532
 533         /* write the command */
 534         len = strlen(msg);
 535
 536         err = writen(control, msg, len);
 537         if (err != len) {
 538                 pr_err("failed: write to control pipe: %d (%s)\n",
 539                        errno, control_path);
 540                 goto out;
 541         }
 542
 543         if (!do_ack)
 544                 goto out;
 545
 546         /* wait for an ack */
 547         pollfd.fd = ack;
 548
 549         if (!poll(&pollfd, 1, 2000)) {
 550                 pr_err("failed: control ack timeout\n");
 551                 goto out;
 552         }
 553
 554         if (!(pollfd.revents & POLLIN)) {
 555                 pr_err("failed: did not received an ack\n");
 556                 goto out;
 557         }
 558
 559         err = read(ack, buf, sizeof(buf));
 560         if (err > 0)
 561                 ret = strcmp(buf, "ack\n");
 562         else
 563                 perror("failed: read ack %d\n");
 564
 565 out:
 566         if (ack != -1)
 567                 close(ack);
 568
 569         close(control);
 570         return ret;
 571 }
 572
 573 static int setup_server_socket(struct daemon *daemon)
 574 {
 575         struct sockaddr_un addr;
 576         char path[PATH_MAX];
 577         int fd = socket(AF_UNIX, SOCK_STREAM, 0);
 578
 579         if (fd < 0) {
 580                 fprintf(stderr, "socket: %s\n", strerror(errno));
 581                 return -1;
 582         }
 583
 584         if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
 585                 perror("failed: fcntl FD_CLOEXEC");
 586                 close(fd);
 587                 return -1;
 588         }
 589
 590         scnprintf(path, sizeof(path), "%s/control", daemon->base);
 591
 592         if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
 593                 pr_err("failed: control path too long '%s'\n", path);
 594                 close(fd);
 595                 return -1;
 596         }
 597
 598         memset(&addr, 0, sizeof(addr));
 599         addr.sun_family = AF_UNIX;
 600
 601         strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
 602         unlink(path);
 603
 604         if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
 605                 perror("failed: bind");
 606                 close(fd);
 607                 return -1;
 608         }
 609
 610         if (listen(fd, 1) == -1) {
 611                 perror("failed: listen");
 612                 close(fd);
 613                 return -1;
 614         }
 615
 616         return fd;
 617 }
 618
 619 enum {
 620         CMD_LIST   = 0,
 621         CMD_SIGNAL = 1,
 622         CMD_STOP   = 2,
 623         CMD_PING   = 3,
 624         CMD_MAX,
 625 };
 626
 627 #define SESSION_MAX 64
 628
 629 union cmd {
 630         int cmd;
 631
 632         /* CMD_LIST */
 633         struct {
 634                 int     cmd;
 635                 int     verbose;
 636                 char    csv_sep;
 637         } list;
 638
 639         /* CMD_SIGNAL */
 640         struct {
 641                 int     cmd;
 642                 int     sig;
 643                 char    name[SESSION_MAX];
 644         } signal;
 645
 646         /* CMD_PING */
 647         struct {
 648                 int     cmd;
 649                 char    name[SESSION_MAX];
 650         } ping;
 651 };
 652
 653 enum {
 654         PING_OK   = 0,
 655         PING_FAIL = 1,
 656         PING_MAX,
 657 };
 658
 659 static int daemon_session__ping(struct daemon_session *session)
 660 {
 661         return daemon_session__control(session, "ping", true) ?  PING_FAIL : PING_OK;
 662 }
 663
 664 static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
 665 {
 666         char csv_sep = cmd->list.csv_sep;
 667         struct daemon_session *session;
 668
 669         if (csv_sep) {
 670                 fprintf(out, "%d%c%s%c%s%c%s/%s",
 671                         /* pid daemon  */
 672                         getpid(), csv_sep, "daemon",
 673                         /* base */
 674                         csv_sep, daemon->base,
 675                         /* output */
 676                         csv_sep, daemon->base, SESSION_OUTPUT);
 677
 678                 fprintf(out, "%c%s/%s",
 679                         /* lock */
 680                         csv_sep, daemon->base, "lock");
 681
 682                 fprintf(out, "\n");
 683         } else {
 684                 fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
 685                 if (cmd->list.verbose) {
 686                         fprintf(out, "  output:  %s/%s\n",
 687                                 daemon->base, SESSION_OUTPUT);
 688                         fprintf(out, "  lock:    %s/lock\n",
 689                                 daemon->base);
 690                 }
 691         }
 692
 693         list_for_each_entry(session, &daemon->sessions, list) {
 694                 if (csv_sep) {
 695                         fprintf(out, "%d%c%s%c%s",
 696                                 /* pid */
 697                                 session->pid,
 698                                 /* name */
 699                                 csv_sep, session->name,
 700                                 /* base */
 701                                 csv_sep, session->run);
 702
 703                         fprintf(out, "%c%s%c%s/%s",
 704                                 /* session dir */
 705                                 csv_sep, session->base,
 706                                 /* session output */
 707                                 csv_sep, session->base, SESSION_OUTPUT);
 708
 709                         fprintf(out, "%c%s/%s%c%s/%s",
 710                                 /* session control */
 711                                 csv_sep, session->base, SESSION_CONTROL,
 712                                 /* session ack */
 713                                 csv_sep, session->base, SESSION_ACK);
 714
 715                         fprintf(out, "\n");
 716                 } else {
 717                         fprintf(out, "[%d:%s] perf record %s\n",
 718                                 session->pid, session->name, session->run);
 719                         if (!cmd->list.verbose)
 720                                 continue;
 721                         fprintf(out, "  base:    %s\n",
 722                                 session->base);
 723                         fprintf(out, "  output:  %s/%s\n",
 724                                 session->base, SESSION_OUTPUT);
 725                         fprintf(out, "  control: %s/%s\n",
 726                                 session->base, SESSION_CONTROL);
 727                         fprintf(out, "  ack:     %s/%s\n",
 728                                 session->base, SESSION_ACK);
 729                 }
 730         }
 731
 732         return 0;
 733 }
 734
 735 static int daemon_session__signal(struct daemon_session *session, int sig)
 736 {
 737         if (session->pid < 0)
 738                 return -1;
 739         return kill(session->pid, sig);
 740 }
 741
 742 static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
 743 {
 744         struct daemon_session *session;
 745         bool all = false;
 746
 747         all = !strcmp(cmd->signal.name, "all");
 748
 749         list_for_each_entry(session, &daemon->sessions, list) {
 750                 if (all || !strcmp(cmd->signal.name, session->name)) {
 751                         daemon_session__signal(session, cmd->signal.sig);
 752                         fprintf(out, "signal %d sent to session '%s [%d]'\n",
 753                                 cmd->signal.sig, session->name, session->pid);
 754                 }
 755         }
 756
 757         return 0;
 758 }
 759
 760 static const char *ping_str[PING_MAX] = {
 761         [PING_OK]   = "OK",
 762         [PING_FAIL] = "FAIL",
 763 };
 764
 765 static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
 766 {
 767         struct daemon_session *session;
 768         bool all = false, found = false;
 769
 770         all = !strcmp(cmd->ping.name, "all");
 771
 772         list_for_each_entry(session, &daemon->sessions, list) {
 773                 if (all || !strcmp(cmd->ping.name, session->name)) {
 774                         int state = daemon_session__ping(session);
 775
 776                         fprintf(out, "%-4s %s\n", ping_str[state], session->name);
 777                         found = true;
 778                 }
 779         }
 780
 781         if (!found && !all) {
 782                 fprintf(out, "%-4s %s (not found)\n",
 783                         ping_str[PING_FAIL], cmd->ping.name);
 784         }
 785         return 0;
 786 }
 787
 788 static int handle_server_socket(struct daemon *daemon, int sock_fd)
 789 {
 790         int ret = -1, fd;
 791         FILE *out = NULL;
 792         union cmd cmd;
 793
 794         fd = accept(sock_fd, NULL, NULL);
 795         if (fd < 0) {
 796                 perror("failed: accept");
 797                 return -1;
 798         }
 799
 800         if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
 801                 perror("failed: read");
 802                 goto out;
 803         }
 804
 805         out = fdopen(fd, "w");
 806         if (!out) {
 807                 perror("failed: fdopen");
 808                 goto out;
 809         }
 810
 811         switch (cmd.cmd) {
 812         case CMD_LIST:
 813                 ret = cmd_session_list(daemon, &cmd, out);
 814                 break;
 815         case CMD_SIGNAL:
 816                 ret = cmd_session_kill(daemon, &cmd, out);
 817                 break;
 818         case CMD_STOP:
 819                 done = 1;
 820                 ret = 0;
 821                 pr_debug("perf daemon is exciting\n");
 822                 break;
 823         case CMD_PING:
 824                 ret = cmd_session_ping(daemon, &cmd, out);
 825                 break;
 826         default:
 827                 break;
 828         }
 829
 830         fclose(out);
 831 out:
 832         /* If out is defined, then fd is closed via fclose. */
 833         if (!out)
 834                 close(fd);
 835         return ret;
 836 }
 837
 838 static int setup_client_socket(struct daemon *daemon)
 839 {
 840         struct sockaddr_un addr;
 841         char path[PATH_MAX];
 842         int fd = socket(AF_UNIX, SOCK_STREAM, 0);
 843
 844         if (fd == -1) {
 845                 perror("failed: socket");
 846                 return -1;
 847         }
 848
 849         scnprintf(path, sizeof(path), "%s/control", daemon->base);
 850
 851         if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
 852                 pr_err("failed: control path too long '%s'\n", path);
 853                 close(fd);
 854                 return -1;
 855         }
 856
 857         memset(&addr, 0, sizeof(addr));
 858         addr.sun_family = AF_UNIX;
 859         strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
 860
 861         if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
 862                 perror("failed: connect");
 863                 close(fd);
 864                 return -1;
 865         }
 866
 867         return fd;
 868 }
 869
 870 static void daemon_session__kill(struct daemon_session *session,
 871                                  struct daemon *daemon)
 872 {
 873         daemon_session__signal(session, SIGTERM);
 874         if (daemon_session__wait(session, daemon, 10)) {
 875                 daemon_session__signal(session, SIGKILL);
 876                 daemon_session__wait(session, daemon, 10);
 877         }
 878 }
 879
 880 static void daemon__signal(struct daemon *daemon, int sig)
 881 {
 882         struct daemon_session *session;
 883
 884         list_for_each_entry(session, &daemon->sessions, list)
 885                 daemon_session__signal(session, sig);
 886 }
 887
 888 static void daemon_session__delete(struct daemon_session *session)
 889 {
 890         free(session->base);
 891         free(session->name);
 892         free(session->run);
 893         free(session);
 894 }
 895
 896 static void daemon_session__remove(struct daemon_session *session)
 897 {
 898         list_del(&session->list);
 899         daemon_session__delete(session);
 900 }
 901
 902 static void daemon__kill(struct daemon *daemon)
 903 {
 904         daemon__signal(daemon, SIGTERM);
 905         if (daemon__wait(daemon, 10)) {
 906                 daemon__signal(daemon, SIGKILL);
 907                 daemon__wait(daemon, 10);
 908         }
 909 }
 910
 911 static void daemon__exit(struct daemon *daemon)
 912 {
 913         struct daemon_session *session, *h;
 914
 915         list_for_each_entry_safe(session, h, &daemon->sessions, list)
 916                 daemon_session__remove(session);
 917
 918         free(daemon->config_real);
 919         free(daemon->config_base);
 920         free(daemon->base);
 921 }
 922
 923 static int daemon__reconfig(struct daemon *daemon)
 924 {
 925         struct daemon_session *session, *n;
 926
 927         list_for_each_entry_safe(session, n, &daemon->sessions, list) {
 928                 /* No change. */
 929                 if (session->state == OK)
 930                         continue;
 931
 932                 /* Remove session. */
 933                 if (session->state == KILL) {
 934                         if (session->pid > 0) {
 935                                 daemon_session__kill(session, daemon);
 936                                 pr_info("reconfig: session '%s' killed\n", session->name);
 937                         }
 938                         daemon_session__remove(session);
 939                         continue;
 940                 }
 941
 942                 /* Reconfig session. */
 943                 if (session->pid > 0) {
 944                         daemon_session__kill(session, daemon);
 945                         pr_info("reconfig: session '%s' killed\n", session->name);
 946                 }
 947                 if (daemon_session__run(session, daemon))
 948                         return -1;
 949
 950                 session->state = OK;
 951         }
 952
 953         return 0;
 954 }
 955
 956 static int setup_config_changes(struct daemon *daemon)
 957 {
 958         char *basen = strdup(daemon->config_real);
 959         char *dirn  = strdup(daemon->config_real);
 960         char *base, *dir;
 961         int fd, wd = -1;
 962
 963         if (!dirn || !basen)
 964                 goto out;
 965
 966         fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
 967         if (fd < 0) {
 968                 perror("failed: inotify_init");
 969                 goto out;
 970         }
 971
 972         dir = dirname(dirn);
 973         base = basename(basen);
 974         pr_debug("config file: %s, dir: %s\n", base, dir);
 975
 976         wd = inotify_add_watch(fd, dir, IN_CLOSE_WRITE);
 977         if (wd >= 0) {
 978                 daemon->config_base = strdup(base);
 979                 if (!daemon->config_base) {
 980                         close(fd);
 981                         wd = -1;
 982                 }
 983         } else {
 984                 perror("failed: inotify_add_watch");
 985         }
 986
 987 out:
 988         free(basen);
 989         free(dirn);
 990         return wd < 0 ? -1 : fd;
 991 }
 992
 993 static bool process_inotify_event(struct daemon *daemon, char *buf, ssize_t len)
 994 {
 995         char *p = buf;
 996
 997         while (p < (buf + len)) {
 998                 struct inotify_event *event = (struct inotify_event *) p;
 999
1000                 /*
1001                  * We monitor config directory, check if our
1002                  * config file was changes.
1003                  */
1004                 if ((event->mask & IN_CLOSE_WRITE) &&
1005                     !(event->mask & IN_ISDIR)) {
1006                         if (!strcmp(event->name, daemon->config_base))
1007                                 return true;
1008                 }
1009                 p += sizeof(*event) + event->len;
1010         }
1011         return false;
1012 }
1013
1014 static int handle_config_changes(struct daemon *daemon, int conf_fd,
1015                                  bool *config_changed)
1016 {
1017         char buf[4096];
1018         ssize_t len;
1019
1020         while (!(*config_changed)) {
1021                 len = read(conf_fd, buf, sizeof(buf));
1022                 if (len == -1) {
1023                         if (errno != EAGAIN) {
1024                                 perror("failed: read");
1025                                 return -1;
1026                         }
1027                         return 0;
1028                 }
1029                 *config_changed = process_inotify_event(daemon, buf, len);
1030         }
1031         return 0;
1032 }
1033
1034 static int setup_config(struct daemon *daemon)
1035 {
1036         if (daemon->base_user) {
1037                 daemon->base = strdup(daemon->base_user);
1038                 if (!daemon->base)
1039                         return -ENOMEM;
1040         }
1041
1042         if (daemon->config) {
1043                 char *real = realpath(daemon->config, NULL);
1044
1045                 if (!real) {
1046                         perror("failed: realpath");
1047                         return -1;
1048                 }
1049                 daemon->config_real = real;
1050                 return 0;
1051         }
1052
1053         if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK))
1054                 daemon->config_real = strdup(perf_etc_perfconfig());
1055         else if (perf_config_global() && perf_home_perfconfig())
1056                 daemon->config_real = strdup(perf_home_perfconfig());
1057
1058         return daemon->config_real ? 0 : -1;
1059 }
1060
1061 #ifndef F_TLOCK
1062 #define F_TLOCK 2
1063
1064 #include <sys/file.h>
1065
1066 static int lockf(int fd, int cmd, off_t len)
1067 {
1068         if (cmd != F_TLOCK || len != 0)
1069                 return -1;
1070
1071         return flock(fd, LOCK_EX | LOCK_NB);
1072 }
1073 #endif // F_TLOCK
1074
1075 /*
1076  * Each daemon tries to create and lock BASE/lock file,
1077  * if it's successful we are sure we're the only daemon
1078  * running over the BASE.
1079  *
1080  * Once daemon is finished, file descriptor to lock file
1081  * is closed and lock is released.
1082  */
1083 static int check_lock(struct daemon *daemon)
1084 {
1085         char path[PATH_MAX];
1086         char buf[20];
1087         int fd, pid;
1088         ssize_t len;
1089
1090         scnprintf(path, sizeof(path), "%s/lock", daemon->base);
1091
1092         fd = open(path, O_RDWR|O_CREAT|O_CLOEXEC, 0640);
1093         if (fd < 0)
1094                 return -1;
1095
1096         if (lockf(fd, F_TLOCK, 0) < 0) {
1097                 filename__read_int(path, &pid);
1098                 fprintf(stderr, "failed: another perf daemon (pid %d) owns %s\n",
1099                         pid, daemon->base);
1100                 close(fd);
1101                 return -1;
1102         }
1103
1104         scnprintf(buf, sizeof(buf), "%d", getpid());
1105         len = strlen(buf);
1106
1107         if (write(fd, buf, len) != len) {
1108                 perror("failed: write");
1109                 close(fd);
1110                 return -1;
1111         }
1112
1113         if (ftruncate(fd, len)) {
1114                 perror("failed: ftruncate");
1115                 close(fd);
1116                 return -1;
1117         }
1118
1119         return 0;
1120 }
1121
1122 static int go_background(struct daemon *daemon)
1123 {
1124         int pid, fd;
1125
1126         pid = fork();
1127         if (pid < 0)
1128                 return -1;
1129
1130         if (pid > 0)
1131                 return 1;
1132
1133         if (setsid() < 0)
1134                 return -1;
1135
1136         if (check_lock(daemon))
1137                 return -1;
1138
1139         umask(0);
1140
1141         if (chdir(daemon->base)) {
1142                 perror("failed: chdir");
1143                 return -1;
1144         }
1145
1146         fd = open("output", O_RDWR|O_CREAT|O_TRUNC, 0644);
1147         if (fd < 0) {
1148                 perror("failed: open");
1149                 return -1;
1150         }
1151
1152         if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
1153                 perror("failed: fcntl FD_CLOEXEC");
1154                 close(fd);
1155                 return -1;
1156         }
1157
1158         close(0);
1159         dup2(fd, 1);
1160         dup2(fd, 2);
1161         close(fd);
1162
1163         daemon->out = fdopen(1, "w");
1164         if (!daemon->out) {
1165                 close(1);
1166                 close(2);
1167                 return -1;
1168         }
1169
1170         setbuf(daemon->out, NULL);
1171         return 0;
1172 }
1173
1174 static int setup_signalfd(struct daemon *daemon)
1175 {
1176         sigset_t mask;
1177
1178         sigemptyset(&mask);
1179         sigaddset(&mask, SIGCHLD);
1180
1181         if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
1182                 return -1;
1183
1184         daemon->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1185         return daemon->signal_fd;
1186 }
1187
1188 static int __cmd_start(struct daemon *daemon, struct option parent_options[],
1189                        int argc, const char **argv)
1190 {
1191         bool foreground = false;
1192         struct option start_options[] = {
1193                 OPT_BOOLEAN('f', "foreground", &foreground, "stay on console"),
1194                 OPT_PARENT(parent_options),
1195                 OPT_END()
1196         };
1197         int sock_fd = -1, conf_fd = -1, signal_fd = -1;
1198         int sock_pos, file_pos, signal_pos;
1199         struct fdarray fda;
1200         int err = 0;
1201
1202         argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1203         if (argc)
1204                 usage_with_options(daemon_usage, start_options);
1205
1206         if (setup_config(daemon)) {
1207                 pr_err("failed: config not found\n");
1208                 return -1;
1209         }
1210
1211         if (setup_server_config(daemon))
1212                 return -1;
1213
1214         if (foreground && check_lock(daemon))
1215                 return -1;
1216
1217         if (!foreground) {
1218                 err = go_background(daemon);
1219                 if (err) {
1220                         /* original process, exit normally */
1221                         if (err == 1)
1222                                 err = 0;
1223                         daemon__exit(daemon);
1224                         return err;
1225                 }
1226         }
1227
1228         debug_set_file(daemon->out);
1229         debug_set_display_time(true);
1230
1231         pr_info("daemon started (pid %d)\n", getpid());
1232
1233         fdarray__init(&fda, 3);
1234
1235         sock_fd = setup_server_socket(daemon);
1236         if (sock_fd < 0)
1237                 goto out;
1238
1239         conf_fd = setup_config_changes(daemon);
1240         if (conf_fd < 0)
1241                 goto out;
1242
1243         signal_fd = setup_signalfd(daemon);
1244         if (signal_fd < 0)
1245                 goto out;
1246
1247         sock_pos = fdarray__add(&fda, sock_fd, POLLIN|POLLERR|POLLHUP, 0);
1248         if (sock_pos < 0)
1249                 goto out;
1250
1251         file_pos = fdarray__add(&fda, conf_fd, POLLIN|POLLERR|POLLHUP, 0);
1252         if (file_pos < 0)
1253                 goto out;
1254
1255         signal_pos = fdarray__add(&fda, signal_fd, POLLIN|POLLERR|POLLHUP, 0);
1256         if (signal_pos < 0)
1257                 goto out;
1258
1259         signal(SIGINT, sig_handler);
1260         signal(SIGTERM, sig_handler);
1261         signal(SIGPIPE, SIG_IGN);
1262
1263         while (!done && !err) {
1264                 err = daemon__reconfig(daemon);
1265
1266                 if (!err && fdarray__poll(&fda, -1)) {
1267                         bool reconfig = false;
1268
1269                         if (fda.entries[sock_pos].revents & POLLIN)
1270                                 err = handle_server_socket(daemon, sock_fd);
1271                         if (fda.entries[file_pos].revents & POLLIN)
1272                                 err = handle_config_changes(daemon, conf_fd, &reconfig);
1273                         if (fda.entries[signal_pos].revents & POLLIN)
1274                                 err = handle_signalfd(daemon) < 0;
1275
1276                         if (reconfig)
1277                                 err = setup_server_config(daemon);
1278                 }
1279         }
1280
1281 out:
1282         fdarray__exit(&fda);
1283
1284         daemon__kill(daemon);
1285         daemon__exit(daemon);
1286
1287         if (sock_fd != -1)
1288                 close(sock_fd);
1289         if (conf_fd != -1)
1290                 close(conf_fd);
1291         if (conf_fd != -1)
1292                 close(signal_fd);
1293
1294         pr_info("daemon exited\n");
1295         fclose(daemon->out);
1296         return err;
1297 }
1298
1299 static int send_cmd(struct daemon *daemon, union cmd *cmd)
1300 {
1301         int ret = -1, fd;
1302         char *line = NULL;
1303         size_t len = 0;
1304         ssize_t nread;
1305         FILE *in = NULL;
1306
1307         if (setup_client_config(daemon))
1308                 return -1;
1309
1310         fd = setup_client_socket(daemon);
1311         if (fd < 0)
1312                 return -1;
1313
1314         if (sizeof(*cmd) != writen(fd, cmd, sizeof(*cmd))) {
1315                 perror("failed: write");
1316                 goto out;
1317         }
1318
1319         in = fdopen(fd, "r");
1320         if (!in) {
1321                 perror("failed: fdopen");
1322                 goto out;
1323         }
1324
1325         while ((nread = getline(&line, &len, in)) != -1) {
1326                 if (fwrite(line, nread, 1, stdout) != 1)
1327                         goto out_fclose;
1328                 fflush(stdout);
1329         }
1330
1331         ret = 0;
1332 out_fclose:
1333         fclose(in);
1334         free(line);
1335 out:
1336         /* If in is defined, then fd is closed via fclose. */
1337         if (!in)
1338                 close(fd);
1339         return ret;
1340 }
1341
1342 static int send_cmd_list(struct daemon *daemon)
1343 {
1344         union cmd cmd = { .cmd = CMD_LIST, };
1345
1346         cmd.list.verbose = verbose;
1347         cmd.list.csv_sep = daemon->csv_sep ? *daemon->csv_sep : 0;
1348
1349         return send_cmd(daemon, &cmd);
1350 }
1351
1352 static int __cmd_signal(struct daemon *daemon, struct option parent_options[],
1353                         int argc, const char **argv)
1354 {
1355         const char *name = "all";
1356         struct option start_options[] = {
1357                 OPT_STRING(0, "session", &name, "session",
1358                         "Sent signal to specific session"),
1359                 OPT_PARENT(parent_options),
1360                 OPT_END()
1361         };
1362         union cmd cmd;
1363
1364         argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1365         if (argc)
1366                 usage_with_options(daemon_usage, start_options);
1367
1368         if (setup_config(daemon)) {
1369                 pr_err("failed: config not found\n");
1370                 return -1;
1371         }
1372
1373         cmd.signal.cmd = CMD_SIGNAL,
1374         cmd.signal.sig = SIGUSR2;
1375         strncpy(cmd.signal.name, name, sizeof(cmd.signal.name) - 1);
1376
1377         return send_cmd(daemon, &cmd);
1378 }
1379
1380 static int __cmd_stop(struct daemon *daemon, struct option parent_options[],
1381                         int argc, const char **argv)
1382 {
1383         struct option start_options[] = {
1384                 OPT_PARENT(parent_options),
1385                 OPT_END()
1386         };
1387         union cmd cmd = { .cmd = CMD_STOP, };
1388
1389         argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1390         if (argc)
1391                 usage_with_options(daemon_usage, start_options);
1392
1393         if (setup_config(daemon)) {
1394                 pr_err("failed: config not found\n");
1395                 return -1;
1396         }
1397
1398         return send_cmd(daemon, &cmd);
1399 }
1400
1401 static int __cmd_ping(struct daemon *daemon, struct option parent_options[],
1402                       int argc, const char **argv)
1403 {
1404         const char *name = "all";
1405         struct option ping_options[] = {
1406                 OPT_STRING(0, "session", &name, "session",
1407                         "Ping to specific session"),
1408                 OPT_PARENT(parent_options),
1409                 OPT_END()
1410         };
1411         union cmd cmd = { .cmd = CMD_PING, };
1412
1413         argc = parse_options(argc, argv, ping_options, daemon_usage, 0);
1414         if (argc)
1415                 usage_with_options(daemon_usage, ping_options);
1416
1417         if (setup_config(daemon)) {
1418                 pr_err("failed: config not found\n");
1419                 return -1;
1420         }
1421
1422         scnprintf(cmd.ping.name, sizeof(cmd.ping.name), "%s", name);
1423         return send_cmd(daemon, &cmd);
1424 }
1425
1426 int cmd_daemon(int argc, const char **argv)
1427 {
1428         struct option daemon_options[] = {
1429                 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1430                 OPT_STRING(0, "config", &__daemon.config,
1431                         "config file", "config file path"),
1432                 OPT_STRING(0, "base", &__daemon.base_user,
1433                         "directory", "base directory"),
1434                 OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
1435                         "field separator", "print counts with custom separator", ","),
1436                 OPT_END()
1437         };
1438
1439         perf_exe(__daemon.perf, sizeof(__daemon.perf));
1440         __daemon.out = stdout;
1441
1442         argc = parse_options(argc, argv, daemon_options, daemon_usage,
1443                              PARSE_OPT_STOP_AT_NON_OPTION);
1444
1445         if (argc) {
1446                 if (!strcmp(argv[0], "start"))
1447                         return __cmd_start(&__daemon, daemon_options, argc, argv);
1448                 if (!strcmp(argv[0], "signal"))
1449                         return __cmd_signal(&__daemon, daemon_options, argc, argv);
1450                 else if (!strcmp(argv[0], "stop"))
1451                         return __cmd_stop(&__daemon, daemon_options, argc, argv);
1452                 else if (!strcmp(argv[0], "ping"))
1453                         return __cmd_ping(&__daemon, daemon_options, argc, argv);
1454
1455                 pr_err("failed: unknown command '%s'\n", argv[0]);
1456                 return -1;
1457         }
1458
1459         if (setup_config(&__daemon)) {
1460                 pr_err("failed: config not found\n");
1461                 return -1;
1462         }
1463
1464         return send_cmd_list(&__daemon);
1465 }