// SPDX-License-Identifier: GPL-2.0
#include <internal/lib.h>
#include <inttypes.h>
#include <subcmd/parse-options.h>
#include <api/fd/array.h>
#include <api/fs/fs.h>
#include <linux/zalloc.h>
#include <linux/string.h>
#include <linux/limits.h>
#include <string.h>
#include <sys/file.h>
#include <signal.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/inotify.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <poll.h>
#include "builtin.h"
#include "perf.h"
#include "debug.h"
#include "config.h"
#include "util.h"

#define SESSION_OUTPUT  "output"
#define SESSION_CONTROL "control"
#define SESSION_ACK     "ack"

/*
 * Session states:
 *
 *   OK       - session is up and running
 *   RECONFIG - session is pending for reconfiguration,
 *              new values are already loaded in session object
 *   KILL     - session is pending to be killed
 *
 * Session object life and its state is maintained by
 * following functions:
 *
 *  setup_server_config
 *    - reads config file and setup session objects
 *      with following states:
 *
 *      OK       - no change needed
 *      RECONFIG - session needs to be changed
 *                 (run variable changed)
 *      KILL     - session needs to be killed
 *                 (session is no longer in config file)
 *
 *  daemon__reconfig
 *    - scans session objects and does following actions
 *      for states:
 *
 *      OK       - skip
 *      RECONFIG - session is killed and re-run with new config
 *      KILL     - session is killed
 *
 *    - all sessions have OK state on the function exit
 */
enum daemon_session_state {
        OK,
        RECONFIG,
        KILL,
};

struct daemon_session {
        char                            *base;
        char                            *name;
        char                            *run;
        char                            *control;
        int                              pid;
        struct list_head                 list;
        enum daemon_session_state        state;
        time_t                           start;
};

struct daemon {
        const char              *config;
        char                    *config_real;
        char                    *config_base;
        const char              *csv_sep;
        const char              *base_user;
        char                    *base;
        struct list_head         sessions;
        FILE                    *out;
        char                    *perf;
        int                      signal_fd;
        time_t                   start;
};

static struct daemon __daemon = {
        .sessions = LIST_HEAD_INIT(__daemon.sessions),
};

static const char * const daemon_usage[] = {
        "perf daemon {start|signal|stop|ping} [<options>]",
        "perf daemon [<options>]",
        NULL
};

static volatile sig_atomic_t done;

static void sig_handler(int sig __maybe_unused)
{
        done = true;
}

static struct daemon_session *daemon__add_session(struct daemon *config, char *name)
{
        struct daemon_session *session = zalloc(sizeof(*session));

        if (!session)
                return NULL;

        session->name = strdup(name);
        if (!session->name) {
                free(session);
                return NULL;
        }

        session->pid = -1;
        list_add_tail(&session->list, &config->sessions);
        return session;
}

static struct daemon_session *daemon__find_session(struct daemon *daemon, char *name)
{
        struct daemon_session *session;

        list_for_each_entry(session, &daemon->sessions, list) {
                if (!strcmp(session->name, name))
                        return session;
        }

        return NULL;
}

static int get_session_name(const char *var, char *session, int len)
{
        const char *p = var + sizeof("session-") - 1;

        while (*p != '.' && *p != 0x0 && len--)
                *session++ = *p++;

        *session = 0;
        return *p == '.' ? 0 : -EINVAL;
}

static int session_config(struct daemon *daemon, const char *var, const char *value)
{
        struct daemon_session *session;
        char name[100];

        if (get_session_name(var, name, sizeof(name) - 1))
                return -EINVAL;

        var = strchr(var, '.');
        if (!var)
                return -EINVAL;

        var++;

        session = daemon__find_session(daemon, name);

        if (!session) {
                /* New session is defined. */
                session = daemon__add_session(daemon, name);
                if (!session)
                        return -ENOMEM;

                pr_debug("reconfig: found new session %s\n", name);

                /* Trigger reconfig to start it. */
                session->state = RECONFIG;
        } else if (session->state == KILL) {
                /* Current session is defined, no action needed. */
                pr_debug("reconfig: found current session %s\n", name);
                session->state = OK;
        }

        if (!strcmp(var, "run")) {
                bool same = false;

                if (session->run)
                        same = !strcmp(session->run, value);

                if (!same) {
                        if (session->run) {
                                zfree(&session->run);
                                pr_debug("reconfig: session %s is changed\n", name);
                        }

                        session->run = strdup(value);
                        if (!session->run)
                                return -ENOMEM;

                        /*
                         * Either new or changed run value is defined,
                         * trigger reconfig for the session.
                         */
                        session->state = RECONFIG;
                }
        }

        return 0;
}

static int server_config(const char *var, const char *value, void *cb)
{
        struct daemon *daemon = cb;

        if (strstarts(var, "session-")) {
                return session_config(daemon, var, value);
        } else if (!strcmp(var, "daemon.base") && !daemon->base_user) {
                if (daemon->base && strcmp(daemon->base, value)) {
                        pr_err("failed: can't redefine base, bailing out\n");
                        return -EINVAL;
                }
                daemon->base = strdup(value);
                if (!daemon->base)
                        return -ENOMEM;
        }

        return 0;
}

static int client_config(const char *var, const char *value, void *cb)
{
        struct daemon *daemon = cb;

        if (!strcmp(var, "daemon.base") && !daemon->base_user) {
                daemon->base = strdup(value);
                if (!daemon->base)
                        return -ENOMEM;
        }

        return 0;
}

static int check_base(struct daemon *daemon)
{
        struct stat st;

        if (!daemon->base) {
                pr_err("failed: base not defined\n");
                return -EINVAL;
        }

        if (stat(daemon->base, &st)) {
                switch (errno) {
                case EACCES:
                        pr_err("failed: permission denied for '%s' base\n",
                               daemon->base);
                        return -EACCES;
                case ENOENT:
                        pr_err("failed: base '%s' does not exists\n",
                               daemon->base);
                        return -EACCES;
                default:
                        pr_err("failed: can't access base '%s': %m\n", daemon->base);
                        return -errno;
                }
        }

        if ((st.st_mode & S_IFMT) != S_IFDIR) {
                pr_err("failed: base '%s' is not directory\n",
                       daemon->base);
                return -EINVAL;
        }

        return 0;
}

static int setup_client_config(struct daemon *daemon)
{
        struct perf_config_set *set = perf_config_set__load_file(daemon->config_real);
        int err = -ENOMEM;

        if (set) {
                err = perf_config_set(set, client_config, daemon);
                perf_config_set__delete(set);
        }

        return err ?: check_base(daemon);
}

static int setup_server_config(struct daemon *daemon)
{
        struct perf_config_set *set;
        struct daemon_session *session;
        int err = -ENOMEM;

        pr_debug("reconfig: started\n");

        /*
         * Mark all sessions for kill, the server config
         * will set following states, see explanation at
         * enum daemon_session_state declaration.
         */
        list_for_each_entry(session, &daemon->sessions, list)
                session->state = KILL;

        set = perf_config_set__load_file(daemon->config_real);
        if (set) {
                err = perf_config_set(set, server_config, daemon);
                perf_config_set__delete(set);
        }

        return err ?: check_base(daemon);
}

static int daemon_session__run(struct daemon_session *session,
                               struct daemon *daemon)
{
        char buf[PATH_MAX];
        char **argv;
        int argc, fd;

        if (asprintf(&session->base, "%s/session-%s",
                     daemon->base, session->name) < 0) {
                perror("failed: asprintf");
                return -1;
        }

        if (mkdir(session->base, 0755) && errno != EEXIST) {
                perror("failed: mkdir");
                return -1;
        }

        session->start = time(NULL);

        session->pid = fork();
        if (session->pid < 0)
                return -1;
        if (session->pid > 0) {
                pr_info("reconfig: ruining session [%s:%d]: %s\n",
                        session->name, session->pid, session->run);
                return 0;
        }

        if (chdir(session->base)) {
                perror("failed: chdir");
                return -1;
        }

        fd = open("/dev/null", O_RDONLY);
        if (fd < 0) {
                perror("failed: open /dev/null");
                return -1;
        }

        dup2(fd, 0);
        close(fd);

        fd = open(SESSION_OUTPUT, O_RDWR|O_CREAT|O_TRUNC, 0644);
        if (fd < 0) {
                perror("failed: open session output");
                return -1;
        }

        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);

        if (mkfifo(SESSION_CONTROL, 0600) && errno != EEXIST) {
                perror("failed: create control fifo");
                return -1;
        }

        if (mkfifo(SESSION_ACK, 0600) && errno != EEXIST) {
                perror("failed: create ack fifo");
                return -1;
        }

        scnprintf(buf, sizeof(buf), "%s record --control=fifo:%s,%s %s",
                  daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);

        argv = argv_split(buf, &argc);
        if (!argv)
                exit(-1);

        exit(execve(daemon->perf, argv, NULL));
        return -1;
}

static pid_t handle_signalfd(struct daemon *daemon)
{
        struct daemon_session *session;
        struct signalfd_siginfo si;
        ssize_t err;
        int status;
        pid_t pid;

        /*
         * Take signal fd data as pure signal notification and check all
         * the sessions state. The reason is that multiple signals can get
         * coalesced in kernel and we can receive only single signal even
         * if multiple SIGCHLD were generated.
         */
        err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
        if (err != sizeof(struct signalfd_siginfo)) {
                pr_err("failed to read signal fd\n");
                return -1;
        }

        list_for_each_entry(session, &daemon->sessions, list) {
                if (session->pid == -1)
                        continue;

                pid = waitpid(session->pid, &status, WNOHANG);
                if (pid <= 0)
                        continue;

                if (WIFEXITED(status)) {
                        pr_info("session '%s' exited, status=%d\n",
                                session->name, WEXITSTATUS(status));
                } else if (WIFSIGNALED(status)) {
                        pr_info("session '%s' killed (signal %d)\n",
                                session->name, WTERMSIG(status));
                } else if (WIFSTOPPED(status)) {
                        pr_info("session '%s' stopped (signal %d)\n",
                                session->name, WSTOPSIG(status));
                } else {
                        pr_info("session '%s' Unexpected status (0x%x)\n",
                                session->name, status);
                }

                session->state = KILL;
                session->pid = -1;
        }

        return 0;
}

static int daemon_session__wait(struct daemon_session *session, struct daemon *daemon,
                                int secs)
{
        struct pollfd pollfd = {
                .fd     = daemon->signal_fd,
                .events = POLLIN,
        };
        time_t start;

        start = time(NULL);

        do {
                int err = poll(&pollfd, 1, 1000);

                if (err > 0) {
                        handle_signalfd(daemon);
                } else if (err < 0) {
                        perror("failed: poll\n");
                        return -1;
                }

                if (start + secs < time(NULL))
                        return -1;
        } while (session->pid != -1);

        return 0;
}

static bool daemon__has_alive_session(struct daemon *daemon)
{
        struct daemon_session *session;

        list_for_each_entry(session, &daemon->sessions, list) {
                if (session->pid != -1)
                        return true;
        }

        return false;
}

static int daemon__wait(struct daemon *daemon, int secs)
{
        struct pollfd pollfd = {
                .fd     = daemon->signal_fd,
                .events = POLLIN,
        };
        time_t start;

        start = time(NULL);

        do {
                int err = poll(&pollfd, 1, 1000);

                if (err > 0) {
                        handle_signalfd(daemon);
                } else if (err < 0) {
                        perror("failed: poll\n");
                        return -1;
                }

                if (start + secs < time(NULL))
                        return -1;
        } while (daemon__has_alive_session(daemon));

        return 0;
}

static int daemon_session__control(struct daemon_session *session,
                                   const char *msg, bool do_ack)
{
        struct pollfd pollfd = { .events = POLLIN, };
        char control_path[PATH_MAX];
        char ack_path[PATH_MAX];
        int control, ack = -1, len;
        char buf[20];
        int ret = -1;
        ssize_t err;

        /* open the control file */
        scnprintf(control_path, sizeof(control_path), "%s/%s",
                  session->base, SESSION_CONTROL);

        control = open(control_path, O_WRONLY|O_NONBLOCK);
        if (control < 0)
                return -1;

        if (do_ack) {
                /* open the ack file */
                scnprintf(ack_path, sizeof(ack_path), "%s/%s",
                          session->base, SESSION_ACK);

                ack = open(ack_path, O_RDONLY, O_NONBLOCK);
                if (ack < 0) {
                        close(control);
                        return -1;
                }
        }

        /* write the command */
        len = strlen(msg);

        err = writen(control, msg, len);
        if (err != len) {
                pr_err("failed: write to control pipe: %m (%s)\n", control_path);
                goto out;
        }

        if (!do_ack)
                goto out;

        /* wait for an ack */
        pollfd.fd = ack;

        if (!poll(&pollfd, 1, 2000)) {
                pr_err("failed: control ack timeout\n");
                goto out;
        }

        if (!(pollfd.revents & POLLIN)) {
                pr_err("failed: did not received an ack\n");
                goto out;
        }

        err = read(ack, buf, sizeof(buf));
        if (err > 0)
                ret = strcmp(buf, "ack\n");
        else
                perror("failed: read ack %d\n");

out:
        if (ack != -1)
                close(ack);

        close(control);
        return ret;
}

static int setup_server_socket(struct daemon *daemon)
{
        struct sockaddr_un addr;
        char path[PATH_MAX];
        int fd = socket(AF_UNIX, SOCK_STREAM, 0);

        if (fd < 0) {
                fprintf(stderr, "socket: %m\n");
                return -1;
        }

        if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
                perror("failed: fcntl FD_CLOEXEC");
                close(fd);
                return -1;
        }

        scnprintf(path, sizeof(path), "%s/control", daemon->base);

        if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
                pr_err("failed: control path too long '%s'\n", path);
                close(fd);
                return -1;
        }

        memset(&addr, 0, sizeof(addr));
        addr.sun_family = AF_UNIX;

        strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
        unlink(path);

        if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
                perror("failed: bind");
                close(fd);
                return -1;
        }

        if (listen(fd, 1) == -1) {
                perror("failed: listen");
                close(fd);
                return -1;
        }

        return fd;
}

enum {
        CMD_LIST   = 0,
        CMD_SIGNAL = 1,
        CMD_STOP   = 2,
        CMD_PING   = 3,
        CMD_MAX,
};

#define SESSION_MAX 64

union cmd {
        int cmd;

        /* CMD_LIST */
        struct {
                int     cmd;
                int     verbose;
                char    csv_sep;
        } list;

        /* CMD_SIGNAL */
        struct {
                int     cmd;
                int     sig;
                char    name[SESSION_MAX];
        } signal;

        /* CMD_PING */
        struct {
                int     cmd;
                char    name[SESSION_MAX];
        } ping;
};

enum {
        PING_OK   = 0,
        PING_FAIL = 1,
        PING_MAX,
};

static int daemon_session__ping(struct daemon_session *session)
{
        return daemon_session__control(session, "ping", true) ?  PING_FAIL : PING_OK;
}

static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
{
        char csv_sep = cmd->list.csv_sep;
        struct daemon_session *session;
        time_t curr = time(NULL);

        if (csv_sep) {
                fprintf(out, "%d%c%s%c%s%c%s/%s",
                        /* pid daemon  */
                        getpid(), csv_sep, "daemon",
                        /* base */
                        csv_sep, daemon->base,
                        /* output */
                        csv_sep, daemon->base, SESSION_OUTPUT);

                fprintf(out, "%c%s/%s",
                        /* lock */
                        csv_sep, daemon->base, "lock");

                fprintf(out, "%c%" PRIu64,
                        /* session up time */
                        csv_sep, (uint64_t)((curr - daemon->start) / 60));

                fprintf(out, "\n");
        } else {
                fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
                if (cmd->list.verbose) {
                        fprintf(out, "  output:  %s/%s\n",
                                daemon->base, SESSION_OUTPUT);
                        fprintf(out, "  lock:    %s/lock\n",
                                daemon->base);
                        fprintf(out, "  up:      %" PRIu64 " minutes\n",
                                (uint64_t)((curr - daemon->start) / 60));
                }
        }

        list_for_each_entry(session, &daemon->sessions, list) {
                if (csv_sep) {
                        fprintf(out, "%d%c%s%c%s",
                                /* pid */
                                session->pid,
                                /* name */
                                csv_sep, session->name,
                                /* base */
                                csv_sep, session->run);

                        fprintf(out, "%c%s%c%s/%s",
                                /* session dir */
                                csv_sep, session->base,
                                /* session output */
                                csv_sep, session->base, SESSION_OUTPUT);

                        fprintf(out, "%c%s/%s%c%s/%s",
                                /* session control */
                                csv_sep, session->base, SESSION_CONTROL,
                                /* session ack */
                                csv_sep, session->base, SESSION_ACK);

                        fprintf(out, "%c%" PRIu64,
                                /* session up time */
                                csv_sep, (uint64_t)((curr - session->start) / 60));

                        fprintf(out, "\n");
                } else {
                        fprintf(out, "[%d:%s] perf record %s\n",
                                session->pid, session->name, session->run);
                        if (!cmd->list.verbose)
                                continue;
                        fprintf(out, "  base:    %s\n",
                                session->base);
                        fprintf(out, "  output:  %s/%s\n",
                                session->base, SESSION_OUTPUT);
                        fprintf(out, "  control: %s/%s\n",
                                session->base, SESSION_CONTROL);
                        fprintf(out, "  ack:     %s/%s\n",
                                session->base, SESSION_ACK);
                        fprintf(out, "  up:      %" PRIu64 " minutes\n",
                                (uint64_t)((curr - session->start) / 60));
                }
        }

        return 0;
}

static int daemon_session__signal(struct daemon_session *session, int sig)
{
        if (session->pid < 0)
                return -1;
        return kill(session->pid, sig);
}

static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
{
        struct daemon_session *session;
        bool all = false;

        all = !strcmp(cmd->signal.name, "all");

        list_for_each_entry(session, &daemon->sessions, list) {
                if (all || !strcmp(cmd->signal.name, session->name)) {
                        daemon_session__signal(session, cmd->signal.sig);
                        fprintf(out, "signal %d sent to session '%s [%d]'\n",
                                cmd->signal.sig, session->name, session->pid);
                }
        }

        return 0;
}

static const char *ping_str[PING_MAX] = {
        [PING_OK]   = "OK",
        [PING_FAIL] = "FAIL",
};

static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
{
        struct daemon_session *session;
        bool all = false, found = false;

        all = !strcmp(cmd->ping.name, "all");

        list_for_each_entry(session, &daemon->sessions, list) {
                if (all || !strcmp(cmd->ping.name, session->name)) {
                        int state = daemon_session__ping(session);

                        fprintf(out, "%-4s %s\n", ping_str[state], session->name);
                        found = true;
                }
        }

        if (!found && !all) {
                fprintf(out, "%-4s %s (not found)\n",
                        ping_str[PING_FAIL], cmd->ping.name);
        }
        return 0;
}

static int handle_server_socket(struct daemon *daemon, int sock_fd)
{
        int ret = -1, fd;
        FILE *out = NULL;
        union cmd cmd;

        fd = accept(sock_fd, NULL, NULL);
        if (fd < 0) {
                perror("failed: accept");
                return -1;
        }

        if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
                perror("failed: read");
                goto out;
        }

        out = fdopen(fd, "w");
        if (!out) {
                perror("failed: fdopen");
                goto out;
        }

        switch (cmd.cmd) {
        case CMD_LIST:
                ret = cmd_session_list(daemon, &cmd, out);
                break;
        case CMD_SIGNAL:
                ret = cmd_session_kill(daemon, &cmd, out);
                break;
        case CMD_STOP:
                done = 1;
                ret = 0;
                pr_debug("perf daemon is exciting\n");
                break;
        case CMD_PING:
                ret = cmd_session_ping(daemon, &cmd, out);
                break;
        default:
                break;
        }

        fclose(out);
out:
        /* If out is defined, then fd is closed via fclose. */
        if (!out)
                close(fd);
        return ret;
}

static int setup_client_socket(struct daemon *daemon)
{
        struct sockaddr_un addr;
        char path[PATH_MAX];
        int fd = socket(AF_UNIX, SOCK_STREAM, 0);

        if (fd == -1) {
                perror("failed: socket");
                return -1;
        }

        scnprintf(path, sizeof(path), "%s/control", daemon->base);

        if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
                pr_err("failed: control path too long '%s'\n", path);
                close(fd);
                return -1;
        }

        memset(&addr, 0, sizeof(addr));
        addr.sun_family = AF_UNIX;
        strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);

        if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
                perror("failed: connect");
                close(fd);
                return -1;
        }

        return fd;
}

static void daemon_session__kill(struct daemon_session *session,
                                 struct daemon *daemon)
{
        int how = 0;

        do {
                switch (how) {
                case 0:
                        daemon_session__control(session, "stop", false);
                        break;
                case 1:
                        daemon_session__signal(session, SIGTERM);
                        break;
                case 2:
                        daemon_session__signal(session, SIGKILL);
                        break;
                default:
                        pr_err("failed to wait for session %s\n",
                               session->name);
                        return;
                }
                how++;

        } while (daemon_session__wait(session, daemon, 10));
}

static void daemon__signal(struct daemon *daemon, int sig)
{
        struct daemon_session *session;

        list_for_each_entry(session, &daemon->sessions, list)
                daemon_session__signal(session, sig);
}

static void daemon_session__delete(struct daemon_session *session)
{
        zfree(&session->base);
        zfree(&session->name);
        zfree(&session->run);
        free(session);
}

static void daemon_session__remove(struct daemon_session *session)
{
        list_del(&session->list);
        daemon_session__delete(session);
}

static void daemon__stop(struct daemon *daemon)
{
        struct daemon_session *session;

        list_for_each_entry(session, &daemon->sessions, list)
                daemon_session__control(session, "stop", false);
}

static void daemon__kill(struct daemon *daemon)
{
        int how = 0;

        do {
                switch (how) {
                case 0:
                        daemon__stop(daemon);
                        break;
                case 1:
                        daemon__signal(daemon, SIGTERM);
                        break;
                case 2:
                        daemon__signal(daemon, SIGKILL);
                        break;
                default:
                        pr_err("failed to wait for sessions\n");
                        return;
                }
                how++;

        } while (daemon__wait(daemon, 10));
}

static void daemon__exit(struct daemon *daemon)
{
        struct daemon_session *session, *h;

        list_for_each_entry_safe(session, h, &daemon->sessions, list)
                daemon_session__remove(session);

        zfree(&daemon->config_real);
        zfree(&daemon->config_base);
        zfree(&daemon->base);
}

static int daemon__reconfig(struct daemon *daemon)
{
        struct daemon_session *session, *n;

        list_for_each_entry_safe(session, n, &daemon->sessions, list) {
                /* No change. */
                if (session->state == OK)
                        continue;

                /* Remove session. */
                if (session->state == KILL) {
                        if (session->pid > 0) {
                                daemon_session__kill(session, daemon);
                                pr_info("reconfig: session '%s' killed\n", session->name);
                        }
                        daemon_session__remove(session);
                        continue;
                }

                /* Reconfig session. */
                if (session->pid > 0) {
                        daemon_session__kill(session, daemon);
                        pr_info("reconfig: session '%s' killed\n", session->name);
                }
                if (daemon_session__run(session, daemon))
                        return -1;

                session->state = OK;
        }

        return 0;
}

static int setup_config_changes(struct daemon *daemon)
{
        char *basen = strdup(daemon->config_real);
        char *dirn  = strdup(daemon->config_real);
        char *base, *dir;
        int fd, wd = -1;

        if (!dirn || !basen)
                goto out;

        fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
        if (fd < 0) {
                perror("failed: inotify_init");
                goto out;
        }

        dir = dirname(dirn);
        base = basename(basen);
        pr_debug("config file: %s, dir: %s\n", base, dir);

        wd = inotify_add_watch(fd, dir, IN_CLOSE_WRITE);
        if (wd >= 0) {
                daemon->config_base = strdup(base);
                if (!daemon->config_base) {
                        close(fd);
                        wd = -1;
                }
        } else {
                perror("failed: inotify_add_watch");
        }

out:
        free(basen);
        free(dirn);
        return wd < 0 ? -1 : fd;
}

static bool process_inotify_event(struct daemon *daemon, char *buf, ssize_t len)
{
        char *p = buf;

        while (p < (buf + len)) {
                struct inotify_event *event = (struct inotify_event *) p;

                /*
                 * We monitor config directory, check if our
                 * config file was changes.
                 */
                if ((event->mask & IN_CLOSE_WRITE) &&
                    !(event->mask & IN_ISDIR)) {
                        if (!strcmp(event->name, daemon->config_base))
                                return true;
                }
                p += sizeof(*event) + event->len;
        }
        return false;
}

static int handle_config_changes(struct daemon *daemon, int conf_fd,
                                 bool *config_changed)
{
        char buf[4096];
        ssize_t len;

        while (!(*config_changed)) {
                len = read(conf_fd, buf, sizeof(buf));
                if (len == -1) {
                        if (errno != EAGAIN) {
                                perror("failed: read");
                                return -1;
                        }
                        return 0;
                }
                *config_changed = process_inotify_event(daemon, buf, len);
        }
        return 0;
}

static int setup_config(struct daemon *daemon)
{
        if (daemon->base_user) {
                daemon->base = strdup(daemon->base_user);
                if (!daemon->base)
                        return -ENOMEM;
        }

        if (daemon->config) {
                char *real = realpath(daemon->config, NULL);

                if (!real) {
                        perror("failed: realpath");
                        return -1;
                }
                daemon->config_real = real;
                return 0;
        }

        if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK))
                daemon->config_real = strdup(perf_etc_perfconfig());
        else if (perf_config_global() && perf_home_perfconfig())
                daemon->config_real = strdup(perf_home_perfconfig());

        return daemon->config_real ? 0 : -1;
}

#ifndef F_TLOCK
#define F_TLOCK 2

static int lockf(int fd, int cmd, off_t len)
{
        if (cmd != F_TLOCK || len != 0)
                return -1;

        return flock(fd, LOCK_EX | LOCK_NB);
}
#endif // F_TLOCK

/*
 * Each daemon tries to create and lock BASE/lock file,
 * if it's successful we are sure we're the only daemon
 * running over the BASE.
 *
 * Once daemon is finished, file descriptor to lock file
 * is closed and lock is released.
 */
static int check_lock(struct daemon *daemon)
{
        char path[PATH_MAX];
        char buf[20];
        int fd, pid;
        ssize_t len;

        scnprintf(path, sizeof(path), "%s/lock", daemon->base);

        fd = open(path, O_RDWR|O_CREAT|O_CLOEXEC, 0640);
        if (fd < 0)
                return -1;

        if (lockf(fd, F_TLOCK, 0) < 0) {
                filename__read_int(path, &pid);
                fprintf(stderr, "failed: another perf daemon (pid %d) owns %s\n",
                        pid, daemon->base);
                close(fd);
                return -1;
        }

        scnprintf(buf, sizeof(buf), "%d", getpid());
        len = strlen(buf);

        if (write(fd, buf, len) != len) {
                perror("failed: write");
                close(fd);
                return -1;
        }

        if (ftruncate(fd, len)) {
                perror("failed: ftruncate");
                close(fd);
                return -1;
        }

        return 0;
}

static int go_background(struct daemon *daemon)
{
        int pid, fd;

        pid = fork();
        if (pid < 0)
                return -1;

        if (pid > 0)
                return 1;

        if (setsid() < 0)
                return -1;

        if (check_lock(daemon))
                return -1;

        umask(0);

        if (chdir(daemon->base)) {
                perror("failed: chdir");
                return -1;
        }

        fd = open("output", O_RDWR|O_CREAT|O_TRUNC, 0644);
        if (fd < 0) {
                perror("failed: open");
                return -1;
        }

        if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
                perror("failed: fcntl FD_CLOEXEC");
                close(fd);
                return -1;
        }

        close(0);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);

        daemon->out = fdopen(1, "w");
        if (!daemon->out) {
                close(1);
                close(2);
                return -1;
        }

        setbuf(daemon->out, NULL);
        return 0;
}

static int setup_signalfd(struct daemon *daemon)
{
        sigset_t mask;

        sigemptyset(&mask);
        sigaddset(&mask, SIGCHLD);

        if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
                return -1;

        daemon->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
        return daemon->signal_fd;
}

static int __cmd_start(struct daemon *daemon, struct option parent_options[],
                       int argc, const char **argv)
{
        bool foreground = false;
        struct option start_options[] = {
                OPT_BOOLEAN('f', "foreground", &foreground, "stay on console"),
                OPT_PARENT(parent_options),
                OPT_END()
        };
        int sock_fd = -1, conf_fd = -1, signal_fd = -1;
        int sock_pos, file_pos, signal_pos;
        struct fdarray fda;
        int err = 0;

        argc = parse_options(argc, argv, start_options, daemon_usage, 0);
        if (argc)
                usage_with_options(daemon_usage, start_options);

        daemon->start = time(NULL);

        if (setup_config(daemon)) {
                pr_err("failed: config not found\n");
                return -1;
        }

        if (setup_server_config(daemon))
                return -1;

        if (foreground && check_lock(daemon))
                return -1;

        if (!foreground) {
                err = go_background(daemon);
                if (err) {
                        /* original process, exit normally */
                        if (err == 1)
                                err = 0;
                        daemon__exit(daemon);
                        return err;
                }
        }

        debug_set_file(daemon->out);
        debug_set_display_time(true);

        pr_info("daemon started (pid %d)\n", getpid());

        fdarray__init(&fda, 3);

        sock_fd = setup_server_socket(daemon);
        if (sock_fd < 0)
                goto out;

        conf_fd = setup_config_changes(daemon);
        if (conf_fd < 0)
                goto out;

        signal_fd = setup_signalfd(daemon);
        if (signal_fd < 0)
                goto out;

        sock_pos = fdarray__add(&fda, sock_fd, POLLIN|POLLERR|POLLHUP, 0);
        if (sock_pos < 0)
                goto out;

        file_pos = fdarray__add(&fda, conf_fd, POLLIN|POLLERR|POLLHUP, 0);
        if (file_pos < 0)
                goto out;

        signal_pos = fdarray__add(&fda, signal_fd, POLLIN|POLLERR|POLLHUP, 0);
        if (signal_pos < 0)
                goto out;

        signal(SIGINT, sig_handler);
        signal(SIGTERM, sig_handler);
        signal(SIGPIPE, SIG_IGN);

        while (!done && !err) {
                err = daemon__reconfig(daemon);

                if (!err && fdarray__poll(&fda, -1)) {
                        bool reconfig = false;

                        if (fda.entries[sock_pos].revents & POLLIN)
                                err = handle_server_socket(daemon, sock_fd);
                        if (fda.entries[file_pos].revents & POLLIN)
                                err = handle_config_changes(daemon, conf_fd, &reconfig);
                        if (fda.entries[signal_pos].revents & POLLIN)
                                err = handle_signalfd(daemon) < 0;

                        if (reconfig)
                                err = setup_server_config(daemon);
                }
        }

out:
        fdarray__exit(&fda);

        daemon__kill(daemon);
        daemon__exit(daemon);

        if (sock_fd != -1)
                close(sock_fd);
        if (conf_fd != -1)
                close(conf_fd);
        if (signal_fd != -1)
                close(signal_fd);

        pr_info("daemon exited\n");
        fclose(daemon->out);
        return err;
}

static int send_cmd(struct daemon *daemon, union cmd *cmd)
{
        int ret = -1, fd;
        char *line = NULL;
        size_t len = 0;
        ssize_t nread;
        FILE *in = NULL;

        if (setup_client_config(daemon))
                return -1;

        fd = setup_client_socket(daemon);
        if (fd < 0)
                return -1;

        if (sizeof(*cmd) != writen(fd, cmd, sizeof(*cmd))) {
                perror("failed: write");
                goto out;
        }

        in = fdopen(fd, "r");
        if (!in) {
                perror("failed: fdopen");
                goto out;
        }

        while ((nread = getline(&line, &len, in)) != -1) {
                if (fwrite(line, nread, 1, stdout) != 1)
                        goto out_fclose;
                fflush(stdout);
        }

        ret = 0;
out_fclose:
        fclose(in);
        free(line);
out:
        /* If in is defined, then fd is closed via fclose. */
        if (!in)
                close(fd);
        return ret;
}

static int send_cmd_list(struct daemon *daemon)
{
        union cmd cmd;

        memset(&cmd, 0, sizeof(cmd));
        cmd.list.cmd = CMD_LIST;
        cmd.list.verbose = verbose;
        cmd.list.csv_sep = daemon->csv_sep ? *daemon->csv_sep : 0;

        return send_cmd(daemon, &cmd);
}

static int __cmd_signal(struct daemon *daemon, struct option parent_options[],
                        int argc, const char **argv)
{
        const char *name = "all";
        struct option start_options[] = {
                OPT_STRING(0, "session", &name, "session",
                        "Sent signal to specific session"),
                OPT_PARENT(parent_options),
                OPT_END()
        };
        union cmd cmd;

        argc = parse_options(argc, argv, start_options, daemon_usage, 0);
        if (argc)
                usage_with_options(daemon_usage, start_options);

        if (setup_config(daemon)) {
                pr_err("failed: config not found\n");
                return -1;
        }

        memset(&cmd, 0, sizeof(cmd));
        cmd.signal.cmd = CMD_SIGNAL;
        cmd.signal.sig = SIGUSR2;
        strncpy(cmd.signal.name, name, sizeof(cmd.signal.name) - 1);

        return send_cmd(daemon, &cmd);
}

static int __cmd_stop(struct daemon *daemon, struct option parent_options[],
                        int argc, const char **argv)
{
        struct option start_options[] = {
                OPT_PARENT(parent_options),
                OPT_END()
        };
        union cmd cmd;

        argc = parse_options(argc, argv, start_options, daemon_usage, 0);
        if (argc)
                usage_with_options(daemon_usage, start_options);

        if (setup_config(daemon)) {
                pr_err("failed: config not found\n");
                return -1;
        }

        memset(&cmd, 0, sizeof(cmd));
        cmd.cmd = CMD_STOP;
        return send_cmd(daemon, &cmd);
}

static int __cmd_ping(struct daemon *daemon, struct option parent_options[],
                      int argc, const char **argv)
{
        const char *name = "all";
        struct option ping_options[] = {
                OPT_STRING(0, "session", &name, "session",
                        "Ping to specific session"),
                OPT_PARENT(parent_options),
                OPT_END()
        };
        union cmd cmd;

        argc = parse_options(argc, argv, ping_options, daemon_usage, 0);
        if (argc)
                usage_with_options(daemon_usage, ping_options);

        if (setup_config(daemon)) {
                pr_err("failed: config not found\n");
                return -1;
        }

        memset(&cmd, 0, sizeof(cmd));
        cmd.cmd = CMD_PING;
        scnprintf(cmd.ping.name, sizeof(cmd.ping.name), "%s", name);
        return send_cmd(daemon, &cmd);
}

static char *alloc_perf_exe_path(void)
{
        char path[PATH_MAX];

        perf_exe(path, sizeof(path));
        return strdup(path);
}

int cmd_daemon(int argc, const char **argv)
{
        struct option daemon_options[] = {
                OPT_INCR('v', "verbose", &verbose, "be more verbose"),
                OPT_STRING(0, "config", &__daemon.config,
                        "config file", "config file path"),
                OPT_STRING(0, "base", &__daemon.base_user,
                        "directory", "base directory"),
                OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
                        "field separator", "print counts with custom separator", ","),
                OPT_END()
        };
        int ret = -1;

        __daemon.perf = alloc_perf_exe_path();
        if (!__daemon.perf)
                return -ENOMEM;

        __daemon.out = stdout;

        argc = parse_options(argc, argv, daemon_options, daemon_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);

        if (argc) {
                if (!strcmp(argv[0], "start"))
                        ret = __cmd_start(&__daemon, daemon_options, argc, argv);
                else if (!strcmp(argv[0], "signal"))
                        ret = __cmd_signal(&__daemon, daemon_options, argc, argv);
                else if (!strcmp(argv[0], "stop"))
                        ret = __cmd_stop(&__daemon, daemon_options, argc, argv);
                else if (!strcmp(argv[0], "ping"))
                        ret = __cmd_ping(&__daemon, daemon_options, argc, argv);
                else
                        pr_err("failed: unknown command '%s'\n", argv[0]);
        } else {
                ret = setup_config(&__daemon);
                if (ret)
                        pr_err("failed: config not found\n");
                else
                        ret = send_cmd_list(&__daemon);
        }
        zfree(&__daemon.perf);
        return ret;
}