// 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': %s\n",
daemon->base, strerror(errno));
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: %d (%s)\n",
errno, control_path);
goto out;
}
if (!do_ack)
goto out;
/* wait for an ack */
pollfd.fd = ack;
if (!poll(&pollfd, 1, 2000)) {
pr_err("failed: control ack timeout\n");
goto out;
}
if (!(pollfd.revents & POLLIN)) {
pr_err("failed: did not received an ack\n");
goto out;
}
err = read(ack, buf, sizeof(buf));
if (err > 0)
ret = strcmp(buf, "ack\n");
else
perror("failed: read ack %d\n");
out:
if (ack != -1)
close(ack);
close(control);
return ret;
}
static int setup_server_socket(struct daemon *daemon)
{
struct sockaddr_un addr;
char path[PATH_MAX];
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
fprintf(stderr, "socket: %s\n", strerror(errno));
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;
}
Codebase Browser
linux