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