xref: /openbmc/linux/tools/perf/builtin-daemon.c (revision 1003d16e)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <internal/lib.h>
3 #include <subcmd/parse-options.h>
4 #include <api/fd/array.h>
5 #include <api/fs/fs.h>
6 #include <linux/zalloc.h>
7 #include <linux/string.h>
8 #include <linux/limits.h>
9 #include <string.h>
10 #include <sys/file.h>
11 #include <signal.h>
12 #include <stdlib.h>
13 #include <time.h>
14 #include <stdio.h>
15 #include <unistd.h>
16 #include <errno.h>
17 #include <sys/inotify.h>
18 #include <libgen.h>
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <sys/un.h>
22 #include <sys/stat.h>
23 #include <sys/signalfd.h>
24 #include <sys/wait.h>
25 #include <poll.h>
26 #include "builtin.h"
27 #include "perf.h"
28 #include "debug.h"
29 #include "config.h"
30 #include "util.h"
31 
32 #define SESSION_OUTPUT  "output"
33 #define SESSION_CONTROL "control"
34 #define SESSION_ACK     "ack"
35 
36 /*
37  * Session states:
38  *
39  *   OK       - session is up and running
40  *   RECONFIG - session is pending for reconfiguration,
41  *              new values are already loaded in session object
42  *   KILL     - session is pending to be killed
43  *
44  * Session object life and its state is maintained by
45  * following functions:
46  *
47  *  setup_server_config
48  *    - reads config file and setup session objects
49  *      with following states:
50  *
51  *      OK       - no change needed
52  *      RECONFIG - session needs to be changed
53  *                 (run variable changed)
54  *      KILL     - session needs to be killed
55  *                 (session is no longer in config file)
56  *
57  *  daemon__reconfig
58  *    - scans session objects and does following actions
59  *      for states:
60  *
61  *      OK       - skip
62  *      RECONFIG - session is killed and re-run with new config
63  *      KILL     - session is killed
64  *
65  *    - all sessions have OK state on the function exit
66  */
67 enum daemon_session_state {
68 	OK,
69 	RECONFIG,
70 	KILL,
71 };
72 
73 struct daemon_session {
74 	char				*base;
75 	char				*name;
76 	char				*run;
77 	char				*control;
78 	int				 pid;
79 	struct list_head		 list;
80 	enum daemon_session_state	 state;
81 	time_t				 start;
82 };
83 
84 struct daemon {
85 	const char		*config;
86 	char			*config_real;
87 	char			*config_base;
88 	const char		*csv_sep;
89 	const char		*base_user;
90 	char			*base;
91 	struct list_head	 sessions;
92 	FILE			*out;
93 	char			*perf;
94 	int			 signal_fd;
95 	time_t			 start;
96 };
97 
98 static struct daemon __daemon = {
99 	.sessions = LIST_HEAD_INIT(__daemon.sessions),
100 };
101 
102 static const char * const daemon_usage[] = {
103 	"perf daemon {start|signal|stop|ping} [<options>]",
104 	"perf daemon [<options>]",
105 	NULL
106 };
107 
108 static volatile sig_atomic_t done;
109 
sig_handler(int sig __maybe_unused)110 static void sig_handler(int sig __maybe_unused)
111 {
112 	done = true;
113 }
114 
daemon__add_session(struct daemon * config,char * name)115 static struct daemon_session *daemon__add_session(struct daemon *config, char *name)
116 {
117 	struct daemon_session *session = zalloc(sizeof(*session));
118 
119 	if (!session)
120 		return NULL;
121 
122 	session->name = strdup(name);
123 	if (!session->name) {
124 		free(session);
125 		return NULL;
126 	}
127 
128 	session->pid = -1;
129 	list_add_tail(&session->list, &config->sessions);
130 	return session;
131 }
132 
daemon__find_session(struct daemon * daemon,char * name)133 static struct daemon_session *daemon__find_session(struct daemon *daemon, char *name)
134 {
135 	struct daemon_session *session;
136 
137 	list_for_each_entry(session, &daemon->sessions, list) {
138 		if (!strcmp(session->name, name))
139 			return session;
140 	}
141 
142 	return NULL;
143 }
144 
get_session_name(const char * var,char * session,int len)145 static int get_session_name(const char *var, char *session, int len)
146 {
147 	const char *p = var + sizeof("session-") - 1;
148 
149 	while (*p != '.' && *p != 0x0 && len--)
150 		*session++ = *p++;
151 
152 	*session = 0;
153 	return *p == '.' ? 0 : -EINVAL;
154 }
155 
session_config(struct daemon * daemon,const char * var,const char * value)156 static int session_config(struct daemon *daemon, const char *var, const char *value)
157 {
158 	struct daemon_session *session;
159 	char name[100];
160 
161 	if (get_session_name(var, name, sizeof(name) - 1))
162 		return -EINVAL;
163 
164 	var = strchr(var, '.');
165 	if (!var)
166 		return -EINVAL;
167 
168 	var++;
169 
170 	session = daemon__find_session(daemon, name);
171 
172 	if (!session) {
173 		/* New session is defined. */
174 		session = daemon__add_session(daemon, name);
175 		if (!session)
176 			return -ENOMEM;
177 
178 		pr_debug("reconfig: found new session %s\n", name);
179 
180 		/* Trigger reconfig to start it. */
181 		session->state = RECONFIG;
182 	} else if (session->state == KILL) {
183 		/* Current session is defined, no action needed. */
184 		pr_debug("reconfig: found current session %s\n", name);
185 		session->state = OK;
186 	}
187 
188 	if (!strcmp(var, "run")) {
189 		bool same = false;
190 
191 		if (session->run)
192 			same = !strcmp(session->run, value);
193 
194 		if (!same) {
195 			if (session->run) {
196 				zfree(&session->run);
197 				pr_debug("reconfig: session %s is changed\n", name);
198 			}
199 
200 			session->run = strdup(value);
201 			if (!session->run)
202 				return -ENOMEM;
203 
204 			/*
205 			 * Either new or changed run value is defined,
206 			 * trigger reconfig for the session.
207 			 */
208 			session->state = RECONFIG;
209 		}
210 	}
211 
212 	return 0;
213 }
214 
server_config(const char * var,const char * value,void * cb)215 static int server_config(const char *var, const char *value, void *cb)
216 {
217 	struct daemon *daemon = cb;
218 
219 	if (strstarts(var, "session-")) {
220 		return session_config(daemon, var, value);
221 	} else if (!strcmp(var, "daemon.base") && !daemon->base_user) {
222 		if (daemon->base && strcmp(daemon->base, value)) {
223 			pr_err("failed: can't redefine base, bailing out\n");
224 			return -EINVAL;
225 		}
226 		daemon->base = strdup(value);
227 		if (!daemon->base)
228 			return -ENOMEM;
229 	}
230 
231 	return 0;
232 }
233 
client_config(const char * var,const char * value,void * cb)234 static int client_config(const char *var, const char *value, void *cb)
235 {
236 	struct daemon *daemon = cb;
237 
238 	if (!strcmp(var, "daemon.base") && !daemon->base_user) {
239 		daemon->base = strdup(value);
240 		if (!daemon->base)
241 			return -ENOMEM;
242 	}
243 
244 	return 0;
245 }
246 
check_base(struct daemon * daemon)247 static int check_base(struct daemon *daemon)
248 {
249 	struct stat st;
250 
251 	if (!daemon->base) {
252 		pr_err("failed: base not defined\n");
253 		return -EINVAL;
254 	}
255 
256 	if (stat(daemon->base, &st)) {
257 		switch (errno) {
258 		case EACCES:
259 			pr_err("failed: permission denied for '%s' base\n",
260 			       daemon->base);
261 			return -EACCES;
262 		case ENOENT:
263 			pr_err("failed: base '%s' does not exists\n",
264 			       daemon->base);
265 			return -EACCES;
266 		default:
267 			pr_err("failed: can't access base '%s': %s\n",
268 			       daemon->base, strerror(errno));
269 			return -errno;
270 		}
271 	}
272 
273 	if ((st.st_mode & S_IFMT) != S_IFDIR) {
274 		pr_err("failed: base '%s' is not directory\n",
275 		       daemon->base);
276 		return -EINVAL;
277 	}
278 
279 	return 0;
280 }
281 
setup_client_config(struct daemon * daemon)282 static int setup_client_config(struct daemon *daemon)
283 {
284 	struct perf_config_set *set = perf_config_set__load_file(daemon->config_real);
285 	int err = -ENOMEM;
286 
287 	if (set) {
288 		err = perf_config_set(set, client_config, daemon);
289 		perf_config_set__delete(set);
290 	}
291 
292 	return err ?: check_base(daemon);
293 }
294 
setup_server_config(struct daemon * daemon)295 static int setup_server_config(struct daemon *daemon)
296 {
297 	struct perf_config_set *set;
298 	struct daemon_session *session;
299 	int err = -ENOMEM;
300 
301 	pr_debug("reconfig: started\n");
302 
303 	/*
304 	 * Mark all sessions for kill, the server config
305 	 * will set following states, see explanation at
306 	 * enum daemon_session_state declaration.
307 	 */
308 	list_for_each_entry(session, &daemon->sessions, list)
309 		session->state = KILL;
310 
311 	set = perf_config_set__load_file(daemon->config_real);
312 	if (set) {
313 		err = perf_config_set(set, server_config, daemon);
314 		perf_config_set__delete(set);
315 	}
316 
317 	return err ?: check_base(daemon);
318 }
319 
daemon_session__run(struct daemon_session * session,struct daemon * daemon)320 static int daemon_session__run(struct daemon_session *session,
321 			       struct daemon *daemon)
322 {
323 	char buf[PATH_MAX];
324 	char **argv;
325 	int argc, fd;
326 
327 	if (asprintf(&session->base, "%s/session-%s",
328 		     daemon->base, session->name) < 0) {
329 		perror("failed: asprintf");
330 		return -1;
331 	}
332 
333 	if (mkdir(session->base, 0755) && errno != EEXIST) {
334 		perror("failed: mkdir");
335 		return -1;
336 	}
337 
338 	session->start = time(NULL);
339 
340 	session->pid = fork();
341 	if (session->pid < 0)
342 		return -1;
343 	if (session->pid > 0) {
344 		pr_info("reconfig: ruining session [%s:%d]: %s\n",
345 			session->name, session->pid, session->run);
346 		return 0;
347 	}
348 
349 	if (chdir(session->base)) {
350 		perror("failed: chdir");
351 		return -1;
352 	}
353 
354 	fd = open("/dev/null", O_RDONLY);
355 	if (fd < 0) {
356 		perror("failed: open /dev/null");
357 		return -1;
358 	}
359 
360 	dup2(fd, 0);
361 	close(fd);
362 
363 	fd = open(SESSION_OUTPUT, O_RDWR|O_CREAT|O_TRUNC, 0644);
364 	if (fd < 0) {
365 		perror("failed: open session output");
366 		return -1;
367 	}
368 
369 	dup2(fd, 1);
370 	dup2(fd, 2);
371 	close(fd);
372 
373 	if (mkfifo(SESSION_CONTROL, 0600) && errno != EEXIST) {
374 		perror("failed: create control fifo");
375 		return -1;
376 	}
377 
378 	if (mkfifo(SESSION_ACK, 0600) && errno != EEXIST) {
379 		perror("failed: create ack fifo");
380 		return -1;
381 	}
382 
383 	scnprintf(buf, sizeof(buf), "%s record --control=fifo:%s,%s %s",
384 		  daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);
385 
386 	argv = argv_split(buf, &argc);
387 	if (!argv)
388 		exit(-1);
389 
390 	exit(execve(daemon->perf, argv, NULL));
391 	return -1;
392 }
393 
handle_signalfd(struct daemon * daemon)394 static pid_t handle_signalfd(struct daemon *daemon)
395 {
396 	struct daemon_session *session;
397 	struct signalfd_siginfo si;
398 	ssize_t err;
399 	int status;
400 	pid_t pid;
401 
402 	/*
403 	 * Take signal fd data as pure signal notification and check all
404 	 * the sessions state. The reason is that multiple signals can get
405 	 * coalesced in kernel and we can receive only single signal even
406 	 * if multiple SIGCHLD were generated.
407 	 */
408 	err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
409 	if (err != sizeof(struct signalfd_siginfo)) {
410 		pr_err("failed to read signal fd\n");
411 		return -1;
412 	}
413 
414 	list_for_each_entry(session, &daemon->sessions, list) {
415 		if (session->pid == -1)
416 			continue;
417 
418 		pid = waitpid(session->pid, &status, WNOHANG);
419 		if (pid <= 0)
420 			continue;
421 
422 		if (WIFEXITED(status)) {
423 			pr_info("session '%s' exited, status=%d\n",
424 				session->name, WEXITSTATUS(status));
425 		} else if (WIFSIGNALED(status)) {
426 			pr_info("session '%s' killed (signal %d)\n",
427 				session->name, WTERMSIG(status));
428 		} else if (WIFSTOPPED(status)) {
429 			pr_info("session '%s' stopped (signal %d)\n",
430 				session->name, WSTOPSIG(status));
431 		} else {
432 			pr_info("session '%s' Unexpected status (0x%x)\n",
433 				session->name, status);
434 		}
435 
436 		session->state = KILL;
437 		session->pid = -1;
438 	}
439 
440 	return 0;
441 }
442 
daemon_session__wait(struct daemon_session * session,struct daemon * daemon,int secs)443 static int daemon_session__wait(struct daemon_session *session, struct daemon *daemon,
444 				int secs)
445 {
446 	struct pollfd pollfd = {
447 		.fd	= daemon->signal_fd,
448 		.events	= POLLIN,
449 	};
450 	time_t start;
451 
452 	start = time(NULL);
453 
454 	do {
455 		int err = poll(&pollfd, 1, 1000);
456 
457 		if (err > 0) {
458 			handle_signalfd(daemon);
459 		} else if (err < 0) {
460 			perror("failed: poll\n");
461 			return -1;
462 		}
463 
464 		if (start + secs < time(NULL))
465 			return -1;
466 	} while (session->pid != -1);
467 
468 	return 0;
469 }
470 
daemon__has_alive_session(struct daemon * daemon)471 static bool daemon__has_alive_session(struct daemon *daemon)
472 {
473 	struct daemon_session *session;
474 
475 	list_for_each_entry(session, &daemon->sessions, list) {
476 		if (session->pid != -1)
477 			return true;
478 	}
479 
480 	return false;
481 }
482 
daemon__wait(struct daemon * daemon,int secs)483 static int daemon__wait(struct daemon *daemon, int secs)
484 {
485 	struct pollfd pollfd = {
486 		.fd	= daemon->signal_fd,
487 		.events	= POLLIN,
488 	};
489 	time_t start;
490 
491 	start = time(NULL);
492 
493 	do {
494 		int err = poll(&pollfd, 1, 1000);
495 
496 		if (err > 0) {
497 			handle_signalfd(daemon);
498 		} else if (err < 0) {
499 			perror("failed: poll\n");
500 			return -1;
501 		}
502 
503 		if (start + secs < time(NULL))
504 			return -1;
505 	} while (daemon__has_alive_session(daemon));
506 
507 	return 0;
508 }
509 
daemon_session__control(struct daemon_session * session,const char * msg,bool do_ack)510 static int daemon_session__control(struct daemon_session *session,
511 				   const char *msg, bool do_ack)
512 {
513 	struct pollfd pollfd = { .events = POLLIN, };
514 	char control_path[PATH_MAX];
515 	char ack_path[PATH_MAX];
516 	int control, ack = -1, len;
517 	char buf[20];
518 	int ret = -1;
519 	ssize_t err;
520 
521 	/* open the control file */
522 	scnprintf(control_path, sizeof(control_path), "%s/%s",
523 		  session->base, SESSION_CONTROL);
524 
525 	control = open(control_path, O_WRONLY|O_NONBLOCK);
526 	if (control < 0)
527 		return -1;
528 
529 	if (do_ack) {
530 		/* open the ack file */
531 		scnprintf(ack_path, sizeof(ack_path), "%s/%s",
532 			  session->base, SESSION_ACK);
533 
534 		ack = open(ack_path, O_RDONLY, O_NONBLOCK);
535 		if (ack < 0) {
536 			close(control);
537 			return -1;
538 		}
539 	}
540 
541 	/* write the command */
542 	len = strlen(msg);
543 
544 	err = writen(control, msg, len);
545 	if (err != len) {
546 		pr_err("failed: write to control pipe: %d (%s)\n",
547 		       errno, control_path);
548 		goto out;
549 	}
550 
551 	if (!do_ack)
552 		goto out;
553 
554 	/* wait for an ack */
555 	pollfd.fd = ack;
556 
557 	if (!poll(&pollfd, 1, 2000)) {
558 		pr_err("failed: control ack timeout\n");
559 		goto out;
560 	}
561 
562 	if (!(pollfd.revents & POLLIN)) {
563 		pr_err("failed: did not received an ack\n");
564 		goto out;
565 	}
566 
567 	err = read(ack, buf, sizeof(buf));
568 	if (err > 0)
569 		ret = strcmp(buf, "ack\n");
570 	else
571 		perror("failed: read ack %d\n");
572 
573 out:
574 	if (ack != -1)
575 		close(ack);
576 
577 	close(control);
578 	return ret;
579 }
580 
setup_server_socket(struct daemon * daemon)581 static int setup_server_socket(struct daemon *daemon)
582 {
583 	struct sockaddr_un addr;
584 	char path[PATH_MAX];
585 	int fd = socket(AF_UNIX, SOCK_STREAM, 0);
586 
587 	if (fd < 0) {
588 		fprintf(stderr, "socket: %s\n", strerror(errno));
589 		return -1;
590 	}
591 
592 	if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
593 		perror("failed: fcntl FD_CLOEXEC");
594 		close(fd);
595 		return -1;
596 	}
597 
598 	scnprintf(path, sizeof(path), "%s/control", daemon->base);
599 
600 	if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
601 		pr_err("failed: control path too long '%s'\n", path);
602 		close(fd);
603 		return -1;
604 	}
605 
606 	memset(&addr, 0, sizeof(addr));
607 	addr.sun_family = AF_UNIX;
608 
609 	strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
610 	unlink(path);
611 
612 	if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
613 		perror("failed: bind");
614 		close(fd);
615 		return -1;
616 	}
617 
618 	if (listen(fd, 1) == -1) {
619 		perror("failed: listen");
620 		close(fd);
621 		return -1;
622 	}
623 
624 	return fd;
625 }
626 
627 enum {
628 	CMD_LIST   = 0,
629 	CMD_SIGNAL = 1,
630 	CMD_STOP   = 2,
631 	CMD_PING   = 3,
632 	CMD_MAX,
633 };
634 
635 #define SESSION_MAX 64
636 
637 union cmd {
638 	int cmd;
639 
640 	/* CMD_LIST */
641 	struct {
642 		int	cmd;
643 		int	verbose;
644 		char	csv_sep;
645 	} list;
646 
647 	/* CMD_SIGNAL */
648 	struct {
649 		int	cmd;
650 		int	sig;
651 		char	name[SESSION_MAX];
652 	} signal;
653 
654 	/* CMD_PING */
655 	struct {
656 		int	cmd;
657 		char	name[SESSION_MAX];
658 	} ping;
659 };
660 
661 enum {
662 	PING_OK	  = 0,
663 	PING_FAIL = 1,
664 	PING_MAX,
665 };
666 
daemon_session__ping(struct daemon_session * session)667 static int daemon_session__ping(struct daemon_session *session)
668 {
669 	return daemon_session__control(session, "ping", true) ?  PING_FAIL : PING_OK;
670 }
671 
cmd_session_list(struct daemon * daemon,union cmd * cmd,FILE * out)672 static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
673 {
674 	char csv_sep = cmd->list.csv_sep;
675 	struct daemon_session *session;
676 	time_t curr = time(NULL);
677 
678 	if (csv_sep) {
679 		fprintf(out, "%d%c%s%c%s%c%s/%s",
680 			/* pid daemon  */
681 			getpid(), csv_sep, "daemon",
682 			/* base */
683 			csv_sep, daemon->base,
684 			/* output */
685 			csv_sep, daemon->base, SESSION_OUTPUT);
686 
687 		fprintf(out, "%c%s/%s",
688 			/* lock */
689 			csv_sep, daemon->base, "lock");
690 
691 		fprintf(out, "%c%lu",
692 			/* session up time */
693 			csv_sep, (curr - daemon->start) / 60);
694 
695 		fprintf(out, "\n");
696 	} else {
697 		fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
698 		if (cmd->list.verbose) {
699 			fprintf(out, "  output:  %s/%s\n",
700 				daemon->base, SESSION_OUTPUT);
701 			fprintf(out, "  lock:    %s/lock\n",
702 				daemon->base);
703 			fprintf(out, "  up:      %lu minutes\n",
704 				(curr - daemon->start) / 60);
705 		}
706 	}
707 
708 	list_for_each_entry(session, &daemon->sessions, list) {
709 		if (csv_sep) {
710 			fprintf(out, "%d%c%s%c%s",
711 				/* pid */
712 				session->pid,
713 				/* name */
714 				csv_sep, session->name,
715 				/* base */
716 				csv_sep, session->run);
717 
718 			fprintf(out, "%c%s%c%s/%s",
719 				/* session dir */
720 				csv_sep, session->base,
721 				/* session output */
722 				csv_sep, session->base, SESSION_OUTPUT);
723 
724 			fprintf(out, "%c%s/%s%c%s/%s",
725 				/* session control */
726 				csv_sep, session->base, SESSION_CONTROL,
727 				/* session ack */
728 				csv_sep, session->base, SESSION_ACK);
729 
730 			fprintf(out, "%c%lu",
731 				/* session up time */
732 				csv_sep, (curr - session->start) / 60);
733 
734 			fprintf(out, "\n");
735 		} else {
736 			fprintf(out, "[%d:%s] perf record %s\n",
737 				session->pid, session->name, session->run);
738 			if (!cmd->list.verbose)
739 				continue;
740 			fprintf(out, "  base:    %s\n",
741 				session->base);
742 			fprintf(out, "  output:  %s/%s\n",
743 				session->base, SESSION_OUTPUT);
744 			fprintf(out, "  control: %s/%s\n",
745 				session->base, SESSION_CONTROL);
746 			fprintf(out, "  ack:     %s/%s\n",
747 				session->base, SESSION_ACK);
748 			fprintf(out, "  up:      %lu minutes\n",
749 				(curr - session->start) / 60);
750 		}
751 	}
752 
753 	return 0;
754 }
755 
daemon_session__signal(struct daemon_session * session,int sig)756 static int daemon_session__signal(struct daemon_session *session, int sig)
757 {
758 	if (session->pid < 0)
759 		return -1;
760 	return kill(session->pid, sig);
761 }
762 
cmd_session_kill(struct daemon * daemon,union cmd * cmd,FILE * out)763 static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
764 {
765 	struct daemon_session *session;
766 	bool all = false;
767 
768 	all = !strcmp(cmd->signal.name, "all");
769 
770 	list_for_each_entry(session, &daemon->sessions, list) {
771 		if (all || !strcmp(cmd->signal.name, session->name)) {
772 			daemon_session__signal(session, cmd->signal.sig);
773 			fprintf(out, "signal %d sent to session '%s [%d]'\n",
774 				cmd->signal.sig, session->name, session->pid);
775 		}
776 	}
777 
778 	return 0;
779 }
780 
781 static const char *ping_str[PING_MAX] = {
782 	[PING_OK]   = "OK",
783 	[PING_FAIL] = "FAIL",
784 };
785 
cmd_session_ping(struct daemon * daemon,union cmd * cmd,FILE * out)786 static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
787 {
788 	struct daemon_session *session;
789 	bool all = false, found = false;
790 
791 	all = !strcmp(cmd->ping.name, "all");
792 
793 	list_for_each_entry(session, &daemon->sessions, list) {
794 		if (all || !strcmp(cmd->ping.name, session->name)) {
795 			int state = daemon_session__ping(session);
796 
797 			fprintf(out, "%-4s %s\n", ping_str[state], session->name);
798 			found = true;
799 		}
800 	}
801 
802 	if (!found && !all) {
803 		fprintf(out, "%-4s %s (not found)\n",
804 			ping_str[PING_FAIL], cmd->ping.name);
805 	}
806 	return 0;
807 }
808 
handle_server_socket(struct daemon * daemon,int sock_fd)809 static int handle_server_socket(struct daemon *daemon, int sock_fd)
810 {
811 	int ret = -1, fd;
812 	FILE *out = NULL;
813 	union cmd cmd;
814 
815 	fd = accept(sock_fd, NULL, NULL);
816 	if (fd < 0) {
817 		perror("failed: accept");
818 		return -1;
819 	}
820 
821 	if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
822 		perror("failed: read");
823 		goto out;
824 	}
825 
826 	out = fdopen(fd, "w");
827 	if (!out) {
828 		perror("failed: fdopen");
829 		goto out;
830 	}
831 
832 	switch (cmd.cmd) {
833 	case CMD_LIST:
834 		ret = cmd_session_list(daemon, &cmd, out);
835 		break;
836 	case CMD_SIGNAL:
837 		ret = cmd_session_kill(daemon, &cmd, out);
838 		break;
839 	case CMD_STOP:
840 		done = 1;
841 		ret = 0;
842 		pr_debug("perf daemon is exciting\n");
843 		break;
844 	case CMD_PING:
845 		ret = cmd_session_ping(daemon, &cmd, out);
846 		break;
847 	default:
848 		break;
849 	}
850 
851 	fclose(out);
852 out:
853 	/* If out is defined, then fd is closed via fclose. */
854 	if (!out)
855 		close(fd);
856 	return ret;
857 }
858 
setup_client_socket(struct daemon * daemon)859 static int setup_client_socket(struct daemon *daemon)
860 {
861 	struct sockaddr_un addr;
862 	char path[PATH_MAX];
863 	int fd = socket(AF_UNIX, SOCK_STREAM, 0);
864 
865 	if (fd == -1) {
866 		perror("failed: socket");
867 		return -1;
868 	}
869 
870 	scnprintf(path, sizeof(path), "%s/control", daemon->base);
871 
872 	if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
873 		pr_err("failed: control path too long '%s'\n", path);
874 		close(fd);
875 		return -1;
876 	}
877 
878 	memset(&addr, 0, sizeof(addr));
879 	addr.sun_family = AF_UNIX;
880 	strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
881 
882 	if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
883 		perror("failed: connect");
884 		close(fd);
885 		return -1;
886 	}
887 
888 	return fd;
889 }
890 
daemon_session__kill(struct daemon_session * session,struct daemon * daemon)891 static void daemon_session__kill(struct daemon_session *session,
892 				 struct daemon *daemon)
893 {
894 	int how = 0;
895 
896 	do {
897 		switch (how) {
898 		case 0:
899 			daemon_session__control(session, "stop", false);
900 			break;
901 		case 1:
902 			daemon_session__signal(session, SIGTERM);
903 			break;
904 		case 2:
905 			daemon_session__signal(session, SIGKILL);
906 			break;
907 		default:
908 			pr_err("failed to wait for session %s\n",
909 			       session->name);
910 			return;
911 		}
912 		how++;
913 
914 	} while (daemon_session__wait(session, daemon, 10));
915 }
916 
daemon__signal(struct daemon * daemon,int sig)917 static void daemon__signal(struct daemon *daemon, int sig)
918 {
919 	struct daemon_session *session;
920 
921 	list_for_each_entry(session, &daemon->sessions, list)
922 		daemon_session__signal(session, sig);
923 }
924 
daemon_session__delete(struct daemon_session * session)925 static void daemon_session__delete(struct daemon_session *session)
926 {
927 	zfree(&session->base);
928 	zfree(&session->name);
929 	zfree(&session->run);
930 	free(session);
931 }
932 
daemon_session__remove(struct daemon_session * session)933 static void daemon_session__remove(struct daemon_session *session)
934 {
935 	list_del(&session->list);
936 	daemon_session__delete(session);
937 }
938 
daemon__stop(struct daemon * daemon)939 static void daemon__stop(struct daemon *daemon)
940 {
941 	struct daemon_session *session;
942 
943 	list_for_each_entry(session, &daemon->sessions, list)
944 		daemon_session__control(session, "stop", false);
945 }
946 
daemon__kill(struct daemon * daemon)947 static void daemon__kill(struct daemon *daemon)
948 {
949 	int how = 0;
950 
951 	do {
952 		switch (how) {
953 		case 0:
954 			daemon__stop(daemon);
955 			break;
956 		case 1:
957 			daemon__signal(daemon, SIGTERM);
958 			break;
959 		case 2:
960 			daemon__signal(daemon, SIGKILL);
961 			break;
962 		default:
963 			pr_err("failed to wait for sessions\n");
964 			return;
965 		}
966 		how++;
967 
968 	} while (daemon__wait(daemon, 10));
969 }
970 
daemon__exit(struct daemon * daemon)971 static void daemon__exit(struct daemon *daemon)
972 {
973 	struct daemon_session *session, *h;
974 
975 	list_for_each_entry_safe(session, h, &daemon->sessions, list)
976 		daemon_session__remove(session);
977 
978 	zfree(&daemon->config_real);
979 	zfree(&daemon->config_base);
980 	zfree(&daemon->base);
981 }
982 
daemon__reconfig(struct daemon * daemon)983 static int daemon__reconfig(struct daemon *daemon)
984 {
985 	struct daemon_session *session, *n;
986 
987 	list_for_each_entry_safe(session, n, &daemon->sessions, list) {
988 		/* No change. */
989 		if (session->state == OK)
990 			continue;
991 
992 		/* Remove session. */
993 		if (session->state == KILL) {
994 			if (session->pid > 0) {
995 				daemon_session__kill(session, daemon);
996 				pr_info("reconfig: session '%s' killed\n", session->name);
997 			}
998 			daemon_session__remove(session);
999 			continue;
1000 		}
1001 
1002 		/* Reconfig session. */
1003 		if (session->pid > 0) {
1004 			daemon_session__kill(session, daemon);
1005 			pr_info("reconfig: session '%s' killed\n", session->name);
1006 		}
1007 		if (daemon_session__run(session, daemon))
1008 			return -1;
1009 
1010 		session->state = OK;
1011 	}
1012 
1013 	return 0;
1014 }
1015 
setup_config_changes(struct daemon * daemon)1016 static int setup_config_changes(struct daemon *daemon)
1017 {
1018 	char *basen = strdup(daemon->config_real);
1019 	char *dirn  = strdup(daemon->config_real);
1020 	char *base, *dir;
1021 	int fd, wd = -1;
1022 
1023 	if (!dirn || !basen)
1024 		goto out;
1025 
1026 	fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
1027 	if (fd < 0) {
1028 		perror("failed: inotify_init");
1029 		goto out;
1030 	}
1031 
1032 	dir = dirname(dirn);
1033 	base = basename(basen);
1034 	pr_debug("config file: %s, dir: %s\n", base, dir);
1035 
1036 	wd = inotify_add_watch(fd, dir, IN_CLOSE_WRITE);
1037 	if (wd >= 0) {
1038 		daemon->config_base = strdup(base);
1039 		if (!daemon->config_base) {
1040 			close(fd);
1041 			wd = -1;
1042 		}
1043 	} else {
1044 		perror("failed: inotify_add_watch");
1045 	}
1046 
1047 out:
1048 	free(basen);
1049 	free(dirn);
1050 	return wd < 0 ? -1 : fd;
1051 }
1052 
process_inotify_event(struct daemon * daemon,char * buf,ssize_t len)1053 static bool process_inotify_event(struct daemon *daemon, char *buf, ssize_t len)
1054 {
1055 	char *p = buf;
1056 
1057 	while (p < (buf + len)) {
1058 		struct inotify_event *event = (struct inotify_event *) p;
1059 
1060 		/*
1061 		 * We monitor config directory, check if our
1062 		 * config file was changes.
1063 		 */
1064 		if ((event->mask & IN_CLOSE_WRITE) &&
1065 		    !(event->mask & IN_ISDIR)) {
1066 			if (!strcmp(event->name, daemon->config_base))
1067 				return true;
1068 		}
1069 		p += sizeof(*event) + event->len;
1070 	}
1071 	return false;
1072 }
1073 
handle_config_changes(struct daemon * daemon,int conf_fd,bool * config_changed)1074 static int handle_config_changes(struct daemon *daemon, int conf_fd,
1075 				 bool *config_changed)
1076 {
1077 	char buf[4096];
1078 	ssize_t len;
1079 
1080 	while (!(*config_changed)) {
1081 		len = read(conf_fd, buf, sizeof(buf));
1082 		if (len == -1) {
1083 			if (errno != EAGAIN) {
1084 				perror("failed: read");
1085 				return -1;
1086 			}
1087 			return 0;
1088 		}
1089 		*config_changed = process_inotify_event(daemon, buf, len);
1090 	}
1091 	return 0;
1092 }
1093 
setup_config(struct daemon * daemon)1094 static int setup_config(struct daemon *daemon)
1095 {
1096 	if (daemon->base_user) {
1097 		daemon->base = strdup(daemon->base_user);
1098 		if (!daemon->base)
1099 			return -ENOMEM;
1100 	}
1101 
1102 	if (daemon->config) {
1103 		char *real = realpath(daemon->config, NULL);
1104 
1105 		if (!real) {
1106 			perror("failed: realpath");
1107 			return -1;
1108 		}
1109 		daemon->config_real = real;
1110 		return 0;
1111 	}
1112 
1113 	if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK))
1114 		daemon->config_real = strdup(perf_etc_perfconfig());
1115 	else if (perf_config_global() && perf_home_perfconfig())
1116 		daemon->config_real = strdup(perf_home_perfconfig());
1117 
1118 	return daemon->config_real ? 0 : -1;
1119 }
1120 
1121 #ifndef F_TLOCK
1122 #define F_TLOCK 2
1123 
lockf(int fd,int cmd,off_t len)1124 static int lockf(int fd, int cmd, off_t len)
1125 {
1126 	if (cmd != F_TLOCK || len != 0)
1127 		return -1;
1128 
1129 	return flock(fd, LOCK_EX | LOCK_NB);
1130 }
1131 #endif // F_TLOCK
1132 
1133 /*
1134  * Each daemon tries to create and lock BASE/lock file,
1135  * if it's successful we are sure we're the only daemon
1136  * running over the BASE.
1137  *
1138  * Once daemon is finished, file descriptor to lock file
1139  * is closed and lock is released.
1140  */
check_lock(struct daemon * daemon)1141 static int check_lock(struct daemon *daemon)
1142 {
1143 	char path[PATH_MAX];
1144 	char buf[20];
1145 	int fd, pid;
1146 	ssize_t len;
1147 
1148 	scnprintf(path, sizeof(path), "%s/lock", daemon->base);
1149 
1150 	fd = open(path, O_RDWR|O_CREAT|O_CLOEXEC, 0640);
1151 	if (fd < 0)
1152 		return -1;
1153 
1154 	if (lockf(fd, F_TLOCK, 0) < 0) {
1155 		filename__read_int(path, &pid);
1156 		fprintf(stderr, "failed: another perf daemon (pid %d) owns %s\n",
1157 			pid, daemon->base);
1158 		close(fd);
1159 		return -1;
1160 	}
1161 
1162 	scnprintf(buf, sizeof(buf), "%d", getpid());
1163 	len = strlen(buf);
1164 
1165 	if (write(fd, buf, len) != len) {
1166 		perror("failed: write");
1167 		close(fd);
1168 		return -1;
1169 	}
1170 
1171 	if (ftruncate(fd, len)) {
1172 		perror("failed: ftruncate");
1173 		close(fd);
1174 		return -1;
1175 	}
1176 
1177 	return 0;
1178 }
1179 
go_background(struct daemon * daemon)1180 static int go_background(struct daemon *daemon)
1181 {
1182 	int pid, fd;
1183 
1184 	pid = fork();
1185 	if (pid < 0)
1186 		return -1;
1187 
1188 	if (pid > 0)
1189 		return 1;
1190 
1191 	if (setsid() < 0)
1192 		return -1;
1193 
1194 	if (check_lock(daemon))
1195 		return -1;
1196 
1197 	umask(0);
1198 
1199 	if (chdir(daemon->base)) {
1200 		perror("failed: chdir");
1201 		return -1;
1202 	}
1203 
1204 	fd = open("output", O_RDWR|O_CREAT|O_TRUNC, 0644);
1205 	if (fd < 0) {
1206 		perror("failed: open");
1207 		return -1;
1208 	}
1209 
1210 	if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
1211 		perror("failed: fcntl FD_CLOEXEC");
1212 		close(fd);
1213 		return -1;
1214 	}
1215 
1216 	close(0);
1217 	dup2(fd, 1);
1218 	dup2(fd, 2);
1219 	close(fd);
1220 
1221 	daemon->out = fdopen(1, "w");
1222 	if (!daemon->out) {
1223 		close(1);
1224 		close(2);
1225 		return -1;
1226 	}
1227 
1228 	setbuf(daemon->out, NULL);
1229 	return 0;
1230 }
1231 
setup_signalfd(struct daemon * daemon)1232 static int setup_signalfd(struct daemon *daemon)
1233 {
1234 	sigset_t mask;
1235 
1236 	sigemptyset(&mask);
1237 	sigaddset(&mask, SIGCHLD);
1238 
1239 	if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
1240 		return -1;
1241 
1242 	daemon->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1243 	return daemon->signal_fd;
1244 }
1245 
__cmd_start(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1246 static int __cmd_start(struct daemon *daemon, struct option parent_options[],
1247 		       int argc, const char **argv)
1248 {
1249 	bool foreground = false;
1250 	struct option start_options[] = {
1251 		OPT_BOOLEAN('f', "foreground", &foreground, "stay on console"),
1252 		OPT_PARENT(parent_options),
1253 		OPT_END()
1254 	};
1255 	int sock_fd = -1, conf_fd = -1, signal_fd = -1;
1256 	int sock_pos, file_pos, signal_pos;
1257 	struct fdarray fda;
1258 	int err = 0;
1259 
1260 	argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1261 	if (argc)
1262 		usage_with_options(daemon_usage, start_options);
1263 
1264 	daemon->start = time(NULL);
1265 
1266 	if (setup_config(daemon)) {
1267 		pr_err("failed: config not found\n");
1268 		return -1;
1269 	}
1270 
1271 	if (setup_server_config(daemon))
1272 		return -1;
1273 
1274 	if (foreground && check_lock(daemon))
1275 		return -1;
1276 
1277 	if (!foreground) {
1278 		err = go_background(daemon);
1279 		if (err) {
1280 			/* original process, exit normally */
1281 			if (err == 1)
1282 				err = 0;
1283 			daemon__exit(daemon);
1284 			return err;
1285 		}
1286 	}
1287 
1288 	debug_set_file(daemon->out);
1289 	debug_set_display_time(true);
1290 
1291 	pr_info("daemon started (pid %d)\n", getpid());
1292 
1293 	fdarray__init(&fda, 3);
1294 
1295 	sock_fd = setup_server_socket(daemon);
1296 	if (sock_fd < 0)
1297 		goto out;
1298 
1299 	conf_fd = setup_config_changes(daemon);
1300 	if (conf_fd < 0)
1301 		goto out;
1302 
1303 	signal_fd = setup_signalfd(daemon);
1304 	if (signal_fd < 0)
1305 		goto out;
1306 
1307 	sock_pos = fdarray__add(&fda, sock_fd, POLLIN|POLLERR|POLLHUP, 0);
1308 	if (sock_pos < 0)
1309 		goto out;
1310 
1311 	file_pos = fdarray__add(&fda, conf_fd, POLLIN|POLLERR|POLLHUP, 0);
1312 	if (file_pos < 0)
1313 		goto out;
1314 
1315 	signal_pos = fdarray__add(&fda, signal_fd, POLLIN|POLLERR|POLLHUP, 0);
1316 	if (signal_pos < 0)
1317 		goto out;
1318 
1319 	signal(SIGINT, sig_handler);
1320 	signal(SIGTERM, sig_handler);
1321 	signal(SIGPIPE, SIG_IGN);
1322 
1323 	while (!done && !err) {
1324 		err = daemon__reconfig(daemon);
1325 
1326 		if (!err && fdarray__poll(&fda, -1)) {
1327 			bool reconfig = false;
1328 
1329 			if (fda.entries[sock_pos].revents & POLLIN)
1330 				err = handle_server_socket(daemon, sock_fd);
1331 			if (fda.entries[file_pos].revents & POLLIN)
1332 				err = handle_config_changes(daemon, conf_fd, &reconfig);
1333 			if (fda.entries[signal_pos].revents & POLLIN)
1334 				err = handle_signalfd(daemon) < 0;
1335 
1336 			if (reconfig)
1337 				err = setup_server_config(daemon);
1338 		}
1339 	}
1340 
1341 out:
1342 	fdarray__exit(&fda);
1343 
1344 	daemon__kill(daemon);
1345 	daemon__exit(daemon);
1346 
1347 	if (sock_fd != -1)
1348 		close(sock_fd);
1349 	if (conf_fd != -1)
1350 		close(conf_fd);
1351 	if (signal_fd != -1)
1352 		close(signal_fd);
1353 
1354 	pr_info("daemon exited\n");
1355 	fclose(daemon->out);
1356 	return err;
1357 }
1358 
send_cmd(struct daemon * daemon,union cmd * cmd)1359 static int send_cmd(struct daemon *daemon, union cmd *cmd)
1360 {
1361 	int ret = -1, fd;
1362 	char *line = NULL;
1363 	size_t len = 0;
1364 	ssize_t nread;
1365 	FILE *in = NULL;
1366 
1367 	if (setup_client_config(daemon))
1368 		return -1;
1369 
1370 	fd = setup_client_socket(daemon);
1371 	if (fd < 0)
1372 		return -1;
1373 
1374 	if (sizeof(*cmd) != writen(fd, cmd, sizeof(*cmd))) {
1375 		perror("failed: write");
1376 		goto out;
1377 	}
1378 
1379 	in = fdopen(fd, "r");
1380 	if (!in) {
1381 		perror("failed: fdopen");
1382 		goto out;
1383 	}
1384 
1385 	while ((nread = getline(&line, &len, in)) != -1) {
1386 		if (fwrite(line, nread, 1, stdout) != 1)
1387 			goto out_fclose;
1388 		fflush(stdout);
1389 	}
1390 
1391 	ret = 0;
1392 out_fclose:
1393 	fclose(in);
1394 	free(line);
1395 out:
1396 	/* If in is defined, then fd is closed via fclose. */
1397 	if (!in)
1398 		close(fd);
1399 	return ret;
1400 }
1401 
send_cmd_list(struct daemon * daemon)1402 static int send_cmd_list(struct daemon *daemon)
1403 {
1404 	union cmd cmd;
1405 
1406 	memset(&cmd, 0, sizeof(cmd));
1407 	cmd.list.cmd = CMD_LIST;
1408 	cmd.list.verbose = verbose;
1409 	cmd.list.csv_sep = daemon->csv_sep ? *daemon->csv_sep : 0;
1410 
1411 	return send_cmd(daemon, &cmd);
1412 }
1413 
__cmd_signal(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1414 static int __cmd_signal(struct daemon *daemon, struct option parent_options[],
1415 			int argc, const char **argv)
1416 {
1417 	const char *name = "all";
1418 	struct option start_options[] = {
1419 		OPT_STRING(0, "session", &name, "session",
1420 			"Sent signal to specific session"),
1421 		OPT_PARENT(parent_options),
1422 		OPT_END()
1423 	};
1424 	union cmd cmd;
1425 
1426 	argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1427 	if (argc)
1428 		usage_with_options(daemon_usage, start_options);
1429 
1430 	if (setup_config(daemon)) {
1431 		pr_err("failed: config not found\n");
1432 		return -1;
1433 	}
1434 
1435 	memset(&cmd, 0, sizeof(cmd));
1436 	cmd.signal.cmd = CMD_SIGNAL,
1437 	cmd.signal.sig = SIGUSR2;
1438 	strncpy(cmd.signal.name, name, sizeof(cmd.signal.name) - 1);
1439 
1440 	return send_cmd(daemon, &cmd);
1441 }
1442 
__cmd_stop(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1443 static int __cmd_stop(struct daemon *daemon, struct option parent_options[],
1444 			int argc, const char **argv)
1445 {
1446 	struct option start_options[] = {
1447 		OPT_PARENT(parent_options),
1448 		OPT_END()
1449 	};
1450 	union cmd cmd;
1451 
1452 	argc = parse_options(argc, argv, start_options, daemon_usage, 0);
1453 	if (argc)
1454 		usage_with_options(daemon_usage, start_options);
1455 
1456 	if (setup_config(daemon)) {
1457 		pr_err("failed: config not found\n");
1458 		return -1;
1459 	}
1460 
1461 	memset(&cmd, 0, sizeof(cmd));
1462 	cmd.cmd = CMD_STOP;
1463 	return send_cmd(daemon, &cmd);
1464 }
1465 
__cmd_ping(struct daemon * daemon,struct option parent_options[],int argc,const char ** argv)1466 static int __cmd_ping(struct daemon *daemon, struct option parent_options[],
1467 		      int argc, const char **argv)
1468 {
1469 	const char *name = "all";
1470 	struct option ping_options[] = {
1471 		OPT_STRING(0, "session", &name, "session",
1472 			"Ping to specific session"),
1473 		OPT_PARENT(parent_options),
1474 		OPT_END()
1475 	};
1476 	union cmd cmd;
1477 
1478 	argc = parse_options(argc, argv, ping_options, daemon_usage, 0);
1479 	if (argc)
1480 		usage_with_options(daemon_usage, ping_options);
1481 
1482 	if (setup_config(daemon)) {
1483 		pr_err("failed: config not found\n");
1484 		return -1;
1485 	}
1486 
1487 	memset(&cmd, 0, sizeof(cmd));
1488 	cmd.cmd = CMD_PING;
1489 	scnprintf(cmd.ping.name, sizeof(cmd.ping.name), "%s", name);
1490 	return send_cmd(daemon, &cmd);
1491 }
1492 
alloc_perf_exe_path(void)1493 static char *alloc_perf_exe_path(void)
1494 {
1495 	char path[PATH_MAX];
1496 
1497 	perf_exe(path, sizeof(path));
1498 	return strdup(path);
1499 }
1500 
cmd_daemon(int argc,const char ** argv)1501 int cmd_daemon(int argc, const char **argv)
1502 {
1503 	struct option daemon_options[] = {
1504 		OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1505 		OPT_STRING(0, "config", &__daemon.config,
1506 			"config file", "config file path"),
1507 		OPT_STRING(0, "base", &__daemon.base_user,
1508 			"directory", "base directory"),
1509 		OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
1510 			"field separator", "print counts with custom separator", ","),
1511 		OPT_END()
1512 	};
1513 	int ret = -1;
1514 
1515 	__daemon.perf = alloc_perf_exe_path();
1516 	if (!__daemon.perf)
1517 		return -ENOMEM;
1518 
1519 	__daemon.out = stdout;
1520 
1521 	argc = parse_options(argc, argv, daemon_options, daemon_usage,
1522 			     PARSE_OPT_STOP_AT_NON_OPTION);
1523 
1524 	if (argc) {
1525 		if (!strcmp(argv[0], "start"))
1526 			ret = __cmd_start(&__daemon, daemon_options, argc, argv);
1527 		else if (!strcmp(argv[0], "signal"))
1528 			ret = __cmd_signal(&__daemon, daemon_options, argc, argv);
1529 		else if (!strcmp(argv[0], "stop"))
1530 			ret = __cmd_stop(&__daemon, daemon_options, argc, argv);
1531 		else if (!strcmp(argv[0], "ping"))
1532 			ret = __cmd_ping(&__daemon, daemon_options, argc, argv);
1533 		else
1534 			pr_err("failed: unknown command '%s'\n", argv[0]);
1535 	} else {
1536 		ret = setup_config(&__daemon);
1537 		if (ret)
1538 			pr_err("failed: config not found\n");
1539 		else
1540 			ret = send_cmd_list(&__daemon);
1541 	}
1542 	zfree(&__daemon.perf);
1543 	return ret;
1544 }
1545