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_MAX,
 536 };
 537
 538 #define SESSION_MAX 64
 539
 540 union cmd {
 541         int cmd;
 542
 543         /* CMD_LIST */
 544         struct {
 545                 int     cmd;
 546                 int     verbose;
 547                 char    csv_sep;
 548         } list;
 549
 550         /* CMD_SIGNAL */
 551         struct {
 552                 int     cmd;
 553                 int     sig;
 554                 char    name[SESSION_MAX];
 555         } signal;
 556 };
 557
 558 static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
 559 {
 560         char csv_sep = cmd->list.csv_sep;
 561         struct daemon_session *session;
 562
 563         if (csv_sep) {
 564                 fprintf(out, "%d%c%s%c%s%c%s/%s",
 565                         /* pid daemon  */
 566                         getpid(), csv_sep, "daemon",
 567                         /* base */
 568                         csv_sep, daemon->base,
 569                         /* output */
 570                         csv_sep, daemon->base, SESSION_OUTPUT);
 571
 572                 fprintf(out, "\n");
 573         } else {
 574                 fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
 575                 if (cmd->list.verbose) {
 576                         fprintf(out, "  output:  %s/%s\n",
 577                                 daemon->base, SESSION_OUTPUT);
 578                 }
 579         }
 580
 581         list_for_each_entry(session, &daemon->sessions, list) {
 582                 if (csv_sep) {
 583                         fprintf(out, "%d%c%s%c%s",
 584                                 /* pid */
 585                                 session->pid,
 586                                 /* name */
 587                                 csv_sep, session->name,
 588                                 /* base */
 589                                 csv_sep, session->run);
 590
 591                         fprintf(out, "%c%s%c%s/%s",
 592                                 /* session dir */
 593                                 csv_sep, session->base,
 594                                 /* session output */
 595                                 csv_sep, session->base, SESSION_OUTPUT);
 596
 597                         fprintf(out, "\n");
 598                 } else {
 599                         fprintf(out, "[%d:%s] perf record %s\n",
 600                                 session->pid, session->name, session->run);
 601                         if (!cmd->list.verbose)
 602                                 continue;
 603                         fprintf(out, "  base:    %s\n",
 604                                 session->base);
 605                         fprintf(out, "  output:  %s/%s\n",
 606                                 session->base, SESSION_OUTPUT);
 607                 }
 608         }
 609
 610         return 0;
 611 }
 612
 613 static int daemon_session__signal(struct daemon_session *session, int sig)
 614 {
 615         if (session->pid < 0)
 616                 return -1;
 617         return kill(session->pid, sig);
 618 }
 619
 620 static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
 621 {
 622         struct daemon_session *session;
 623         bool all = false;
 624
 625         all = !strcmp(cmd->signal.name, "all");
 626
 627         list_for_each_entry(session, &daemon->sessions, list) {
 628                 if (all || !strcmp(cmd->signal.name, session->name)) {
 629                         daemon_session__signal(session, cmd->signal.sig);
 630                         fprintf(out, "signal %d sent to session '%s [%d]'\n",
 631                                 cmd->signal.sig, session->name, session->pid);
 632                 }
 633         }
 634
 635         return 0;
 636 }
 637
 638 static int handle_server_socket(struct daemon *daemon, int sock_fd)
 639 {
 640         int ret = -1, fd;
 641         FILE *out = NULL;
 642         union cmd cmd;
 643
 644         fd = accept(sock_fd, NULL, NULL);
 645         if (fd < 0) {
 646                 perror("failed: accept");
 647                 return -1;
 648         }
 649
 650         if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
 651                 perror("failed: read");
 652                 goto out;
 653         }
 654
 655         out = fdopen(fd, "w");
 656         if (!out) {
 657                 perror("failed: fdopen");
 658                 goto out;
 659         }
 660
 661         switch (cmd.cmd) {
 662         case CMD_LIST:
 663                 ret = cmd_session_list(daemon, &cmd, out);
 664                 break;
 665         case CMD_SIGNAL:
 666                 ret = cmd_session_kill(daemon, &cmd, out);
 667                 break;
 668         default:
 669                 break;
 670         }
 671
 672         fclose(out);
 673 out:
 674         /* If out is defined, then fd is closed via fclose. */
 675         if (!out)
 676                 close(fd);
 677         return ret;
 678 }
 679
 680 static int setup_client_socket(struct daemon *daemon)
 681 {
 682         struct sockaddr_un addr;
 683         char path[PATH_MAX];
 684         int fd = socket(AF_UNIX, SOCK_STREAM, 0);
 685
 686         if (fd == -1) {
 687                 perror("failed: socket");
 688                 return -1;
 689         }
 690
 691         scnprintf(path, sizeof(path), "%s/control", daemon->base);
 692
 693         if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
 694                 pr_err("failed: control path too long '%s'\n", path);
 695                 close(fd);
 696                 return -1;
 697         }
 698
 699         memset(&addr, 0, sizeof(addr));
 700         addr.sun_family = AF_UNIX;
 701         strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
 702
 703         if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
 704                 perror("failed: connect");
 705                 close(fd);
 706                 return -1;
 707         }
 708
 709         return fd;
 710 }
 711
 712 static void daemon_session__kill(struct daemon_session *session,
 713                                  struct daemon *daemon)
 714 {
 715         daemon_session__signal(session, SIGTERM);
 716         if (daemon_session__wait(session, daemon, 10)) {
 717                 daemon_session__signal(session, SIGKILL);
 718                 daemon_session__wait(session, daemon, 10);
 719         }
 720 }
 721
 722 static void daemon__signal(struct daemon *daemon, int sig)
 723 {
 724         struct daemon_session *session;
 725
 726         list_for_each_entry(session, &daemon->sessions, list)
 727                 daemon_session__signal(session, sig);
 728 }
 729
 730 static void daemon_session__delete(struct daemon_session *session)
 731 {
 732         free(session->base);
 733         free(session->name);
 734         free(session->run);
 735         free(session);
 736 }
 737
 738 static void daemon_session__remove(struct daemon_session *session)
 739 {
 740         list_del(&session->list);
 741         daemon_session__delete(session);
 742 }
 743
 744 static void daemon__kill(struct daemon *daemon)
 745 {
 746         daemon__signal(daemon, SIGTERM);
 747         if (daemon__wait(daemon, 10)) {
 748                 daemon__signal(daemon, SIGKILL);
 749                 daemon__wait(daemon, 10);
 750         }
 751 }
 752
 753 static void daemon__exit(struct daemon *daemon)
 754 {
 755         struct daemon_session *session, *h;
 756
 757         list_for_each_entry_safe(session, h, &daemon->sessions, list)
 758                 daemon_session__remove(session);
 759
 760         free(daemon->config_real);
 761         free(daemon->config_base);
 762         free(daemon->base);
 763 }
 764
 765 static int daemon__reconfig(struct daemon *daemon)
 766 {
 767         struct daemon_session *session, *n;
 768
 769         list_for_each_entry_safe(session, n, &daemon->sessions, list) {
 770                 /* No change. */
 771                 if (session->state == OK)
 772                         continue;
 773
 774                 /* Remove session. */
 775                 if (session->state == KILL) {
 776                         if (session->pid > 0) {
 777                                 daemon_session__kill(session, daemon);
 778                                 pr_info("reconfig: session '%s' killed\n", session->name);
 779                         }
 780                         daemon_session__remove(session);
 781                         continue;
 782                 }
 783
 784                 /* Reconfig session. */
 785                 if (session->pid > 0) {
 786                         daemon_session__kill(session, daemon);
 787                         pr_info("reconfig: session '%s' killed\n", session->name);
 788                 }
 789                 if (daemon_session__run(session, daemon))
 790                         return -1;
 791
 792                 session->state = OK;
 793         }
 794
 795         return 0;
 796 }
 797
 798 static int setup_config_changes(struct daemon *daemon)
 799 {
 800         char *basen = strdup(daemon->config_real);
 801         char *dirn  = strdup(daemon->config_real);
 802         char *base, *dir;
 803         int fd, wd = -1;
 804
 805         if (!dirn || !basen)
 806                 goto out;
 807
 808         fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
 809         if (fd < 0) {
 810                 perror("failed: inotify_init");
 811                 goto out;
 812         }
 813
 814         dir = dirname(dirn);
 815         base = basename(basen);
 816         pr_debug("config file: %s, dir: %s\n", base, dir);
 817
 818         wd = inotify_add_watch(fd, dir, IN_CLOSE_WRITE);
 819         if (wd >= 0) {
 820                 daemon->config_base = strdup(base);
 821                 if (!daemon->config_base) {
 822                         close(fd);
 823                         wd = -1;
 824                 }
 825         } else {
 826                 perror("failed: inotify_add_watch");
 827         }
 828
 829 out:
 830         free(basen);
 831         free(dirn);
 832         return wd < 0 ? -1 : fd;
 833 }
 834
 835 static bool process_inotify_event(struct daemon *daemon, char *buf, ssize_t len)
 836 {
 837         char *p = buf;
 838
 839         while (p < (buf + len)) {
 840                 struct inotify_event *event = (struct inotify_event *) p;
 841
 842                 /*
 843                  * We monitor config directory, check if our
 844                  * config file was changes.
 845                  */
 846                 if ((event->mask & IN_CLOSE_WRITE) &&
 847                     !(event->mask & IN_ISDIR)) {
 848                         if (!strcmp(event->name, daemon->config_base))
 849                                 return true;
 850                 }
 851                 p += sizeof(*event) + event->len;
 852         }
 853         return false;
 854 }
 855
 856 static int handle_config_changes(struct daemon *daemon, int conf_fd,
 857                                  bool *config_changed)
 858 {
 859         char buf[4096];
 860         ssize_t len;
 861
 862         while (!(*config_changed)) {
 863                 len = read(conf_fd, buf, sizeof(buf));
 864                 if (len == -1) {
 865                         if (errno != EAGAIN) {
 866                                 perror("failed: read");
 867                                 return -1;
 868                         }
 869                         return 0;
 870                 }
 871                 *config_changed = process_inotify_event(daemon, buf, len);
 872         }
 873         return 0;
 874 }
 875
 876 static int setup_config(struct daemon *daemon)
 877 {
 878         if (daemon->base_user) {
 879                 daemon->base = strdup(daemon->base_user);
 880                 if (!daemon->base)
 881                         return -ENOMEM;
 882         }
 883
 884         if (daemon->config) {
 885                 char *real = realpath(daemon->config, NULL);
 886
 887                 if (!real) {
 888                         perror("failed: realpath");
 889                         return -1;
 890                 }
 891                 daemon->config_real = real;
 892                 return 0;
 893         }
 894
 895         if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK))
 896                 daemon->config_real = strdup(perf_etc_perfconfig());
 897         else if (perf_config_global() && perf_home_perfconfig())
 898                 daemon->config_real = strdup(perf_home_perfconfig());
 899
 900         return daemon->config_real ? 0 : -1;
 901 }
 902
 903 static int go_background(struct daemon *daemon)
 904 {
 905         int pid, fd;
 906
 907         pid = fork();
 908         if (pid < 0)
 909                 return -1;
 910
 911         if (pid > 0)
 912                 return 1;
 913
 914         if (setsid() < 0)
 915                 return -1;
 916
 917         umask(0);
 918
 919         if (chdir(daemon->base)) {
 920                 perror("failed: chdir");
 921                 return -1;
 922         }
 923
 924         fd = open("output", O_RDWR|O_CREAT|O_TRUNC, 0644);
 925         if (fd < 0) {
 926                 perror("failed: open");
 927                 return -1;
 928         }
 929
 930         if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
 931                 perror("failed: fcntl FD_CLOEXEC");
 932                 close(fd);
 933                 return -1;
 934         }
 935
 936         close(0);
 937         dup2(fd, 1);
 938         dup2(fd, 2);
 939         close(fd);
 940
 941         daemon->out = fdopen(1, "w");
 942         if (!daemon->out) {
 943                 close(1);
 944                 close(2);
 945                 return -1;
 946         }
 947
 948         setbuf(daemon->out, NULL);
 949         return 0;
 950 }
 951
 952 static int setup_signalfd(struct daemon *daemon)
 953 {
 954         sigset_t mask;
 955
 956         sigemptyset(&mask);
 957         sigaddset(&mask, SIGCHLD);
 958
 959         if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
 960                 return -1;
 961
 962         daemon->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 963         return daemon->signal_fd;
 964 }
 965
 966 static int __cmd_start(struct daemon *daemon, struct option parent_options[],
 967                        int argc, const char **argv)
 968 {
 969         bool foreground = false;
 970         struct option start_options[] = {
 971                 OPT_BOOLEAN('f', "foreground", &foreground, "stay on console"),
 972                 OPT_PARENT(parent_options),
 973                 OPT_END()
 974         };
 975         int sock_fd = -1, conf_fd = -1, signal_fd = -1;
 976         int sock_pos, file_pos, signal_pos;
 977         struct fdarray fda;
 978         int err = 0;
 979
 980         argc = parse_options(argc, argv, start_options, daemon_usage, 0);
 981         if (argc)
 982                 usage_with_options(daemon_usage, start_options);
 983
 984         if (setup_config(daemon)) {
 985                 pr_err("failed: config not found\n");
 986                 return -1;
 987         }
 988
 989         if (setup_server_config(daemon))
 990                 return -1;
 991
 992         if (!foreground) {
 993                 err = go_background(daemon);
 994                 if (err) {
 995                         /* original process, exit normally */
 996                         if (err == 1)
 997                                 err = 0;
 998                         daemon__exit(daemon);
 999                         return err;
1000                 }
1001         }
1002
1003         debug_set_file(daemon->out);
1004         debug_set_display_time(true);
1005
1006         pr_info("daemon started (pid %d)\n", getpid());
1007
1008         fdarray__init(&fda, 3);
1009
1010         sock_fd = setup_server_socket(daemon);
1011         if (sock_fd < 0)
1012                 goto out;
1013
1014         conf_fd = setup_config_changes(daemon);
1015         if (conf_fd < 0)
1016                 goto out;
1017
1018         signal_fd = setup_signalfd(daemon);
1019         if (signal_fd < 0)
1020                 goto out;
1021
1022         sock_pos = fdarray__add(&fda, sock_fd, POLLIN|POLLERR|POLLHUP, 0);
1023         if (sock_pos < 0)
1024                 goto out;
1025
1026         file_pos = fdarray__add(&fda, conf_fd, POLLIN|POLLERR|POLLHUP, 0);
1027         if (file_pos < 0)
1028                 goto out;
1029
1030         signal_pos = fdarray__add(&fda, signal_fd, POLLIN|POLLERR|POLLHUP, 0);
1031         if (signal_pos < 0)
1032                 goto out;
1033
1034         signal(SIGINT, sig_handler);
1035         signal(SIGTERM, sig_handler);
1036
1037         while (!done && !err) {
1038                 err = daemon__reconfig(daemon);
1039
1040                 if (!err && fdarray__poll(&fda, -1)) {
1041                         bool reconfig = false;
1042
1043                         if (fda.entries[sock_pos].revents & POLLIN)
1044                                 err = handle_server_socket(daemon, sock_fd);
1045                         if (fda.entries[file_pos].revents & POLLIN)
1046                                 err = handle_config_changes(daemon, conf_fd, &reconfig);
1047                         if (fda.entries[signal_pos].revents & POLLIN)
1048                                 err = handle_signalfd(daemon) < 0;
1049
1050                         if (reconfig)
1051                                 err = setup_server_config(daemon);
1052                 }
1053         }
1054
1055 out:
1056         fdarray__exit(&fda);
1057
1058         daemon__kill(daemon);
1059         daemon__exit(daemon);
1060
1061         if (sock_fd != -1)
1062                 close(sock_fd);
1063         if (conf_fd != -1)
1064                 close(conf_fd);
1065         if (conf_fd != -1)
1066                 close(signal_fd);
1067
1068         pr_info("daemon exited\n");
1069         fclose(daemon->out);
1070         return err;
1071 }
1072
1073 static int send_cmd(struct daemon *daemon, union cmd *cmd)
1074 {
1075         int ret = -1, fd;
1076         char *line = NULL;
1077         size_t len = 0;
1078         ssize_t nread;
1079         FILE *in = NULL;
1080
1081         if (setup_client_config(daemon))
1082                 return -1;
1083
1084         fd = setup_client_socket(daemon);
1085         if (fd < 0)
1086                 return -1;
1087
1088         if (sizeof(*cmd) != writen(fd, cmd, sizeof(*cmd))) {
1089                 perror("failed: write");
1090                 goto out;
1091         }
1092
1093         in = fdopen(fd, "r");
1094         if (!in) {
1095                 perror("failed: fdopen");
1096                 goto out;
1097         }
1098
1099         while ((nread = getline(&line, &len, in)) != -1) {
1100                 if (fwrite(line, nread, 1, stdout) != 1)
1101                         goto out_fclose;
1102                 fflush(stdout);
1103         }
1104
1105         ret = 0;
1106 out_fclose:
1107         fclose(in);
1108         free(line);
1109 out:
1110         /* If in is defined, then fd is closed via fclose. */
1111         if (!in)
1112                 close(fd);
1113         return ret;
1114 }
1115
1116 static int send_cmd_list(struct daemon *daemon)
1117 {
1118         union cmd cmd = { .cmd = CMD_LIST, };
1119
1120         cmd.list.verbose = verbose;
1121         cmd.list.csv_sep = daemon->csv_sep ? *daemon->csv_sep : 0;
1122
1123         return send_cmd(daemon, &cmd);
1124 }
1125
1126 static int __cmd_signal(struct daemon *daemon, struct option parent_options[],
1127                         int argc, const char **argv)
1128 {
1129         const char *name = "all";
1130         struct option start_options[] = {
1131                 OPT_STRING(0, "session", &name, "session",
1132                         "Sent signal to specific session"),
1133                 OPT_PARENT(parent_options),
1134                 OPT_END()
1135         };
1136         union cmd cmd;
1137
1138         argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1139         if (argc)
1140                 usage_with_options(daemon_usage, start_options);
1141
1142         if (setup_config(daemon)) {
1143                 pr_err("failed: config not found\n");
1144                 return -1;
1145         }
1146
1147         cmd.signal.cmd = CMD_SIGNAL,
1148         cmd.signal.sig = SIGUSR2;
1149         strncpy(cmd.signal.name, name, sizeof(cmd.signal.name) - 1);
1150
1151         return send_cmd(daemon, &cmd);
1152 }
1153
1154 int cmd_daemon(int argc, const char **argv)
1155 {
1156         struct option daemon_options[] = {
1157                 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1158                 OPT_STRING(0, "config", &__daemon.config,
1159                         "config file", "config file path"),
1160                 OPT_STRING(0, "base", &__daemon.base_user,
1161                         "directory", "base directory"),
1162                 OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
1163                         "field separator", "print counts with custom separator", ","),
1164                 OPT_END()
1165         };
1166
1167         perf_exe(__daemon.perf, sizeof(__daemon.perf));
1168         __daemon.out = stdout;
1169
1170         argc = parse_options(argc, argv, daemon_options, daemon_usage,
1171                              PARSE_OPT_STOP_AT_NON_OPTION);
1172
1173         if (argc) {
1174                 if (!strcmp(argv[0], "start"))
1175                         return __cmd_start(&__daemon, daemon_options, argc, argv);
1176                 if (!strcmp(argv[0], "signal"))
1177                         return __cmd_signal(&__daemon, daemon_options, argc, argv);
1178
1179                 pr_err("failed: unknown command '%s'\n", argv[0]);
1180                 return -1;
1181         }
1182
1183         if (setup_config(&__daemon)) {
1184                 pr_err("failed: config not found\n");
1185                 return -1;
1186         }
1187
1188         return send_cmd_list(&__daemon);
1189 }