1d450bc50SJiri Olsa // SPDX-License-Identifier: GPL-2.0
2ed36b704SJiri Olsa #include <internal/lib.h>
3d450bc50SJiri Olsa #include <subcmd/parse-options.h>
4ed36b704SJiri Olsa #include <api/fd/array.h>
58c98be6cSJiri Olsa #include <api/fs/fs.h>
6c0666261SJiri Olsa #include <linux/zalloc.h>
7c0666261SJiri Olsa #include <linux/string.h>
8d450bc50SJiri Olsa #include <linux/limits.h>
9d450bc50SJiri Olsa #include <string.h>
108c98be6cSJiri Olsa #include <sys/file.h>
11d450bc50SJiri Olsa #include <signal.h>
12fc1dcb1eSJiri Olsa #include <stdlib.h>
1312c1a415SJiri Olsa #include <time.h>
14d450bc50SJiri Olsa #include <stdio.h>
15d450bc50SJiri Olsa #include <unistd.h>
165631d100SJiri Olsa #include <errno.h>
173cda0625SJiri Olsa #include <sys/inotify.h>
183cda0625SJiri Olsa #include <libgen.h>
19ed36b704SJiri Olsa #include <sys/types.h>
20ed36b704SJiri Olsa #include <sys/socket.h>
21ed36b704SJiri Olsa #include <sys/un.h>
2290b0aad8SJiri Olsa #include <sys/stat.h>
2312c1a415SJiri Olsa #include <sys/signalfd.h>
2412c1a415SJiri Olsa #include <sys/wait.h>
25ed36b704SJiri Olsa #include <poll.h>
26d450bc50SJiri Olsa #include "builtin.h"
27d450bc50SJiri Olsa #include "perf.h"
28d450bc50SJiri Olsa #include "debug.h"
29fc1dcb1eSJiri Olsa #include "config.h"
30d450bc50SJiri Olsa #include "util.h"
31d450bc50SJiri Olsa
32c0666261SJiri Olsa #define SESSION_OUTPUT "output"
336a6d1804SJiri Olsa #define SESSION_CONTROL "control"
346a6d1804SJiri Olsa #define SESSION_ACK "ack"
35c0666261SJiri Olsa
36c0666261SJiri Olsa /*
37c0666261SJiri Olsa * Session states:
38c0666261SJiri Olsa *
39c0666261SJiri Olsa * OK - session is up and running
40c0666261SJiri Olsa * RECONFIG - session is pending for reconfiguration,
41c0666261SJiri Olsa * new values are already loaded in session object
42c0666261SJiri Olsa * KILL - session is pending to be killed
43c0666261SJiri Olsa *
44c0666261SJiri Olsa * Session object life and its state is maintained by
45c0666261SJiri Olsa * following functions:
46c0666261SJiri Olsa *
47c0666261SJiri Olsa * setup_server_config
48c0666261SJiri Olsa * - reads config file and setup session objects
49c0666261SJiri Olsa * with following states:
50c0666261SJiri Olsa *
51c0666261SJiri Olsa * OK - no change needed
52c0666261SJiri Olsa * RECONFIG - session needs to be changed
53c0666261SJiri Olsa * (run variable changed)
54c0666261SJiri Olsa * KILL - session needs to be killed
55c0666261SJiri Olsa * (session is no longer in config file)
56c0666261SJiri Olsa *
57c0666261SJiri Olsa * daemon__reconfig
58c0666261SJiri Olsa * - scans session objects and does following actions
59c0666261SJiri Olsa * for states:
60c0666261SJiri Olsa *
61c0666261SJiri Olsa * OK - skip
62c0666261SJiri Olsa * RECONFIG - session is killed and re-run with new config
63c0666261SJiri Olsa * KILL - session is killed
64c0666261SJiri Olsa *
65c0666261SJiri Olsa * - all sessions have OK state on the function exit
66c0666261SJiri Olsa */
67c0666261SJiri Olsa enum daemon_session_state {
68c0666261SJiri Olsa OK,
69c0666261SJiri Olsa RECONFIG,
70c0666261SJiri Olsa KILL,
71c0666261SJiri Olsa };
72c0666261SJiri Olsa
73c0666261SJiri Olsa struct daemon_session {
74c0666261SJiri Olsa char *base;
75c0666261SJiri Olsa char *name;
76c0666261SJiri Olsa char *run;
776a6d1804SJiri Olsa char *control;
78c0666261SJiri Olsa int pid;
79c0666261SJiri Olsa struct list_head list;
80c0666261SJiri Olsa enum daemon_session_state state;
815bdee4f0SJiri Olsa time_t start;
82c0666261SJiri Olsa };
83c0666261SJiri Olsa
84d450bc50SJiri Olsa struct daemon {
85fc1dcb1eSJiri Olsa const char *config;
86fc1dcb1eSJiri Olsa char *config_real;
873cda0625SJiri Olsa char *config_base;
88b325f7beSJiri Olsa const char *csv_sep;
895631d100SJiri Olsa const char *base_user;
90d450bc50SJiri Olsa char *base;
91c0666261SJiri Olsa struct list_head sessions;
92d450bc50SJiri Olsa FILE *out;
9392294b90SIan Rogers char *perf;
9412c1a415SJiri Olsa int signal_fd;
955bdee4f0SJiri Olsa time_t start;
96d450bc50SJiri Olsa };
97d450bc50SJiri Olsa
98c0666261SJiri Olsa static struct daemon __daemon = {
99c0666261SJiri Olsa .sessions = LIST_HEAD_INIT(__daemon.sessions),
100c0666261SJiri Olsa };
101d450bc50SJiri Olsa
102d450bc50SJiri Olsa static const char * const daemon_usage[] = {
103a87edbecSYang Jihong "perf daemon {start|signal|stop|ping} [<options>]",
104d450bc50SJiri Olsa "perf daemon [<options>]",
105d450bc50SJiri Olsa NULL
106d450bc50SJiri Olsa };
107d450bc50SJiri Olsa
1087f337429SIan Rogers static volatile sig_atomic_t done;
109d450bc50SJiri Olsa
sig_handler(int sig __maybe_unused)110d450bc50SJiri Olsa static void sig_handler(int sig __maybe_unused)
111d450bc50SJiri Olsa {
112d450bc50SJiri Olsa done = true;
113d450bc50SJiri Olsa }
114d450bc50SJiri Olsa
daemon__add_session(struct daemon * config,char * name)115c0666261SJiri Olsa static struct daemon_session *daemon__add_session(struct daemon *config, char *name)
116c0666261SJiri Olsa {
117c0666261SJiri Olsa struct daemon_session *session = zalloc(sizeof(*session));
118c0666261SJiri Olsa
119c0666261SJiri Olsa if (!session)
120c0666261SJiri Olsa return NULL;
121c0666261SJiri Olsa
122c0666261SJiri Olsa session->name = strdup(name);
123c0666261SJiri Olsa if (!session->name) {
124c0666261SJiri Olsa free(session);
125c0666261SJiri Olsa return NULL;
126c0666261SJiri Olsa }
127c0666261SJiri Olsa
128c0666261SJiri Olsa session->pid = -1;
129c0666261SJiri Olsa list_add_tail(&session->list, &config->sessions);
130c0666261SJiri Olsa return session;
131c0666261SJiri Olsa }
132c0666261SJiri Olsa
daemon__find_session(struct daemon * daemon,char * name)133c0666261SJiri Olsa static struct daemon_session *daemon__find_session(struct daemon *daemon, char *name)
134c0666261SJiri Olsa {
135c0666261SJiri Olsa struct daemon_session *session;
136c0666261SJiri Olsa
137c0666261SJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
138c0666261SJiri Olsa if (!strcmp(session->name, name))
139c0666261SJiri Olsa return session;
140c0666261SJiri Olsa }
141c0666261SJiri Olsa
142c0666261SJiri Olsa return NULL;
143c0666261SJiri Olsa }
144c0666261SJiri Olsa
get_session_name(const char * var,char * session,int len)145c0666261SJiri Olsa static int get_session_name(const char *var, char *session, int len)
146c0666261SJiri Olsa {
147c0666261SJiri Olsa const char *p = var + sizeof("session-") - 1;
148c0666261SJiri Olsa
149c0666261SJiri Olsa while (*p != '.' && *p != 0x0 && len--)
150c0666261SJiri Olsa *session++ = *p++;
151c0666261SJiri Olsa
152c0666261SJiri Olsa *session = 0;
153c0666261SJiri Olsa return *p == '.' ? 0 : -EINVAL;
154c0666261SJiri Olsa }
155c0666261SJiri Olsa
session_config(struct daemon * daemon,const char * var,const char * value)156c0666261SJiri Olsa static int session_config(struct daemon *daemon, const char *var, const char *value)
157c0666261SJiri Olsa {
158c0666261SJiri Olsa struct daemon_session *session;
159c0666261SJiri Olsa char name[100];
160c0666261SJiri Olsa
161bd57a9f3SNamhyung Kim if (get_session_name(var, name, sizeof(name) - 1))
162c0666261SJiri Olsa return -EINVAL;
163c0666261SJiri Olsa
164c0666261SJiri Olsa var = strchr(var, '.');
165c0666261SJiri Olsa if (!var)
166c0666261SJiri Olsa return -EINVAL;
167c0666261SJiri Olsa
168c0666261SJiri Olsa var++;
169c0666261SJiri Olsa
170c0666261SJiri Olsa session = daemon__find_session(daemon, name);
171c0666261SJiri Olsa
172c0666261SJiri Olsa if (!session) {
173c0666261SJiri Olsa /* New session is defined. */
174c0666261SJiri Olsa session = daemon__add_session(daemon, name);
175c0666261SJiri Olsa if (!session)
176c0666261SJiri Olsa return -ENOMEM;
177c0666261SJiri Olsa
178c0666261SJiri Olsa pr_debug("reconfig: found new session %s\n", name);
179c0666261SJiri Olsa
180c0666261SJiri Olsa /* Trigger reconfig to start it. */
181c0666261SJiri Olsa session->state = RECONFIG;
182c0666261SJiri Olsa } else if (session->state == KILL) {
183c0666261SJiri Olsa /* Current session is defined, no action needed. */
184c0666261SJiri Olsa pr_debug("reconfig: found current session %s\n", name);
185c0666261SJiri Olsa session->state = OK;
186c0666261SJiri Olsa }
187c0666261SJiri Olsa
188c0666261SJiri Olsa if (!strcmp(var, "run")) {
189c0666261SJiri Olsa bool same = false;
190c0666261SJiri Olsa
191c0666261SJiri Olsa if (session->run)
192c0666261SJiri Olsa same = !strcmp(session->run, value);
193c0666261SJiri Olsa
194c0666261SJiri Olsa if (!same) {
195c0666261SJiri Olsa if (session->run) {
196789eae7fSArnaldo Carvalho de Melo zfree(&session->run);
197c0666261SJiri Olsa pr_debug("reconfig: session %s is changed\n", name);
198c0666261SJiri Olsa }
199c0666261SJiri Olsa
200c0666261SJiri Olsa session->run = strdup(value);
201c0666261SJiri Olsa if (!session->run)
202c0666261SJiri Olsa return -ENOMEM;
203c0666261SJiri Olsa
204c0666261SJiri Olsa /*
205c0666261SJiri Olsa * Either new or changed run value is defined,
206c0666261SJiri Olsa * trigger reconfig for the session.
207c0666261SJiri Olsa */
208c0666261SJiri Olsa session->state = RECONFIG;
209c0666261SJiri Olsa }
210c0666261SJiri Olsa }
211c0666261SJiri Olsa
212c0666261SJiri Olsa return 0;
213c0666261SJiri Olsa }
214c0666261SJiri Olsa
server_config(const char * var,const char * value,void * cb)215c0666261SJiri Olsa static int server_config(const char *var, const char *value, void *cb)
216c0666261SJiri Olsa {
217c0666261SJiri Olsa struct daemon *daemon = cb;
218c0666261SJiri Olsa
219c0666261SJiri Olsa if (strstarts(var, "session-")) {
220c0666261SJiri Olsa return session_config(daemon, var, value);
221c0666261SJiri Olsa } else if (!strcmp(var, "daemon.base") && !daemon->base_user) {
222c0666261SJiri Olsa if (daemon->base && strcmp(daemon->base, value)) {
223c0666261SJiri Olsa pr_err("failed: can't redefine base, bailing out\n");
224c0666261SJiri Olsa return -EINVAL;
225c0666261SJiri Olsa }
226c0666261SJiri Olsa daemon->base = strdup(value);
227c0666261SJiri Olsa if (!daemon->base)
228c0666261SJiri Olsa return -ENOMEM;
229c0666261SJiri Olsa }
230c0666261SJiri Olsa
231c0666261SJiri Olsa return 0;
232c0666261SJiri Olsa }
233c0666261SJiri Olsa
client_config(const char * var,const char * value,void * cb)23490b0aad8SJiri Olsa static int client_config(const char *var, const char *value, void *cb)
23590b0aad8SJiri Olsa {
23690b0aad8SJiri Olsa struct daemon *daemon = cb;
23790b0aad8SJiri Olsa
23890b0aad8SJiri Olsa if (!strcmp(var, "daemon.base") && !daemon->base_user) {
23990b0aad8SJiri Olsa daemon->base = strdup(value);
24090b0aad8SJiri Olsa if (!daemon->base)
24190b0aad8SJiri Olsa return -ENOMEM;
24290b0aad8SJiri Olsa }
24390b0aad8SJiri Olsa
24490b0aad8SJiri Olsa return 0;
24590b0aad8SJiri Olsa }
24690b0aad8SJiri Olsa
check_base(struct daemon * daemon)24790b0aad8SJiri Olsa static int check_base(struct daemon *daemon)
24890b0aad8SJiri Olsa {
24990b0aad8SJiri Olsa struct stat st;
25090b0aad8SJiri Olsa
25190b0aad8SJiri Olsa if (!daemon->base) {
25290b0aad8SJiri Olsa pr_err("failed: base not defined\n");
25390b0aad8SJiri Olsa return -EINVAL;
25490b0aad8SJiri Olsa }
25590b0aad8SJiri Olsa
25690b0aad8SJiri Olsa if (stat(daemon->base, &st)) {
25790b0aad8SJiri Olsa switch (errno) {
25890b0aad8SJiri Olsa case EACCES:
25990b0aad8SJiri Olsa pr_err("failed: permission denied for '%s' base\n",
26090b0aad8SJiri Olsa daemon->base);
26190b0aad8SJiri Olsa return -EACCES;
26290b0aad8SJiri Olsa case ENOENT:
26390b0aad8SJiri Olsa pr_err("failed: base '%s' does not exists\n",
26490b0aad8SJiri Olsa daemon->base);
26590b0aad8SJiri Olsa return -EACCES;
26690b0aad8SJiri Olsa default:
26790b0aad8SJiri Olsa pr_err("failed: can't access base '%s': %s\n",
26890b0aad8SJiri Olsa daemon->base, strerror(errno));
26990b0aad8SJiri Olsa return -errno;
27090b0aad8SJiri Olsa }
27190b0aad8SJiri Olsa }
27290b0aad8SJiri Olsa
27390b0aad8SJiri Olsa if ((st.st_mode & S_IFMT) != S_IFDIR) {
27490b0aad8SJiri Olsa pr_err("failed: base '%s' is not directory\n",
27590b0aad8SJiri Olsa daemon->base);
27690b0aad8SJiri Olsa return -EINVAL;
27790b0aad8SJiri Olsa }
27890b0aad8SJiri Olsa
27990b0aad8SJiri Olsa return 0;
28090b0aad8SJiri Olsa }
28190b0aad8SJiri Olsa
setup_client_config(struct daemon * daemon)28290b0aad8SJiri Olsa static int setup_client_config(struct daemon *daemon)
28390b0aad8SJiri Olsa {
28490b0aad8SJiri Olsa struct perf_config_set *set = perf_config_set__load_file(daemon->config_real);
28590b0aad8SJiri Olsa int err = -ENOMEM;
28690b0aad8SJiri Olsa
28790b0aad8SJiri Olsa if (set) {
28890b0aad8SJiri Olsa err = perf_config_set(set, client_config, daemon);
28990b0aad8SJiri Olsa perf_config_set__delete(set);
29090b0aad8SJiri Olsa }
29190b0aad8SJiri Olsa
29290b0aad8SJiri Olsa return err ?: check_base(daemon);
29390b0aad8SJiri Olsa }
29490b0aad8SJiri Olsa
setup_server_config(struct daemon * daemon)295c0666261SJiri Olsa static int setup_server_config(struct daemon *daemon)
296c0666261SJiri Olsa {
297c0666261SJiri Olsa struct perf_config_set *set;
298c0666261SJiri Olsa struct daemon_session *session;
299c0666261SJiri Olsa int err = -ENOMEM;
300c0666261SJiri Olsa
301c0666261SJiri Olsa pr_debug("reconfig: started\n");
302c0666261SJiri Olsa
303c0666261SJiri Olsa /*
304c0666261SJiri Olsa * Mark all sessions for kill, the server config
305c0666261SJiri Olsa * will set following states, see explanation at
306c0666261SJiri Olsa * enum daemon_session_state declaration.
307c0666261SJiri Olsa */
308c0666261SJiri Olsa list_for_each_entry(session, &daemon->sessions, list)
309c0666261SJiri Olsa session->state = KILL;
310c0666261SJiri Olsa
311c0666261SJiri Olsa set = perf_config_set__load_file(daemon->config_real);
312c0666261SJiri Olsa if (set) {
313c0666261SJiri Olsa err = perf_config_set(set, server_config, daemon);
314c0666261SJiri Olsa perf_config_set__delete(set);
315c0666261SJiri Olsa }
316c0666261SJiri Olsa
317c0666261SJiri Olsa return err ?: check_base(daemon);
318c0666261SJiri Olsa }
319c0666261SJiri Olsa
daemon_session__run(struct daemon_session * session,struct daemon * daemon)320c0666261SJiri Olsa static int daemon_session__run(struct daemon_session *session,
321c0666261SJiri Olsa struct daemon *daemon)
322c0666261SJiri Olsa {
323c0666261SJiri Olsa char buf[PATH_MAX];
324c0666261SJiri Olsa char **argv;
325c0666261SJiri Olsa int argc, fd;
326c0666261SJiri Olsa
327c0666261SJiri Olsa if (asprintf(&session->base, "%s/session-%s",
328c0666261SJiri Olsa daemon->base, session->name) < 0) {
329c0666261SJiri Olsa perror("failed: asprintf");
330c0666261SJiri Olsa return -1;
331c0666261SJiri Olsa }
332c0666261SJiri Olsa
333c0666261SJiri Olsa if (mkdir(session->base, 0755) && errno != EEXIST) {
334c0666261SJiri Olsa perror("failed: mkdir");
335c0666261SJiri Olsa return -1;
336c0666261SJiri Olsa }
337c0666261SJiri Olsa
3385bdee4f0SJiri Olsa session->start = time(NULL);
3395bdee4f0SJiri Olsa
340c0666261SJiri Olsa session->pid = fork();
341c0666261SJiri Olsa if (session->pid < 0)
342c0666261SJiri Olsa return -1;
343c0666261SJiri Olsa if (session->pid > 0) {
344c0666261SJiri Olsa pr_info("reconfig: ruining session [%s:%d]: %s\n",
345c0666261SJiri Olsa session->name, session->pid, session->run);
346c0666261SJiri Olsa return 0;
347c0666261SJiri Olsa }
348c0666261SJiri Olsa
349c0666261SJiri Olsa if (chdir(session->base)) {
350c0666261SJiri Olsa perror("failed: chdir");
351c0666261SJiri Olsa return -1;
352c0666261SJiri Olsa }
353c0666261SJiri Olsa
354c0666261SJiri Olsa fd = open("/dev/null", O_RDONLY);
355c0666261SJiri Olsa if (fd < 0) {
356c0666261SJiri Olsa perror("failed: open /dev/null");
357c0666261SJiri Olsa return -1;
358c0666261SJiri Olsa }
359c0666261SJiri Olsa
360c0666261SJiri Olsa dup2(fd, 0);
361c0666261SJiri Olsa close(fd);
362c0666261SJiri Olsa
363c0666261SJiri Olsa fd = open(SESSION_OUTPUT, O_RDWR|O_CREAT|O_TRUNC, 0644);
364c0666261SJiri Olsa if (fd < 0) {
365c0666261SJiri Olsa perror("failed: open session output");
366c0666261SJiri Olsa return -1;
367c0666261SJiri Olsa }
368c0666261SJiri Olsa
369c0666261SJiri Olsa dup2(fd, 1);
370c0666261SJiri Olsa dup2(fd, 2);
371c0666261SJiri Olsa close(fd);
372c0666261SJiri Olsa
37331bf4e7cSJiri Olsa if (mkfifo(SESSION_CONTROL, 0600) && errno != EEXIST) {
3746a6d1804SJiri Olsa perror("failed: create control fifo");
3756a6d1804SJiri Olsa return -1;
3766a6d1804SJiri Olsa }
3776a6d1804SJiri Olsa
37831bf4e7cSJiri Olsa if (mkfifo(SESSION_ACK, 0600) && errno != EEXIST) {
3796a6d1804SJiri Olsa perror("failed: create ack fifo");
3806a6d1804SJiri Olsa return -1;
3816a6d1804SJiri Olsa }
3826a6d1804SJiri Olsa
3836a6d1804SJiri Olsa scnprintf(buf, sizeof(buf), "%s record --control=fifo:%s,%s %s",
3846a6d1804SJiri Olsa daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);
385c0666261SJiri Olsa
386c0666261SJiri Olsa argv = argv_split(buf, &argc);
387c0666261SJiri Olsa if (!argv)
388c0666261SJiri Olsa exit(-1);
389c0666261SJiri Olsa
390c0666261SJiri Olsa exit(execve(daemon->perf, argv, NULL));
391c0666261SJiri Olsa return -1;
392c0666261SJiri Olsa }
393c0666261SJiri Olsa
handle_signalfd(struct daemon * daemon)39412c1a415SJiri Olsa static pid_t handle_signalfd(struct daemon *daemon)
39512c1a415SJiri Olsa {
39612c1a415SJiri Olsa struct daemon_session *session;
39712c1a415SJiri Olsa struct signalfd_siginfo si;
39812c1a415SJiri Olsa ssize_t err;
39912c1a415SJiri Olsa int status;
40012c1a415SJiri Olsa pid_t pid;
40112c1a415SJiri Olsa
4021833b64fSJiri Olsa /*
4031833b64fSJiri Olsa * Take signal fd data as pure signal notification and check all
4041833b64fSJiri Olsa * the sessions state. The reason is that multiple signals can get
4051833b64fSJiri Olsa * coalesced in kernel and we can receive only single signal even
4061833b64fSJiri Olsa * if multiple SIGCHLD were generated.
4071833b64fSJiri Olsa */
40812c1a415SJiri Olsa err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
4091833b64fSJiri Olsa if (err != sizeof(struct signalfd_siginfo)) {
4101833b64fSJiri Olsa pr_err("failed to read signal fd\n");
41112c1a415SJiri Olsa return -1;
4121833b64fSJiri Olsa }
41312c1a415SJiri Olsa
41412c1a415SJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
4151833b64fSJiri Olsa if (session->pid == -1)
41612c1a415SJiri Olsa continue;
41712c1a415SJiri Olsa
4181833b64fSJiri Olsa pid = waitpid(session->pid, &status, WNOHANG);
4191833b64fSJiri Olsa if (pid <= 0)
4201833b64fSJiri Olsa continue;
4211833b64fSJiri Olsa
42212c1a415SJiri Olsa if (WIFEXITED(status)) {
42312c1a415SJiri Olsa pr_info("session '%s' exited, status=%d\n",
42412c1a415SJiri Olsa session->name, WEXITSTATUS(status));
42512c1a415SJiri Olsa } else if (WIFSIGNALED(status)) {
42612c1a415SJiri Olsa pr_info("session '%s' killed (signal %d)\n",
42712c1a415SJiri Olsa session->name, WTERMSIG(status));
42812c1a415SJiri Olsa } else if (WIFSTOPPED(status)) {
42912c1a415SJiri Olsa pr_info("session '%s' stopped (signal %d)\n",
43012c1a415SJiri Olsa session->name, WSTOPSIG(status));
43112c1a415SJiri Olsa } else {
43212c1a415SJiri Olsa pr_info("session '%s' Unexpected status (0x%x)\n",
43312c1a415SJiri Olsa session->name, status);
43412c1a415SJiri Olsa }
43512c1a415SJiri Olsa
43612c1a415SJiri Olsa session->state = KILL;
43712c1a415SJiri Olsa session->pid = -1;
43812c1a415SJiri Olsa }
43912c1a415SJiri Olsa
44012c1a415SJiri Olsa return 0;
44112c1a415SJiri Olsa }
44212c1a415SJiri Olsa
daemon_session__wait(struct daemon_session * session,struct daemon * daemon,int secs)44312c1a415SJiri Olsa static int daemon_session__wait(struct daemon_session *session, struct daemon *daemon,
44412c1a415SJiri Olsa int secs)
44512c1a415SJiri Olsa {
44612c1a415SJiri Olsa struct pollfd pollfd = {
44712c1a415SJiri Olsa .fd = daemon->signal_fd,
44812c1a415SJiri Olsa .events = POLLIN,
44912c1a415SJiri Olsa };
45012c1a415SJiri Olsa time_t start;
45112c1a415SJiri Olsa
45212c1a415SJiri Olsa start = time(NULL);
45312c1a415SJiri Olsa
45412c1a415SJiri Olsa do {
45512c1a415SJiri Olsa int err = poll(&pollfd, 1, 1000);
45612c1a415SJiri Olsa
45712c1a415SJiri Olsa if (err > 0) {
4581833b64fSJiri Olsa handle_signalfd(daemon);
45912c1a415SJiri Olsa } else if (err < 0) {
46012c1a415SJiri Olsa perror("failed: poll\n");
46112c1a415SJiri Olsa return -1;
46212c1a415SJiri Olsa }
46312c1a415SJiri Olsa
46412c1a415SJiri Olsa if (start + secs < time(NULL))
46512c1a415SJiri Olsa return -1;
4661833b64fSJiri Olsa } while (session->pid != -1);
46712c1a415SJiri Olsa
46812c1a415SJiri Olsa return 0;
46912c1a415SJiri Olsa }
47012c1a415SJiri Olsa
daemon__has_alive_session(struct daemon * daemon)47112c1a415SJiri Olsa static bool daemon__has_alive_session(struct daemon *daemon)
47212c1a415SJiri Olsa {
47312c1a415SJiri Olsa struct daemon_session *session;
47412c1a415SJiri Olsa
47512c1a415SJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
47612c1a415SJiri Olsa if (session->pid != -1)
47712c1a415SJiri Olsa return true;
47812c1a415SJiri Olsa }
47912c1a415SJiri Olsa
48012c1a415SJiri Olsa return false;
48112c1a415SJiri Olsa }
48212c1a415SJiri Olsa
daemon__wait(struct daemon * daemon,int secs)48312c1a415SJiri Olsa static int daemon__wait(struct daemon *daemon, int secs)
48412c1a415SJiri Olsa {
48512c1a415SJiri Olsa struct pollfd pollfd = {
48612c1a415SJiri Olsa .fd = daemon->signal_fd,
48712c1a415SJiri Olsa .events = POLLIN,
48812c1a415SJiri Olsa };
48912c1a415SJiri Olsa time_t start;
49012c1a415SJiri Olsa
49112c1a415SJiri Olsa start = time(NULL);
49212c1a415SJiri Olsa
49312c1a415SJiri Olsa do {
49412c1a415SJiri Olsa int err = poll(&pollfd, 1, 1000);
49512c1a415SJiri Olsa
49612c1a415SJiri Olsa if (err > 0) {
49712c1a415SJiri Olsa handle_signalfd(daemon);
49812c1a415SJiri Olsa } else if (err < 0) {
49912c1a415SJiri Olsa perror("failed: poll\n");
50012c1a415SJiri Olsa return -1;
50112c1a415SJiri Olsa }
50212c1a415SJiri Olsa
50312c1a415SJiri Olsa if (start + secs < time(NULL))
50412c1a415SJiri Olsa return -1;
50512c1a415SJiri Olsa } while (daemon__has_alive_session(daemon));
50612c1a415SJiri Olsa
50712c1a415SJiri Olsa return 0;
50812c1a415SJiri Olsa }
50912c1a415SJiri Olsa
daemon_session__control(struct daemon_session * session,const char * msg,bool do_ack)510edcaa479SJiri Olsa static int daemon_session__control(struct daemon_session *session,
511edcaa479SJiri Olsa const char *msg, bool do_ack)
512edcaa479SJiri Olsa {
513edcaa479SJiri Olsa struct pollfd pollfd = { .events = POLLIN, };
514edcaa479SJiri Olsa char control_path[PATH_MAX];
515edcaa479SJiri Olsa char ack_path[PATH_MAX];
516edcaa479SJiri Olsa int control, ack = -1, len;
517edcaa479SJiri Olsa char buf[20];
518edcaa479SJiri Olsa int ret = -1;
519edcaa479SJiri Olsa ssize_t err;
520edcaa479SJiri Olsa
521edcaa479SJiri Olsa /* open the control file */
522edcaa479SJiri Olsa scnprintf(control_path, sizeof(control_path), "%s/%s",
523edcaa479SJiri Olsa session->base, SESSION_CONTROL);
524edcaa479SJiri Olsa
525edcaa479SJiri Olsa control = open(control_path, O_WRONLY|O_NONBLOCK);
526edcaa479SJiri Olsa if (!control)
527edcaa479SJiri Olsa return -1;
528edcaa479SJiri Olsa
529edcaa479SJiri Olsa if (do_ack) {
530edcaa479SJiri Olsa /* open the ack file */
531edcaa479SJiri Olsa scnprintf(ack_path, sizeof(ack_path), "%s/%s",
532edcaa479SJiri Olsa session->base, SESSION_ACK);
533edcaa479SJiri Olsa
534edcaa479SJiri Olsa ack = open(ack_path, O_RDONLY, O_NONBLOCK);
535edcaa479SJiri Olsa if (!ack) {
536edcaa479SJiri Olsa close(control);
537edcaa479SJiri Olsa return -1;
538edcaa479SJiri Olsa }
539edcaa479SJiri Olsa }
540edcaa479SJiri Olsa
541edcaa479SJiri Olsa /* write the command */
542edcaa479SJiri Olsa len = strlen(msg);
543edcaa479SJiri Olsa
544edcaa479SJiri Olsa err = writen(control, msg, len);
545edcaa479SJiri Olsa if (err != len) {
546edcaa479SJiri Olsa pr_err("failed: write to control pipe: %d (%s)\n",
547edcaa479SJiri Olsa errno, control_path);
548edcaa479SJiri Olsa goto out;
549edcaa479SJiri Olsa }
550edcaa479SJiri Olsa
551edcaa479SJiri Olsa if (!do_ack)
552edcaa479SJiri Olsa goto out;
553edcaa479SJiri Olsa
554edcaa479SJiri Olsa /* wait for an ack */
555edcaa479SJiri Olsa pollfd.fd = ack;
556edcaa479SJiri Olsa
557edcaa479SJiri Olsa if (!poll(&pollfd, 1, 2000)) {
558edcaa479SJiri Olsa pr_err("failed: control ack timeout\n");
559edcaa479SJiri Olsa goto out;
560edcaa479SJiri Olsa }
561edcaa479SJiri Olsa
562edcaa479SJiri Olsa if (!(pollfd.revents & POLLIN)) {
563edcaa479SJiri Olsa pr_err("failed: did not received an ack\n");
564edcaa479SJiri Olsa goto out;
565edcaa479SJiri Olsa }
566edcaa479SJiri Olsa
567edcaa479SJiri Olsa err = read(ack, buf, sizeof(buf));
568edcaa479SJiri Olsa if (err > 0)
569edcaa479SJiri Olsa ret = strcmp(buf, "ack\n");
570edcaa479SJiri Olsa else
571edcaa479SJiri Olsa perror("failed: read ack %d\n");
572edcaa479SJiri Olsa
573edcaa479SJiri Olsa out:
574edcaa479SJiri Olsa if (ack != -1)
575edcaa479SJiri Olsa close(ack);
576edcaa479SJiri Olsa
577edcaa479SJiri Olsa close(control);
578edcaa479SJiri Olsa return ret;
579edcaa479SJiri Olsa }
580edcaa479SJiri Olsa
setup_server_socket(struct daemon * daemon)581ed36b704SJiri Olsa static int setup_server_socket(struct daemon *daemon)
582ed36b704SJiri Olsa {
583ed36b704SJiri Olsa struct sockaddr_un addr;
584ed36b704SJiri Olsa char path[PATH_MAX];
585ed36b704SJiri Olsa int fd = socket(AF_UNIX, SOCK_STREAM, 0);
586ed36b704SJiri Olsa
587ed36b704SJiri Olsa if (fd < 0) {
588ed36b704SJiri Olsa fprintf(stderr, "socket: %s\n", strerror(errno));
589ed36b704SJiri Olsa return -1;
590ed36b704SJiri Olsa }
591ed36b704SJiri Olsa
592ed36b704SJiri Olsa if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
593ed36b704SJiri Olsa perror("failed: fcntl FD_CLOEXEC");
594ed36b704SJiri Olsa close(fd);
595ed36b704SJiri Olsa return -1;
596ed36b704SJiri Olsa }
597ed36b704SJiri Olsa
598ed36b704SJiri Olsa scnprintf(path, sizeof(path), "%s/control", daemon->base);
599ed36b704SJiri Olsa
600ed36b704SJiri Olsa if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
601ed36b704SJiri Olsa pr_err("failed: control path too long '%s'\n", path);
602ed36b704SJiri Olsa close(fd);
603ed36b704SJiri Olsa return -1;
604ed36b704SJiri Olsa }
605ed36b704SJiri Olsa
606ed36b704SJiri Olsa memset(&addr, 0, sizeof(addr));
607ed36b704SJiri Olsa addr.sun_family = AF_UNIX;
608ed36b704SJiri Olsa
609ed36b704SJiri Olsa strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
610ed36b704SJiri Olsa unlink(path);
611ed36b704SJiri Olsa
612ed36b704SJiri Olsa if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
613ed36b704SJiri Olsa perror("failed: bind");
614ed36b704SJiri Olsa close(fd);
615ed36b704SJiri Olsa return -1;
616ed36b704SJiri Olsa }
617ed36b704SJiri Olsa
618ed36b704SJiri Olsa if (listen(fd, 1) == -1) {
619ed36b704SJiri Olsa perror("failed: listen");
620ed36b704SJiri Olsa close(fd);
621ed36b704SJiri Olsa return -1;
622ed36b704SJiri Olsa }
623ed36b704SJiri Olsa
624ed36b704SJiri Olsa return fd;
625ed36b704SJiri Olsa }
626ed36b704SJiri Olsa
627b325f7beSJiri Olsa enum {
628b325f7beSJiri Olsa CMD_LIST = 0,
6292d6914cdSJiri Olsa CMD_SIGNAL = 1,
63023c5831eSJiri Olsa CMD_STOP = 2,
631edcaa479SJiri Olsa CMD_PING = 3,
632b325f7beSJiri Olsa CMD_MAX,
633ed36b704SJiri Olsa };
634ed36b704SJiri Olsa
6352d6914cdSJiri Olsa #define SESSION_MAX 64
6362d6914cdSJiri Olsa
637b325f7beSJiri Olsa union cmd {
638b325f7beSJiri Olsa int cmd;
639b325f7beSJiri Olsa
640b325f7beSJiri Olsa /* CMD_LIST */
641b325f7beSJiri Olsa struct {
642b325f7beSJiri Olsa int cmd;
643b325f7beSJiri Olsa int verbose;
644b325f7beSJiri Olsa char csv_sep;
645b325f7beSJiri Olsa } list;
6462d6914cdSJiri Olsa
6472d6914cdSJiri Olsa /* CMD_SIGNAL */
6482d6914cdSJiri Olsa struct {
6492d6914cdSJiri Olsa int cmd;
6502d6914cdSJiri Olsa int sig;
6512d6914cdSJiri Olsa char name[SESSION_MAX];
6522d6914cdSJiri Olsa } signal;
653edcaa479SJiri Olsa
654edcaa479SJiri Olsa /* CMD_PING */
655edcaa479SJiri Olsa struct {
656edcaa479SJiri Olsa int cmd;
657edcaa479SJiri Olsa char name[SESSION_MAX];
658edcaa479SJiri Olsa } ping;
659b325f7beSJiri Olsa };
660b325f7beSJiri Olsa
661edcaa479SJiri Olsa enum {
662edcaa479SJiri Olsa PING_OK = 0,
663edcaa479SJiri Olsa PING_FAIL = 1,
664edcaa479SJiri Olsa PING_MAX,
665edcaa479SJiri Olsa };
666edcaa479SJiri Olsa
daemon_session__ping(struct daemon_session * session)667edcaa479SJiri Olsa static int daemon_session__ping(struct daemon_session *session)
668edcaa479SJiri Olsa {
669edcaa479SJiri Olsa return daemon_session__control(session, "ping", true) ? PING_FAIL : PING_OK;
670edcaa479SJiri Olsa }
671edcaa479SJiri Olsa
cmd_session_list(struct daemon * daemon,union cmd * cmd,FILE * out)672b325f7beSJiri Olsa static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
673b325f7beSJiri Olsa {
674b325f7beSJiri Olsa char csv_sep = cmd->list.csv_sep;
675b325f7beSJiri Olsa struct daemon_session *session;
6765bdee4f0SJiri Olsa time_t curr = time(NULL);
677b325f7beSJiri Olsa
678b325f7beSJiri Olsa if (csv_sep) {
679b325f7beSJiri Olsa fprintf(out, "%d%c%s%c%s%c%s/%s",
680b325f7beSJiri Olsa /* pid daemon */
681b325f7beSJiri Olsa getpid(), csv_sep, "daemon",
682b325f7beSJiri Olsa /* base */
683b325f7beSJiri Olsa csv_sep, daemon->base,
684b325f7beSJiri Olsa /* output */
685b325f7beSJiri Olsa csv_sep, daemon->base, SESSION_OUTPUT);
686b325f7beSJiri Olsa
6878c98be6cSJiri Olsa fprintf(out, "%c%s/%s",
6888c98be6cSJiri Olsa /* lock */
6898c98be6cSJiri Olsa csv_sep, daemon->base, "lock");
6908c98be6cSJiri Olsa
6915bdee4f0SJiri Olsa fprintf(out, "%c%lu",
6925bdee4f0SJiri Olsa /* session up time */
6935bdee4f0SJiri Olsa csv_sep, (curr - daemon->start) / 60);
6945bdee4f0SJiri Olsa
695b325f7beSJiri Olsa fprintf(out, "\n");
696b325f7beSJiri Olsa } else {
697b325f7beSJiri Olsa fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
698b325f7beSJiri Olsa if (cmd->list.verbose) {
699b325f7beSJiri Olsa fprintf(out, " output: %s/%s\n",
700b325f7beSJiri Olsa daemon->base, SESSION_OUTPUT);
7018c98be6cSJiri Olsa fprintf(out, " lock: %s/lock\n",
7028c98be6cSJiri Olsa daemon->base);
7035bdee4f0SJiri Olsa fprintf(out, " up: %lu minutes\n",
7045bdee4f0SJiri Olsa (curr - daemon->start) / 60);
705b325f7beSJiri Olsa }
706b325f7beSJiri Olsa }
707b325f7beSJiri Olsa
708b325f7beSJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
709b325f7beSJiri Olsa if (csv_sep) {
710b325f7beSJiri Olsa fprintf(out, "%d%c%s%c%s",
711b325f7beSJiri Olsa /* pid */
712b325f7beSJiri Olsa session->pid,
713b325f7beSJiri Olsa /* name */
714b325f7beSJiri Olsa csv_sep, session->name,
715b325f7beSJiri Olsa /* base */
716b325f7beSJiri Olsa csv_sep, session->run);
717b325f7beSJiri Olsa
718b325f7beSJiri Olsa fprintf(out, "%c%s%c%s/%s",
719b325f7beSJiri Olsa /* session dir */
720b325f7beSJiri Olsa csv_sep, session->base,
721b325f7beSJiri Olsa /* session output */
722b325f7beSJiri Olsa csv_sep, session->base, SESSION_OUTPUT);
723b325f7beSJiri Olsa
7246a6d1804SJiri Olsa fprintf(out, "%c%s/%s%c%s/%s",
7256a6d1804SJiri Olsa /* session control */
7266a6d1804SJiri Olsa csv_sep, session->base, SESSION_CONTROL,
7276a6d1804SJiri Olsa /* session ack */
7286a6d1804SJiri Olsa csv_sep, session->base, SESSION_ACK);
7296a6d1804SJiri Olsa
7305bdee4f0SJiri Olsa fprintf(out, "%c%lu",
7315bdee4f0SJiri Olsa /* session up time */
7325bdee4f0SJiri Olsa csv_sep, (curr - session->start) / 60);
7335bdee4f0SJiri Olsa
734b325f7beSJiri Olsa fprintf(out, "\n");
735b325f7beSJiri Olsa } else {
736b325f7beSJiri Olsa fprintf(out, "[%d:%s] perf record %s\n",
737b325f7beSJiri Olsa session->pid, session->name, session->run);
738b325f7beSJiri Olsa if (!cmd->list.verbose)
739b325f7beSJiri Olsa continue;
740b325f7beSJiri Olsa fprintf(out, " base: %s\n",
741b325f7beSJiri Olsa session->base);
742b325f7beSJiri Olsa fprintf(out, " output: %s/%s\n",
743b325f7beSJiri Olsa session->base, SESSION_OUTPUT);
7446a6d1804SJiri Olsa fprintf(out, " control: %s/%s\n",
7456a6d1804SJiri Olsa session->base, SESSION_CONTROL);
7466a6d1804SJiri Olsa fprintf(out, " ack: %s/%s\n",
7476a6d1804SJiri Olsa session->base, SESSION_ACK);
7485bdee4f0SJiri Olsa fprintf(out, " up: %lu minutes\n",
7495bdee4f0SJiri Olsa (curr - session->start) / 60);
750b325f7beSJiri Olsa }
751b325f7beSJiri Olsa }
752b325f7beSJiri Olsa
753b325f7beSJiri Olsa return 0;
754b325f7beSJiri Olsa }
755b325f7beSJiri Olsa
daemon_session__signal(struct daemon_session * session,int sig)7562d6914cdSJiri Olsa static int daemon_session__signal(struct daemon_session *session, int sig)
7572d6914cdSJiri Olsa {
7582d6914cdSJiri Olsa if (session->pid < 0)
7592d6914cdSJiri Olsa return -1;
7602d6914cdSJiri Olsa return kill(session->pid, sig);
7612d6914cdSJiri Olsa }
7622d6914cdSJiri Olsa
cmd_session_kill(struct daemon * daemon,union cmd * cmd,FILE * out)7632d6914cdSJiri Olsa static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
7642d6914cdSJiri Olsa {
7652d6914cdSJiri Olsa struct daemon_session *session;
7662d6914cdSJiri Olsa bool all = false;
7672d6914cdSJiri Olsa
7682d6914cdSJiri Olsa all = !strcmp(cmd->signal.name, "all");
7692d6914cdSJiri Olsa
7702d6914cdSJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
7712d6914cdSJiri Olsa if (all || !strcmp(cmd->signal.name, session->name)) {
7722d6914cdSJiri Olsa daemon_session__signal(session, cmd->signal.sig);
7732d6914cdSJiri Olsa fprintf(out, "signal %d sent to session '%s [%d]'\n",
7742d6914cdSJiri Olsa cmd->signal.sig, session->name, session->pid);
7752d6914cdSJiri Olsa }
7762d6914cdSJiri Olsa }
7772d6914cdSJiri Olsa
7782d6914cdSJiri Olsa return 0;
7792d6914cdSJiri Olsa }
7802d6914cdSJiri Olsa
781edcaa479SJiri Olsa static const char *ping_str[PING_MAX] = {
782edcaa479SJiri Olsa [PING_OK] = "OK",
783edcaa479SJiri Olsa [PING_FAIL] = "FAIL",
784edcaa479SJiri Olsa };
785edcaa479SJiri Olsa
cmd_session_ping(struct daemon * daemon,union cmd * cmd,FILE * out)786edcaa479SJiri Olsa static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
787edcaa479SJiri Olsa {
788edcaa479SJiri Olsa struct daemon_session *session;
789edcaa479SJiri Olsa bool all = false, found = false;
790edcaa479SJiri Olsa
791edcaa479SJiri Olsa all = !strcmp(cmd->ping.name, "all");
792edcaa479SJiri Olsa
793edcaa479SJiri Olsa list_for_each_entry(session, &daemon->sessions, list) {
794edcaa479SJiri Olsa if (all || !strcmp(cmd->ping.name, session->name)) {
795edcaa479SJiri Olsa int state = daemon_session__ping(session);
796edcaa479SJiri Olsa
797edcaa479SJiri Olsa fprintf(out, "%-4s %s\n", ping_str[state], session->name);
798edcaa479SJiri Olsa found = true;
799edcaa479SJiri Olsa }
800edcaa479SJiri Olsa }
801edcaa479SJiri Olsa
802edcaa479SJiri Olsa if (!found && !all) {
803edcaa479SJiri Olsa fprintf(out, "%-4s %s (not found)\n",
804edcaa479SJiri Olsa ping_str[PING_FAIL], cmd->ping.name);
805edcaa479SJiri Olsa }
806edcaa479SJiri Olsa return 0;
807edcaa479SJiri Olsa }
808edcaa479SJiri Olsa
handle_server_socket(struct daemon * daemon,int sock_fd)809b325f7beSJiri Olsa static int handle_server_socket(struct daemon *daemon, int sock_fd)
810ed36b704SJiri Olsa {
811ed36b704SJiri Olsa int ret = -1, fd;
812ed36b704SJiri Olsa FILE *out = NULL;
813ed36b704SJiri Olsa union cmd cmd;
814ed36b704SJiri Olsa
815ed36b704SJiri Olsa fd = accept(sock_fd, NULL, NULL);
816ed36b704SJiri Olsa if (fd < 0) {
817ed36b704SJiri Olsa perror("failed: accept");
818ed36b704SJiri Olsa return -1;
819ed36b704SJiri Olsa }
820ed36b704SJiri Olsa
821ed36b704SJiri Olsa if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
822ed36b704SJiri Olsa perror("failed: read");
823ed36b704SJiri Olsa goto out;
824ed36b704SJiri Olsa }
825ed36b704SJiri Olsa
826ed36b704SJiri Olsa out = fdopen(fd, "w");
827ed36b704SJiri Olsa if (!out) {
828ed36b704SJiri Olsa perror("failed: fdopen");
829ed36b704SJiri Olsa goto out;
830ed36b704SJiri Olsa }
831ed36b704SJiri Olsa
832ed36b704SJiri Olsa switch (cmd.cmd) {
833b325f7beSJiri Olsa case CMD_LIST:
834b325f7beSJiri Olsa ret = cmd_session_list(daemon, &cmd, out);
835b325f7beSJiri Olsa break;
8362d6914cdSJiri Olsa case CMD_SIGNAL:
8372d6914cdSJiri Olsa ret = cmd_session_kill(daemon, &cmd, out);
8382d6914cdSJiri Olsa break;
83923c5831eSJiri Olsa case CMD_STOP:
84023c5831eSJiri Olsa done = 1;
84123c5831eSJiri Olsa ret = 0;
84223c5831eSJiri Olsa pr_debug("perf daemon is exciting\n");
84323c5831eSJiri Olsa break;
844edcaa479SJiri Olsa case CMD_PING:
845edcaa479SJiri Olsa ret = cmd_session_ping(daemon, &cmd, out);
846edcaa479SJiri Olsa break;
847ed36b704SJiri Olsa default:
848ed36b704SJiri Olsa break;
849ed36b704SJiri Olsa }
850ed36b704SJiri Olsa
851ed36b704SJiri Olsa fclose(out);
852ed36b704SJiri Olsa out:
853ed36b704SJiri Olsa /* If out is defined, then fd is closed via fclose. */
854ed36b704SJiri Olsa if (!out)
855ed36b704SJiri Olsa close(fd);
856ed36b704SJiri Olsa return ret;
857ed36b704SJiri Olsa }
858ed36b704SJiri Olsa
setup_client_socket(struct daemon * daemon)85990b0aad8SJiri Olsa static int setup_client_socket(struct daemon *daemon)
86090b0aad8SJiri Olsa {
86190b0aad8SJiri Olsa struct sockaddr_un addr;
86290b0aad8SJiri Olsa char path[PATH_MAX];
86390b0aad8SJiri Olsa int fd = socket(AF_UNIX, SOCK_STREAM, 0);
86490b0aad8SJiri Olsa
86590b0aad8SJiri Olsa if (fd == -1) {
86690b0aad8SJiri Olsa perror("failed: socket");
86790b0aad8SJiri Olsa return -1;
86890b0aad8SJiri Olsa }
86990b0aad8SJiri Olsa
87090b0aad8SJiri Olsa scnprintf(path, sizeof(path), "%s/control", daemon->base);
87190b0aad8SJiri Olsa
87290b0aad8SJiri Olsa if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
87390b0aad8SJiri Olsa pr_err("failed: control path too long '%s'\n", path);
87490b0aad8SJiri Olsa close(fd);
87590b0aad8SJiri Olsa return -1;
87690b0aad8SJiri Olsa }
87790b0aad8SJiri Olsa
87890b0aad8SJiri Olsa memset(&addr, 0, sizeof(addr));
87990b0aad8SJiri Olsa addr.sun_family = AF_UNIX;
88090b0aad8SJiri Olsa strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
88190b0aad8SJiri Olsa
88290b0aad8SJiri Olsa if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
88390b0aad8SJiri Olsa perror("failed: connect");
88490b0aad8SJiri Olsa close(fd);
88590b0aad8SJiri Olsa return -1;
88690b0aad8SJiri Olsa }
88790b0aad8SJiri Olsa
88890b0aad8SJiri Olsa return fd;
88990b0aad8SJiri Olsa }
89090b0aad8SJiri Olsa
daemon_session__kill(struct daemon_session * session,struct daemon * daemon)89112c1a415SJiri Olsa static void daemon_session__kill(struct daemon_session *session,
89212c1a415SJiri Olsa struct daemon *daemon)
893c0666261SJiri Olsa {
8946d6162d5SJiri Olsa int how = 0;
8956d6162d5SJiri Olsa
8966d6162d5SJiri Olsa do {
8976d6162d5SJiri Olsa switch (how) {
8986d6162d5SJiri Olsa case 0:
8996d6162d5SJiri Olsa daemon_session__control(session, "stop", false);
9006d6162d5SJiri Olsa break;
9016d6162d5SJiri Olsa case 1:
902c0666261SJiri Olsa daemon_session__signal(session, SIGTERM);
9036d6162d5SJiri Olsa break;
9046d6162d5SJiri Olsa case 2:
90512c1a415SJiri Olsa daemon_session__signal(session, SIGKILL);
9066d6162d5SJiri Olsa break;
9076d6162d5SJiri Olsa default:
9089f177fd8SJiri Olsa pr_err("failed to wait for session %s\n",
9099f177fd8SJiri Olsa session->name);
9109f177fd8SJiri Olsa return;
91112c1a415SJiri Olsa }
9126d6162d5SJiri Olsa how++;
9136d6162d5SJiri Olsa
9146d6162d5SJiri Olsa } while (daemon_session__wait(session, daemon, 10));
915c0666261SJiri Olsa }
916c0666261SJiri Olsa
daemon__signal(struct daemon * daemon,int sig)917c0666261SJiri Olsa static void daemon__signal(struct daemon *daemon, int sig)
918c0666261SJiri Olsa {
919c0666261SJiri Olsa struct daemon_session *session;
920c0666261SJiri Olsa
921c0666261SJiri Olsa list_for_each_entry(session, &daemon->sessions, list)
922c0666261SJiri Olsa daemon_session__signal(session, sig);
923c0666261SJiri Olsa }
924c0666261SJiri Olsa
daemon_session__delete(struct daemon_session * session)925c0666261SJiri Olsa static void daemon_session__delete(struct daemon_session *session)
926c0666261SJiri Olsa {
927789eae7fSArnaldo Carvalho de Melo zfree(&session->base);
928789eae7fSArnaldo Carvalho de Melo zfree(&session->name);
929789eae7fSArnaldo Carvalho de Melo zfree(&session->run);
930c0666261SJiri Olsa free(session);
931c0666261SJiri Olsa }
932c0666261SJiri Olsa
daemon_session__remove(struct daemon_session * session)933c0666261SJiri Olsa static void daemon_session__remove(struct daemon_session *session)
934c0666261SJiri Olsa {
935c0666261SJiri Olsa list_del(&session->list);
936c0666261SJiri Olsa daemon_session__delete(session);
937c0666261SJiri Olsa }
938c0666261SJiri Olsa
daemon__stop(struct daemon * daemon)9396d6162d5SJiri Olsa static void daemon__stop(struct daemon *daemon)
9406d6162d5SJiri Olsa {
9416d6162d5SJiri Olsa struct daemon_session *session;
9426d6162d5SJiri Olsa
9436d6162d5SJiri Olsa list_for_each_entry(session, &daemon->sessions, list)
9446d6162d5SJiri Olsa daemon_session__control(session, "stop", false);
9456d6162d5SJiri Olsa }
9466d6162d5SJiri Olsa
daemon__kill(struct daemon * daemon)947c0666261SJiri Olsa static void daemon__kill(struct daemon *daemon)
948c0666261SJiri Olsa {
9496d6162d5SJiri Olsa int how = 0;
9506d6162d5SJiri Olsa
9516d6162d5SJiri Olsa do {
9526d6162d5SJiri Olsa switch (how) {
9536d6162d5SJiri Olsa case 0:
9546d6162d5SJiri Olsa daemon__stop(daemon);
9556d6162d5SJiri Olsa break;
9566d6162d5SJiri Olsa case 1:
957c0666261SJiri Olsa daemon__signal(daemon, SIGTERM);
9586d6162d5SJiri Olsa break;
9596d6162d5SJiri Olsa case 2:
96012c1a415SJiri Olsa daemon__signal(daemon, SIGKILL);
9616d6162d5SJiri Olsa break;
9626d6162d5SJiri Olsa default:
9639f177fd8SJiri Olsa pr_err("failed to wait for sessions\n");
9649f177fd8SJiri Olsa return;
96512c1a415SJiri Olsa }
9666d6162d5SJiri Olsa how++;
9676d6162d5SJiri Olsa
9686d6162d5SJiri Olsa } while (daemon__wait(daemon, 10));
969c0666261SJiri Olsa }
970c0666261SJiri Olsa
daemon__exit(struct daemon * daemon)971fc1dcb1eSJiri Olsa static void daemon__exit(struct daemon *daemon)
972fc1dcb1eSJiri Olsa {
973c0666261SJiri Olsa struct daemon_session *session, *h;
974c0666261SJiri Olsa
975c0666261SJiri Olsa list_for_each_entry_safe(session, h, &daemon->sessions, list)
976c0666261SJiri Olsa daemon_session__remove(session);
977c0666261SJiri Olsa
978789eae7fSArnaldo Carvalho de Melo zfree(&daemon->config_real);
979789eae7fSArnaldo Carvalho de Melo zfree(&daemon->config_base);
980789eae7fSArnaldo Carvalho de Melo zfree(&daemon->base);
981fc1dcb1eSJiri Olsa }
982fc1dcb1eSJiri Olsa
daemon__reconfig(struct daemon * daemon)983c0666261SJiri Olsa static int daemon__reconfig(struct daemon *daemon)
984c0666261SJiri Olsa {
985c0666261SJiri Olsa struct daemon_session *session, *n;
986c0666261SJiri Olsa
987c0666261SJiri Olsa list_for_each_entry_safe(session, n, &daemon->sessions, list) {
988c0666261SJiri Olsa /* No change. */
989c0666261SJiri Olsa if (session->state == OK)
990c0666261SJiri Olsa continue;
991c0666261SJiri Olsa
992c0666261SJiri Olsa /* Remove session. */
993c0666261SJiri Olsa if (session->state == KILL) {
994c0666261SJiri Olsa if (session->pid > 0) {
99512c1a415SJiri Olsa daemon_session__kill(session, daemon);
996c0666261SJiri Olsa pr_info("reconfig: session '%s' killed\n", session->name);
997c0666261SJiri Olsa }
998c0666261SJiri Olsa daemon_session__remove(session);
999c0666261SJiri Olsa continue;
1000c0666261SJiri Olsa }
1001c0666261SJiri Olsa
1002c0666261SJiri Olsa /* Reconfig session. */
1003c0666261SJiri Olsa if (session->pid > 0) {
100412c1a415SJiri Olsa daemon_session__kill(session, daemon);
1005c0666261SJiri Olsa pr_info("reconfig: session '%s' killed\n", session->name);
1006c0666261SJiri Olsa }
1007c0666261SJiri Olsa if (daemon_session__run(session, daemon))
1008c0666261SJiri Olsa return -1;
1009c0666261SJiri Olsa
1010c0666261SJiri Olsa session->state = OK;
1011c0666261SJiri Olsa }
1012c0666261SJiri Olsa
1013c0666261SJiri Olsa return 0;
1014c0666261SJiri Olsa }
1015c0666261SJiri Olsa
setup_config_changes(struct daemon * daemon)10163cda0625SJiri Olsa static int setup_config_changes(struct daemon *daemon)
10173cda0625SJiri Olsa {
10183cda0625SJiri Olsa char *basen = strdup(daemon->config_real);
10193cda0625SJiri Olsa char *dirn = strdup(daemon->config_real);
10203cda0625SJiri Olsa char *base, *dir;
10213cda0625SJiri Olsa int fd, wd = -1;
10223cda0625SJiri Olsa
10233cda0625SJiri Olsa if (!dirn || !basen)
10243cda0625SJiri Olsa goto out;
10253cda0625SJiri Olsa
10263cda0625SJiri Olsa fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
10273cda0625SJiri Olsa if (fd < 0) {
10283cda0625SJiri Olsa perror("failed: inotify_init");
10293cda0625SJiri Olsa goto out;
10303cda0625SJiri Olsa }
10313cda0625SJiri Olsa
10323cda0625SJiri Olsa dir = dirname(dirn);
10333cda0625SJiri Olsa base = basename(basen);
10343cda0625SJiri Olsa pr_debug("config file: %s, dir: %s\n", base, dir);
10353cda0625SJiri Olsa
10363cda0625SJiri Olsa wd = inotify_add_watch(fd, dir, IN_CLOSE_WRITE);
10373cda0625SJiri Olsa if (wd >= 0) {
10383cda0625SJiri Olsa daemon->config_base = strdup(base);
10393cda0625SJiri Olsa if (!daemon->config_base) {
10403cda0625SJiri Olsa close(fd);
10413cda0625SJiri Olsa wd = -1;
10423cda0625SJiri Olsa }
10433cda0625SJiri Olsa } else {
10443cda0625SJiri Olsa perror("failed: inotify_add_watch");
10453cda0625SJiri Olsa }
10463cda0625SJiri Olsa
10473cda0625SJiri Olsa out:
10483cda0625SJiri Olsa free(basen);
10493cda0625SJiri Olsa free(dirn);
10503cda0625SJiri Olsa return wd < 0 ? -1 : fd;
10513cda0625SJiri Olsa }
10523cda0625SJiri Olsa
process_inotify_event(struct daemon * daemon,char * buf,ssize_t len)10533cda0625SJiri Olsa static bool process_inotify_event(struct daemon *daemon, char *buf, ssize_t len)
10543cda0625SJiri Olsa {
10553cda0625SJiri Olsa char *p = buf;
10563cda0625SJiri Olsa
10573cda0625SJiri Olsa while (p < (buf + len)) {
10583cda0625SJiri Olsa struct inotify_event *event = (struct inotify_event *) p;
10593cda0625SJiri Olsa
10603cda0625SJiri Olsa /*
10613cda0625SJiri Olsa * We monitor config directory, check if our
10623cda0625SJiri Olsa * config file was changes.
10633cda0625SJiri Olsa */
10643cda0625SJiri Olsa if ((event->mask & IN_CLOSE_WRITE) &&
10653cda0625SJiri Olsa !(event->mask & IN_ISDIR)) {
10663cda0625SJiri Olsa if (!strcmp(event->name, daemon->config_base))
10673cda0625SJiri Olsa return true;
10683cda0625SJiri Olsa }
10693cda0625SJiri Olsa p += sizeof(*event) + event->len;
10703cda0625SJiri Olsa }
10713cda0625SJiri Olsa return false;
10723cda0625SJiri Olsa }
10733cda0625SJiri Olsa
handle_config_changes(struct daemon * daemon,int conf_fd,bool * config_changed)10743cda0625SJiri Olsa static int handle_config_changes(struct daemon *daemon, int conf_fd,
10753cda0625SJiri Olsa bool *config_changed)
10763cda0625SJiri Olsa {
10773cda0625SJiri Olsa char buf[4096];
10783cda0625SJiri Olsa ssize_t len;
10793cda0625SJiri Olsa
10803cda0625SJiri Olsa while (!(*config_changed)) {
10813cda0625SJiri Olsa len = read(conf_fd, buf, sizeof(buf));
10823cda0625SJiri Olsa if (len == -1) {
10833cda0625SJiri Olsa if (errno != EAGAIN) {
10843cda0625SJiri Olsa perror("failed: read");
10853cda0625SJiri Olsa return -1;
10863cda0625SJiri Olsa }
10873cda0625SJiri Olsa return 0;
10883cda0625SJiri Olsa }
10893cda0625SJiri Olsa *config_changed = process_inotify_event(daemon, buf, len);
10903cda0625SJiri Olsa }
10913cda0625SJiri Olsa return 0;
10923cda0625SJiri Olsa }
10933cda0625SJiri Olsa
setup_config(struct daemon * daemon)1094fc1dcb1eSJiri Olsa static int setup_config(struct daemon *daemon)
1095fc1dcb1eSJiri Olsa {
10965631d100SJiri Olsa if (daemon->base_user) {
10975631d100SJiri Olsa daemon->base = strdup(daemon->base_user);
10985631d100SJiri Olsa if (!daemon->base)
10995631d100SJiri Olsa return -ENOMEM;
11005631d100SJiri Olsa }
11015631d100SJiri Olsa
1102fc1dcb1eSJiri Olsa if (daemon->config) {
1103fc1dcb1eSJiri Olsa char *real = realpath(daemon->config, NULL);
1104fc1dcb1eSJiri Olsa
1105fc1dcb1eSJiri Olsa if (!real) {
1106fc1dcb1eSJiri Olsa perror("failed: realpath");
1107fc1dcb1eSJiri Olsa return -1;
1108fc1dcb1eSJiri Olsa }
1109fc1dcb1eSJiri Olsa daemon->config_real = real;
1110fc1dcb1eSJiri Olsa return 0;
1111fc1dcb1eSJiri Olsa }
1112fc1dcb1eSJiri Olsa
1113fc1dcb1eSJiri Olsa if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK))
1114fc1dcb1eSJiri Olsa daemon->config_real = strdup(perf_etc_perfconfig());
1115fc1dcb1eSJiri Olsa else if (perf_config_global() && perf_home_perfconfig())
1116fc1dcb1eSJiri Olsa daemon->config_real = strdup(perf_home_perfconfig());
1117fc1dcb1eSJiri Olsa
1118fc1dcb1eSJiri Olsa return daemon->config_real ? 0 : -1;
1119fc1dcb1eSJiri Olsa }
1120fc1dcb1eSJiri Olsa
11218c98be6cSJiri Olsa #ifndef F_TLOCK
11228c98be6cSJiri Olsa #define F_TLOCK 2
11238c98be6cSJiri Olsa
lockf(int fd,int cmd,off_t len)11248c98be6cSJiri Olsa static int lockf(int fd, int cmd, off_t len)
11258c98be6cSJiri Olsa {
11268c98be6cSJiri Olsa if (cmd != F_TLOCK || len != 0)
11278c98be6cSJiri Olsa return -1;
11288c98be6cSJiri Olsa
11298c98be6cSJiri Olsa return flock(fd, LOCK_EX | LOCK_NB);
11308c98be6cSJiri Olsa }
11318c98be6cSJiri Olsa #endif // F_TLOCK
11328c98be6cSJiri Olsa
11338c98be6cSJiri Olsa /*
11348c98be6cSJiri Olsa * Each daemon tries to create and lock BASE/lock file,
11358c98be6cSJiri Olsa * if it's successful we are sure we're the only daemon
11368c98be6cSJiri Olsa * running over the BASE.
11378c98be6cSJiri Olsa *
11388c98be6cSJiri Olsa * Once daemon is finished, file descriptor to lock file
11398c98be6cSJiri Olsa * is closed and lock is released.
11408c98be6cSJiri Olsa */
check_lock(struct daemon * daemon)11418c98be6cSJiri Olsa static int check_lock(struct daemon *daemon)
11428c98be6cSJiri Olsa {
11438c98be6cSJiri Olsa char path[PATH_MAX];
11448c98be6cSJiri Olsa char buf[20];
11458c98be6cSJiri Olsa int fd, pid;
11468c98be6cSJiri Olsa ssize_t len;
11478c98be6cSJiri Olsa
11488c98be6cSJiri Olsa scnprintf(path, sizeof(path), "%s/lock", daemon->base);
11498c98be6cSJiri Olsa
11508c98be6cSJiri Olsa fd = open(path, O_RDWR|O_CREAT|O_CLOEXEC, 0640);
11518c98be6cSJiri Olsa if (fd < 0)
11528c98be6cSJiri Olsa return -1;
11538c98be6cSJiri Olsa
11548c98be6cSJiri Olsa if (lockf(fd, F_TLOCK, 0) < 0) {
11558c98be6cSJiri Olsa filename__read_int(path, &pid);
11568c98be6cSJiri Olsa fprintf(stderr, "failed: another perf daemon (pid %d) owns %s\n",
11578c98be6cSJiri Olsa pid, daemon->base);
11588c98be6cSJiri Olsa close(fd);
11598c98be6cSJiri Olsa return -1;
11608c98be6cSJiri Olsa }
11618c98be6cSJiri Olsa
11628c98be6cSJiri Olsa scnprintf(buf, sizeof(buf), "%d", getpid());
11638c98be6cSJiri Olsa len = strlen(buf);
11648c98be6cSJiri Olsa
11658c98be6cSJiri Olsa if (write(fd, buf, len) != len) {
11668c98be6cSJiri Olsa perror("failed: write");
11678c98be6cSJiri Olsa close(fd);
11688c98be6cSJiri Olsa return -1;
11698c98be6cSJiri Olsa }
11708c98be6cSJiri Olsa
11718c98be6cSJiri Olsa if (ftruncate(fd, len)) {
11728c98be6cSJiri Olsa perror("failed: ftruncate");
11738c98be6cSJiri Olsa close(fd);
11748c98be6cSJiri Olsa return -1;
11758c98be6cSJiri Olsa }
11768c98be6cSJiri Olsa
11778c98be6cSJiri Olsa return 0;
11788c98be6cSJiri Olsa }
11798c98be6cSJiri Olsa
go_background(struct daemon * daemon)118088adb119SJiri Olsa static int go_background(struct daemon *daemon)
118188adb119SJiri Olsa {
118288adb119SJiri Olsa int pid, fd;
118388adb119SJiri Olsa
118488adb119SJiri Olsa pid = fork();
118588adb119SJiri Olsa if (pid < 0)
118688adb119SJiri Olsa return -1;
118788adb119SJiri Olsa
118888adb119SJiri Olsa if (pid > 0)
118988adb119SJiri Olsa return 1;
119088adb119SJiri Olsa
119188adb119SJiri Olsa if (setsid() < 0)
119288adb119SJiri Olsa return -1;
119388adb119SJiri Olsa
11948c98be6cSJiri Olsa if (check_lock(daemon))
11958c98be6cSJiri Olsa return -1;
11968c98be6cSJiri Olsa
119788adb119SJiri Olsa umask(0);
119888adb119SJiri Olsa
119988adb119SJiri Olsa if (chdir(daemon->base)) {
120088adb119SJiri Olsa perror("failed: chdir");
120188adb119SJiri Olsa return -1;
120288adb119SJiri Olsa }
120388adb119SJiri Olsa
120488adb119SJiri Olsa fd = open("output", O_RDWR|O_CREAT|O_TRUNC, 0644);
120588adb119SJiri Olsa if (fd < 0) {
120688adb119SJiri Olsa perror("failed: open");
120788adb119SJiri Olsa return -1;
120888adb119SJiri Olsa }
120988adb119SJiri Olsa
121088adb119SJiri Olsa if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
121188adb119SJiri Olsa perror("failed: fcntl FD_CLOEXEC");
121288adb119SJiri Olsa close(fd);
121388adb119SJiri Olsa return -1;
121488adb119SJiri Olsa }
121588adb119SJiri Olsa
121688adb119SJiri Olsa close(0);
121788adb119SJiri Olsa dup2(fd, 1);
121888adb119SJiri Olsa dup2(fd, 2);
121988adb119SJiri Olsa close(fd);
122088adb119SJiri Olsa
122188adb119SJiri Olsa daemon->out = fdopen(1, "w");
122288adb119SJiri Olsa if (!daemon->out) {
122388adb119SJiri Olsa close(1);
122488adb119SJiri Olsa close(2);
122588adb119SJiri Olsa return -1;
122688adb119SJiri Olsa }
122788adb119SJiri Olsa
122888adb119SJiri Olsa setbuf(daemon->out, NULL);
122988adb119SJiri Olsa return 0;
123088adb119SJiri Olsa }
123188adb119SJiri Olsa
setup_signalfd(struct daemon * daemon)123212c1a415SJiri Olsa static int setup_signalfd(struct daemon *daemon)
123312c1a415SJiri Olsa {
123412c1a415SJiri Olsa sigset_t mask;
123512c1a415SJiri Olsa
123612c1a415SJiri Olsa sigemptyset(&mask);
123712c1a415SJiri Olsa sigaddset(&mask, SIGCHLD);
123812c1a415SJiri Olsa
123912c1a415SJiri Olsa if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
124012c1a415SJiri Olsa return -1;
124112c1a415SJiri Olsa
124212c1a415SJiri Olsa daemon->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
124312c1a415SJiri Olsa return daemon->signal_fd;
124412c1a415SJiri Olsa }
124512c1a415SJiri Olsa
__cmd_start(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1246d450bc50SJiri Olsa static int __cmd_start(struct daemon *daemon, struct option parent_options[],
1247d450bc50SJiri Olsa int argc, const char **argv)
1248d450bc50SJiri Olsa {
124988adb119SJiri Olsa bool foreground = false;
1250d450bc50SJiri Olsa struct option start_options[] = {
125188adb119SJiri Olsa OPT_BOOLEAN('f', "foreground", &foreground, "stay on console"),
1252d450bc50SJiri Olsa OPT_PARENT(parent_options),
1253d450bc50SJiri Olsa OPT_END()
1254d450bc50SJiri Olsa };
125512c1a415SJiri Olsa int sock_fd = -1, conf_fd = -1, signal_fd = -1;
125612c1a415SJiri Olsa int sock_pos, file_pos, signal_pos;
1257ed36b704SJiri Olsa struct fdarray fda;
1258d450bc50SJiri Olsa int err = 0;
1259d450bc50SJiri Olsa
1260d450bc50SJiri Olsa argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1261d450bc50SJiri Olsa if (argc)
1262d450bc50SJiri Olsa usage_with_options(daemon_usage, start_options);
1263d450bc50SJiri Olsa
12645bdee4f0SJiri Olsa daemon->start = time(NULL);
12655bdee4f0SJiri Olsa
1266fc1dcb1eSJiri Olsa if (setup_config(daemon)) {
1267fc1dcb1eSJiri Olsa pr_err("failed: config not found\n");
1268fc1dcb1eSJiri Olsa return -1;
1269fc1dcb1eSJiri Olsa }
1270fc1dcb1eSJiri Olsa
1271c0666261SJiri Olsa if (setup_server_config(daemon))
1272c0666261SJiri Olsa return -1;
1273c0666261SJiri Olsa
12748c98be6cSJiri Olsa if (foreground && check_lock(daemon))
12758c98be6cSJiri Olsa return -1;
12768c98be6cSJiri Olsa
127788adb119SJiri Olsa if (!foreground) {
127888adb119SJiri Olsa err = go_background(daemon);
127988adb119SJiri Olsa if (err) {
128088adb119SJiri Olsa /* original process, exit normally */
128188adb119SJiri Olsa if (err == 1)
128288adb119SJiri Olsa err = 0;
128388adb119SJiri Olsa daemon__exit(daemon);
128488adb119SJiri Olsa return err;
128588adb119SJiri Olsa }
128688adb119SJiri Olsa }
128788adb119SJiri Olsa
1288d450bc50SJiri Olsa debug_set_file(daemon->out);
1289d450bc50SJiri Olsa debug_set_display_time(true);
1290d450bc50SJiri Olsa
1291d450bc50SJiri Olsa pr_info("daemon started (pid %d)\n", getpid());
1292d450bc50SJiri Olsa
129312c1a415SJiri Olsa fdarray__init(&fda, 3);
1294ed36b704SJiri Olsa
1295ed36b704SJiri Olsa sock_fd = setup_server_socket(daemon);
1296ed36b704SJiri Olsa if (sock_fd < 0)
1297ed36b704SJiri Olsa goto out;
1298ed36b704SJiri Olsa
12993cda0625SJiri Olsa conf_fd = setup_config_changes(daemon);
13003cda0625SJiri Olsa if (conf_fd < 0)
13013cda0625SJiri Olsa goto out;
13023cda0625SJiri Olsa
130312c1a415SJiri Olsa signal_fd = setup_signalfd(daemon);
130412c1a415SJiri Olsa if (signal_fd < 0)
130512c1a415SJiri Olsa goto out;
130612c1a415SJiri Olsa
1307ed36b704SJiri Olsa sock_pos = fdarray__add(&fda, sock_fd, POLLIN|POLLERR|POLLHUP, 0);
1308ed36b704SJiri Olsa if (sock_pos < 0)
1309ed36b704SJiri Olsa goto out;
1310ed36b704SJiri Olsa
13113cda0625SJiri Olsa file_pos = fdarray__add(&fda, conf_fd, POLLIN|POLLERR|POLLHUP, 0);
13123cda0625SJiri Olsa if (file_pos < 0)
13133cda0625SJiri Olsa goto out;
13143cda0625SJiri Olsa
131512c1a415SJiri Olsa signal_pos = fdarray__add(&fda, signal_fd, POLLIN|POLLERR|POLLHUP, 0);
131612c1a415SJiri Olsa if (signal_pos < 0)
131712c1a415SJiri Olsa goto out;
131812c1a415SJiri Olsa
1319d450bc50SJiri Olsa signal(SIGINT, sig_handler);
1320d450bc50SJiri Olsa signal(SIGTERM, sig_handler);
1321edcaa479SJiri Olsa signal(SIGPIPE, SIG_IGN);
1322d450bc50SJiri Olsa
1323d450bc50SJiri Olsa while (!done && !err) {
1324c0666261SJiri Olsa err = daemon__reconfig(daemon);
1325c0666261SJiri Olsa
1326c0666261SJiri Olsa if (!err && fdarray__poll(&fda, -1)) {
1327c0666261SJiri Olsa bool reconfig = false;
1328c0666261SJiri Olsa
1329ed36b704SJiri Olsa if (fda.entries[sock_pos].revents & POLLIN)
1330ed36b704SJiri Olsa err = handle_server_socket(daemon, sock_fd);
13313cda0625SJiri Olsa if (fda.entries[file_pos].revents & POLLIN)
13323cda0625SJiri Olsa err = handle_config_changes(daemon, conf_fd, &reconfig);
133312c1a415SJiri Olsa if (fda.entries[signal_pos].revents & POLLIN)
133412c1a415SJiri Olsa err = handle_signalfd(daemon) < 0;
1335c0666261SJiri Olsa
1336c0666261SJiri Olsa if (reconfig)
1337c0666261SJiri Olsa err = setup_server_config(daemon);
1338ed36b704SJiri Olsa }
1339d450bc50SJiri Olsa }
1340d450bc50SJiri Olsa
1341ed36b704SJiri Olsa out:
1342ed36b704SJiri Olsa fdarray__exit(&fda);
1343ed36b704SJiri Olsa
1344c0666261SJiri Olsa daemon__kill(daemon);
1345fc1dcb1eSJiri Olsa daemon__exit(daemon);
1346fc1dcb1eSJiri Olsa
1347ed36b704SJiri Olsa if (sock_fd != -1)
1348ed36b704SJiri Olsa close(sock_fd);
13493cda0625SJiri Olsa if (conf_fd != -1)
13503cda0625SJiri Olsa close(conf_fd);
13511833b64fSJiri Olsa if (signal_fd != -1)
135212c1a415SJiri Olsa close(signal_fd);
1353ed36b704SJiri Olsa
1354d450bc50SJiri Olsa pr_info("daemon exited\n");
1355d450bc50SJiri Olsa fclose(daemon->out);
1356d450bc50SJiri Olsa return err;
1357d450bc50SJiri Olsa }
1358d450bc50SJiri Olsa
send_cmd(struct daemon * daemon,union cmd * cmd)135990b0aad8SJiri Olsa static int send_cmd(struct daemon *daemon, union cmd *cmd)
136090b0aad8SJiri Olsa {
136190b0aad8SJiri Olsa int ret = -1, fd;
136290b0aad8SJiri Olsa char *line = NULL;
136390b0aad8SJiri Olsa size_t len = 0;
136490b0aad8SJiri Olsa ssize_t nread;
136590b0aad8SJiri Olsa FILE *in = NULL;
136690b0aad8SJiri Olsa
136790b0aad8SJiri Olsa if (setup_client_config(daemon))
136890b0aad8SJiri Olsa return -1;
136990b0aad8SJiri Olsa
137090b0aad8SJiri Olsa fd = setup_client_socket(daemon);
137190b0aad8SJiri Olsa if (fd < 0)
137290b0aad8SJiri Olsa return -1;
137390b0aad8SJiri Olsa
137490b0aad8SJiri Olsa if (sizeof(*cmd) != writen(fd, cmd, sizeof(*cmd))) {
137590b0aad8SJiri Olsa perror("failed: write");
137690b0aad8SJiri Olsa goto out;
137790b0aad8SJiri Olsa }
137890b0aad8SJiri Olsa
137990b0aad8SJiri Olsa in = fdopen(fd, "r");
138090b0aad8SJiri Olsa if (!in) {
138190b0aad8SJiri Olsa perror("failed: fdopen");
138290b0aad8SJiri Olsa goto out;
138390b0aad8SJiri Olsa }
138490b0aad8SJiri Olsa
138590b0aad8SJiri Olsa while ((nread = getline(&line, &len, in)) != -1) {
138690b0aad8SJiri Olsa if (fwrite(line, nread, 1, stdout) != 1)
138790b0aad8SJiri Olsa goto out_fclose;
138890b0aad8SJiri Olsa fflush(stdout);
138990b0aad8SJiri Olsa }
139090b0aad8SJiri Olsa
139190b0aad8SJiri Olsa ret = 0;
139290b0aad8SJiri Olsa out_fclose:
139390b0aad8SJiri Olsa fclose(in);
139490b0aad8SJiri Olsa free(line);
139590b0aad8SJiri Olsa out:
139690b0aad8SJiri Olsa /* If in is defined, then fd is closed via fclose. */
139790b0aad8SJiri Olsa if (!in)
139890b0aad8SJiri Olsa close(fd);
139990b0aad8SJiri Olsa return ret;
140090b0aad8SJiri Olsa }
140190b0aad8SJiri Olsa
send_cmd_list(struct daemon * daemon)1402b325f7beSJiri Olsa static int send_cmd_list(struct daemon *daemon)
1403b325f7beSJiri Olsa {
1404b28e5e43SIan Rogers union cmd cmd;
1405b325f7beSJiri Olsa
1406b28e5e43SIan Rogers memset(&cmd, 0, sizeof(cmd));
1407b28e5e43SIan Rogers cmd.list.cmd = CMD_LIST;
1408b325f7beSJiri Olsa cmd.list.verbose = verbose;
1409b325f7beSJiri Olsa cmd.list.csv_sep = daemon->csv_sep ? *daemon->csv_sep : 0;
1410b325f7beSJiri Olsa
1411b325f7beSJiri Olsa return send_cmd(daemon, &cmd);
1412b325f7beSJiri Olsa }
1413b325f7beSJiri Olsa
__cmd_signal(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)14142d6914cdSJiri Olsa static int __cmd_signal(struct daemon *daemon, struct option parent_options[],
14152d6914cdSJiri Olsa int argc, const char **argv)
14162d6914cdSJiri Olsa {
14172d6914cdSJiri Olsa const char *name = "all";
14182d6914cdSJiri Olsa struct option start_options[] = {
14192d6914cdSJiri Olsa OPT_STRING(0, "session", &name, "session",
14202d6914cdSJiri Olsa "Sent signal to specific session"),
14212d6914cdSJiri Olsa OPT_PARENT(parent_options),
14222d6914cdSJiri Olsa OPT_END()
14232d6914cdSJiri Olsa };
14242d6914cdSJiri Olsa union cmd cmd;
14252d6914cdSJiri Olsa
14262d6914cdSJiri Olsa argc = parse_options(argc, argv, start_options, daemon_usage, 0);
14272d6914cdSJiri Olsa if (argc)
14282d6914cdSJiri Olsa usage_with_options(daemon_usage, start_options);
14292d6914cdSJiri Olsa
14302d6914cdSJiri Olsa if (setup_config(daemon)) {
14312d6914cdSJiri Olsa pr_err("failed: config not found\n");
14322d6914cdSJiri Olsa return -1;
14332d6914cdSJiri Olsa }
14342d6914cdSJiri Olsa
1435b28e5e43SIan Rogers memset(&cmd, 0, sizeof(cmd));
14362d6914cdSJiri Olsa cmd.signal.cmd = CMD_SIGNAL,
14372d6914cdSJiri Olsa cmd.signal.sig = SIGUSR2;
14382d6914cdSJiri Olsa strncpy(cmd.signal.name, name, sizeof(cmd.signal.name) - 1);
14392d6914cdSJiri Olsa
14402d6914cdSJiri Olsa return send_cmd(daemon, &cmd);
14412d6914cdSJiri Olsa }
14422d6914cdSJiri Olsa
__cmd_stop(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)144323c5831eSJiri Olsa static int __cmd_stop(struct daemon *daemon, struct option parent_options[],
144423c5831eSJiri Olsa int argc, const char **argv)
144523c5831eSJiri Olsa {
144623c5831eSJiri Olsa struct option start_options[] = {
144723c5831eSJiri Olsa OPT_PARENT(parent_options),
144823c5831eSJiri Olsa OPT_END()
144923c5831eSJiri Olsa };
1450b28e5e43SIan Rogers union cmd cmd;
145123c5831eSJiri Olsa
145223c5831eSJiri Olsa argc = parse_options(argc, argv, start_options, daemon_usage, 0);
145323c5831eSJiri Olsa if (argc)
145423c5831eSJiri Olsa usage_with_options(daemon_usage, start_options);
145523c5831eSJiri Olsa
145623c5831eSJiri Olsa if (setup_config(daemon)) {
145723c5831eSJiri Olsa pr_err("failed: config not found\n");
145823c5831eSJiri Olsa return -1;
145923c5831eSJiri Olsa }
146023c5831eSJiri Olsa
1461b28e5e43SIan Rogers memset(&cmd, 0, sizeof(cmd));
1462b28e5e43SIan Rogers cmd.cmd = CMD_STOP;
146323c5831eSJiri Olsa return send_cmd(daemon, &cmd);
146423c5831eSJiri Olsa }
146523c5831eSJiri Olsa
__cmd_ping(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1466edcaa479SJiri Olsa static int __cmd_ping(struct daemon *daemon, struct option parent_options[],
1467edcaa479SJiri Olsa int argc, const char **argv)
1468edcaa479SJiri Olsa {
1469edcaa479SJiri Olsa const char *name = "all";
1470edcaa479SJiri Olsa struct option ping_options[] = {
1471edcaa479SJiri Olsa OPT_STRING(0, "session", &name, "session",
1472edcaa479SJiri Olsa "Ping to specific session"),
1473edcaa479SJiri Olsa OPT_PARENT(parent_options),
1474edcaa479SJiri Olsa OPT_END()
1475edcaa479SJiri Olsa };
1476b28e5e43SIan Rogers union cmd cmd;
1477edcaa479SJiri Olsa
1478edcaa479SJiri Olsa argc = parse_options(argc, argv, ping_options, daemon_usage, 0);
1479edcaa479SJiri Olsa if (argc)
1480edcaa479SJiri Olsa usage_with_options(daemon_usage, ping_options);
1481edcaa479SJiri Olsa
1482edcaa479SJiri Olsa if (setup_config(daemon)) {
1483edcaa479SJiri Olsa pr_err("failed: config not found\n");
1484edcaa479SJiri Olsa return -1;
1485edcaa479SJiri Olsa }
1486edcaa479SJiri Olsa
1487b28e5e43SIan Rogers memset(&cmd, 0, sizeof(cmd));
1488b28e5e43SIan Rogers cmd.cmd = CMD_PING;
1489edcaa479SJiri Olsa scnprintf(cmd.ping.name, sizeof(cmd.ping.name), "%s", name);
1490edcaa479SJiri Olsa return send_cmd(daemon, &cmd);
1491edcaa479SJiri Olsa }
1492edcaa479SJiri Olsa
alloc_perf_exe_path(void)149392294b90SIan Rogers static char *alloc_perf_exe_path(void)
149492294b90SIan Rogers {
149592294b90SIan Rogers char path[PATH_MAX];
149692294b90SIan Rogers
149792294b90SIan Rogers perf_exe(path, sizeof(path));
149892294b90SIan Rogers return strdup(path);
149992294b90SIan Rogers }
150092294b90SIan Rogers
cmd_daemon(int argc,const char ** argv)1501d450bc50SJiri Olsa int cmd_daemon(int argc, const char **argv)
1502d450bc50SJiri Olsa {
1503d450bc50SJiri Olsa struct option daemon_options[] = {
1504d450bc50SJiri Olsa OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1505fc1dcb1eSJiri Olsa OPT_STRING(0, "config", &__daemon.config,
1506fc1dcb1eSJiri Olsa "config file", "config file path"),
15075631d100SJiri Olsa OPT_STRING(0, "base", &__daemon.base_user,
15085631d100SJiri Olsa "directory", "base directory"),
1509b325f7beSJiri Olsa OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
1510b325f7beSJiri Olsa "field separator", "print counts with custom separator", ","),
1511d450bc50SJiri Olsa OPT_END()
1512d450bc50SJiri Olsa };
151392294b90SIan Rogers int ret = -1;
1514d450bc50SJiri Olsa
151592294b90SIan Rogers __daemon.perf = alloc_perf_exe_path();
151692294b90SIan Rogers if (!__daemon.perf)
151792294b90SIan Rogers return -ENOMEM;
151892294b90SIan Rogers
1519d450bc50SJiri Olsa __daemon.out = stdout;
1520d450bc50SJiri Olsa
1521d450bc50SJiri Olsa argc = parse_options(argc, argv, daemon_options, daemon_usage,
1522d450bc50SJiri Olsa PARSE_OPT_STOP_AT_NON_OPTION);
1523d450bc50SJiri Olsa
1524d450bc50SJiri Olsa if (argc) {
1525d450bc50SJiri Olsa if (!strcmp(argv[0], "start"))
152692294b90SIan Rogers ret = __cmd_start(&__daemon, daemon_options, argc, argv);
1527*49a5e3edSJiri Olsa else if (!strcmp(argv[0], "signal"))
152892294b90SIan Rogers ret = __cmd_signal(&__daemon, daemon_options, argc, argv);
152923c5831eSJiri Olsa else if (!strcmp(argv[0], "stop"))
153092294b90SIan Rogers ret = __cmd_stop(&__daemon, daemon_options, argc, argv);
1531edcaa479SJiri Olsa else if (!strcmp(argv[0], "ping"))
153292294b90SIan Rogers ret = __cmd_ping(&__daemon, daemon_options, argc, argv);
153392294b90SIan Rogers else
1534d450bc50SJiri Olsa pr_err("failed: unknown command '%s'\n", argv[0]);
153592294b90SIan Rogers } else {
153692294b90SIan Rogers ret = setup_config(&__daemon);
153792294b90SIan Rogers if (ret)
1538fc1dcb1eSJiri Olsa pr_err("failed: config not found\n");
153992294b90SIan Rogers else
154092294b90SIan Rogers ret = send_cmd_list(&__daemon);
1541fc1dcb1eSJiri Olsa }
154292294b90SIan Rogers zfree(&__daemon.perf);
154392294b90SIan Rogers return ret;
1544d450bc50SJiri Olsa }
1545