Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <internal/lib.h>
0003 #include <subcmd/parse-options.h>
0004 #include <api/fd/array.h>
0005 #include <api/fs/fs.h>
0006 #include <linux/zalloc.h>
0007 #include <linux/string.h>
0008 #include <linux/limits.h>
0009 #include <string.h>
0010 #include <sys/file.h>
0011 #include <signal.h>
0012 #include <stdlib.h>
0013 #include <time.h>
0014 #include <stdio.h>
0015 #include <unistd.h>
0016 #include <errno.h>
0017 #include <sys/inotify.h>
0018 #include <libgen.h>
0019 #include <sys/types.h>
0020 #include <sys/socket.h>
0021 #include <sys/un.h>
0022 #include <sys/stat.h>
0023 #include <sys/signalfd.h>
0024 #include <sys/wait.h>
0025 #include <poll.h>
0026 #include "builtin.h"
0027 #include "perf.h"
0028 #include "debug.h"
0029 #include "config.h"
0030 #include "util.h"
0031 
0032 #define SESSION_OUTPUT  "output"
0033 #define SESSION_CONTROL "control"
0034 #define SESSION_ACK     "ack"
0035 
0036 /*
0037  * Session states:
0038  *
0039  *   OK       - session is up and running
0040  *   RECONFIG - session is pending for reconfiguration,
0041  *              new values are already loaded in session object
0042  *   KILL     - session is pending to be killed
0043  *
0044  * Session object life and its state is maintained by
0045  * following functions:
0046  *
0047  *  setup_server_config
0048  *    - reads config file and setup session objects
0049  *      with following states:
0050  *
0051  *      OK       - no change needed
0052  *      RECONFIG - session needs to be changed
0053  *                 (run variable changed)
0054  *      KILL     - session needs to be killed
0055  *                 (session is no longer in config file)
0056  *
0057  *  daemon__reconfig
0058  *    - scans session objects and does following actions
0059  *      for states:
0060  *
0061  *      OK       - skip
0062  *      RECONFIG - session is killed and re-run with new config
0063  *      KILL     - session is killed
0064  *
0065  *    - all sessions have OK state on the function exit
0066  */
0067 enum daemon_session_state {
0068     OK,
0069     RECONFIG,
0070     KILL,
0071 };
0072 
0073 struct daemon_session {
0074     char                *base;
0075     char                *name;
0076     char                *run;
0077     char                *control;
0078     int              pid;
0079     struct list_head         list;
0080     enum daemon_session_state    state;
0081     time_t               start;
0082 };
0083 
0084 struct daemon {
0085     const char      *config;
0086     char            *config_real;
0087     char            *config_base;
0088     const char      *csv_sep;
0089     const char      *base_user;
0090     char            *base;
0091     struct list_head     sessions;
0092     FILE            *out;
0093     char             perf[PATH_MAX];
0094     int          signal_fd;
0095     time_t           start;
0096 };
0097 
0098 static struct daemon __daemon = {
0099     .sessions = LIST_HEAD_INIT(__daemon.sessions),
0100 };
0101 
0102 static const char * const daemon_usage[] = {
0103     "perf daemon start [<options>]",
0104     "perf daemon [<options>]",
0105     NULL
0106 };
0107 
0108 static bool done;
0109 
0110 static void sig_handler(int sig __maybe_unused)
0111 {
0112     done = true;
0113 }
0114 
0115 static struct daemon_session *daemon__add_session(struct daemon *config, char *name)
0116 {
0117     struct daemon_session *session = zalloc(sizeof(*session));
0118 
0119     if (!session)
0120         return NULL;
0121 
0122     session->name = strdup(name);
0123     if (!session->name) {
0124         free(session);
0125         return NULL;
0126     }
0127 
0128     session->pid = -1;
0129     list_add_tail(&session->list, &config->sessions);
0130     return session;
0131 }
0132 
0133 static struct daemon_session *daemon__find_session(struct daemon *daemon, char *name)
0134 {
0135     struct daemon_session *session;
0136 
0137     list_for_each_entry(session, &daemon->sessions, list) {
0138         if (!strcmp(session->name, name))
0139             return session;
0140     }
0141 
0142     return NULL;
0143 }
0144 
0145 static int get_session_name(const char *var, char *session, int len)
0146 {
0147     const char *p = var + sizeof("session-") - 1;
0148 
0149     while (*p != '.' && *p != 0x0 && len--)
0150         *session++ = *p++;
0151 
0152     *session = 0;
0153     return *p == '.' ? 0 : -EINVAL;
0154 }
0155 
0156 static int session_config(struct daemon *daemon, const char *var, const char *value)
0157 {
0158     struct daemon_session *session;
0159     char name[100];
0160 
0161     if (get_session_name(var, name, sizeof(name) - 1))
0162         return -EINVAL;
0163 
0164     var = strchr(var, '.');
0165     if (!var)
0166         return -EINVAL;
0167 
0168     var++;
0169 
0170     session = daemon__find_session(daemon, name);
0171 
0172     if (!session) {
0173         /* New session is defined. */
0174         session = daemon__add_session(daemon, name);
0175         if (!session)
0176             return -ENOMEM;
0177 
0178         pr_debug("reconfig: found new session %s\n", name);
0179 
0180         /* Trigger reconfig to start it. */
0181         session->state = RECONFIG;
0182     } else if (session->state == KILL) {
0183         /* Current session is defined, no action needed. */
0184         pr_debug("reconfig: found current session %s\n", name);
0185         session->state = OK;
0186     }
0187 
0188     if (!strcmp(var, "run")) {
0189         bool same = false;
0190 
0191         if (session->run)
0192             same = !strcmp(session->run, value);
0193 
0194         if (!same) {
0195             if (session->run) {
0196                 free(session->run);
0197                 pr_debug("reconfig: session %s is changed\n", name);
0198             }
0199 
0200             session->run = strdup(value);
0201             if (!session->run)
0202                 return -ENOMEM;
0203 
0204             /*
0205              * Either new or changed run value is defined,
0206              * trigger reconfig for the session.
0207              */
0208             session->state = RECONFIG;
0209         }
0210     }
0211 
0212     return 0;
0213 }
0214 
0215 static int server_config(const char *var, const char *value, void *cb)
0216 {
0217     struct daemon *daemon = cb;
0218 
0219     if (strstarts(var, "session-")) {
0220         return session_config(daemon, var, value);
0221     } else if (!strcmp(var, "daemon.base") && !daemon->base_user) {
0222         if (daemon->base && strcmp(daemon->base, value)) {
0223             pr_err("failed: can't redefine base, bailing out\n");
0224             return -EINVAL;
0225         }
0226         daemon->base = strdup(value);
0227         if (!daemon->base)
0228             return -ENOMEM;
0229     }
0230 
0231     return 0;
0232 }
0233 
0234 static int client_config(const char *var, const char *value, void *cb)
0235 {
0236     struct daemon *daemon = cb;
0237 
0238     if (!strcmp(var, "daemon.base") && !daemon->base_user) {
0239         daemon->base = strdup(value);
0240         if (!daemon->base)
0241             return -ENOMEM;
0242     }
0243 
0244     return 0;
0245 }
0246 
0247 static int check_base(struct daemon *daemon)
0248 {
0249     struct stat st;
0250 
0251     if (!daemon->base) {
0252         pr_err("failed: base not defined\n");
0253         return -EINVAL;
0254     }
0255 
0256     if (stat(daemon->base, &st)) {
0257         switch (errno) {
0258         case EACCES:
0259             pr_err("failed: permission denied for '%s' base\n",
0260                    daemon->base);
0261             return -EACCES;
0262         case ENOENT:
0263             pr_err("failed: base '%s' does not exists\n",
0264                    daemon->base);
0265             return -EACCES;
0266         default:
0267             pr_err("failed: can't access base '%s': %s\n",
0268                    daemon->base, strerror(errno));
0269             return -errno;
0270         }
0271     }
0272 
0273     if ((st.st_mode & S_IFMT) != S_IFDIR) {
0274         pr_err("failed: base '%s' is not directory\n",
0275                daemon->base);
0276         return -EINVAL;
0277     }
0278 
0279     return 0;
0280 }
0281 
0282 static int setup_client_config(struct daemon *daemon)
0283 {
0284     struct perf_config_set *set = perf_config_set__load_file(daemon->config_real);
0285     int err = -ENOMEM;
0286 
0287     if (set) {
0288         err = perf_config_set(set, client_config, daemon);
0289         perf_config_set__delete(set);
0290     }
0291 
0292     return err ?: check_base(daemon);
0293 }
0294 
0295 static int setup_server_config(struct daemon *daemon)
0296 {
0297     struct perf_config_set *set;
0298     struct daemon_session *session;
0299     int err = -ENOMEM;
0300 
0301     pr_debug("reconfig: started\n");
0302 
0303     /*
0304      * Mark all sessions for kill, the server config
0305      * will set following states, see explanation at
0306      * enum daemon_session_state declaration.
0307      */
0308     list_for_each_entry(session, &daemon->sessions, list)
0309         session->state = KILL;
0310 
0311     set = perf_config_set__load_file(daemon->config_real);
0312     if (set) {
0313         err = perf_config_set(set, server_config, daemon);
0314         perf_config_set__delete(set);
0315     }
0316 
0317     return err ?: check_base(daemon);
0318 }
0319 
0320 static int daemon_session__run(struct daemon_session *session,
0321                    struct daemon *daemon)
0322 {
0323     char buf[PATH_MAX];
0324     char **argv;
0325     int argc, fd;
0326 
0327     if (asprintf(&session->base, "%s/session-%s",
0328              daemon->base, session->name) < 0) {
0329         perror("failed: asprintf");
0330         return -1;
0331     }
0332 
0333     if (mkdir(session->base, 0755) && errno != EEXIST) {
0334         perror("failed: mkdir");
0335         return -1;
0336     }
0337 
0338     session->start = time(NULL);
0339 
0340     session->pid = fork();
0341     if (session->pid < 0)
0342         return -1;
0343     if (session->pid > 0) {
0344         pr_info("reconfig: ruining session [%s:%d]: %s\n",
0345             session->name, session->pid, session->run);
0346         return 0;
0347     }
0348 
0349     if (chdir(session->base)) {
0350         perror("failed: chdir");
0351         return -1;
0352     }
0353 
0354     fd = open("/dev/null", O_RDONLY);
0355     if (fd < 0) {
0356         perror("failed: open /dev/null");
0357         return -1;
0358     }
0359 
0360     dup2(fd, 0);
0361     close(fd);
0362 
0363     fd = open(SESSION_OUTPUT, O_RDWR|O_CREAT|O_TRUNC, 0644);
0364     if (fd < 0) {
0365         perror("failed: open session output");
0366         return -1;
0367     }
0368 
0369     dup2(fd, 1);
0370     dup2(fd, 2);
0371     close(fd);
0372 
0373     if (mkfifo(SESSION_CONTROL, 0600) && errno != EEXIST) {
0374         perror("failed: create control fifo");
0375         return -1;
0376     }
0377 
0378     if (mkfifo(SESSION_ACK, 0600) && errno != EEXIST) {
0379         perror("failed: create ack fifo");
0380         return -1;
0381     }
0382 
0383     scnprintf(buf, sizeof(buf), "%s record --control=fifo:%s,%s %s",
0384           daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);
0385 
0386     argv = argv_split(buf, &argc);
0387     if (!argv)
0388         exit(-1);
0389 
0390     exit(execve(daemon->perf, argv, NULL));
0391     return -1;
0392 }
0393 
0394 static pid_t handle_signalfd(struct daemon *daemon)
0395 {
0396     struct daemon_session *session;
0397     struct signalfd_siginfo si;
0398     ssize_t err;
0399     int status;
0400     pid_t pid;
0401 
0402     /*
0403      * Take signal fd data as pure signal notification and check all
0404      * the sessions state. The reason is that multiple signals can get
0405      * coalesced in kernel and we can receive only single signal even
0406      * if multiple SIGCHLD were generated.
0407      */
0408     err = read(daemon->signal_fd, &si, sizeof(struct signalfd_siginfo));
0409     if (err != sizeof(struct signalfd_siginfo)) {
0410         pr_err("failed to read signal fd\n");
0411         return -1;
0412     }
0413 
0414     list_for_each_entry(session, &daemon->sessions, list) {
0415         if (session->pid == -1)
0416             continue;
0417 
0418         pid = waitpid(session->pid, &status, WNOHANG);
0419         if (pid <= 0)
0420             continue;
0421 
0422         if (WIFEXITED(status)) {
0423             pr_info("session '%s' exited, status=%d\n",
0424                 session->name, WEXITSTATUS(status));
0425         } else if (WIFSIGNALED(status)) {
0426             pr_info("session '%s' killed (signal %d)\n",
0427                 session->name, WTERMSIG(status));
0428         } else if (WIFSTOPPED(status)) {
0429             pr_info("session '%s' stopped (signal %d)\n",
0430                 session->name, WSTOPSIG(status));
0431         } else {
0432             pr_info("session '%s' Unexpected status (0x%x)\n",
0433                 session->name, status);
0434         }
0435 
0436         session->state = KILL;
0437         session->pid = -1;
0438     }
0439 
0440     return 0;
0441 }
0442 
0443 static int daemon_session__wait(struct daemon_session *session, struct daemon *daemon,
0444                 int secs)
0445 {
0446     struct pollfd pollfd = {
0447         .fd = daemon->signal_fd,
0448         .events = POLLIN,
0449     };
0450     time_t start;
0451 
0452     start = time(NULL);
0453 
0454     do {
0455         int err = poll(&pollfd, 1, 1000);
0456 
0457         if (err > 0) {
0458             handle_signalfd(daemon);
0459         } else if (err < 0) {
0460             perror("failed: poll\n");
0461             return -1;
0462         }
0463 
0464         if (start + secs < time(NULL))
0465             return -1;
0466     } while (session->pid != -1);
0467 
0468     return 0;
0469 }
0470 
0471 static bool daemon__has_alive_session(struct daemon *daemon)
0472 {
0473     struct daemon_session *session;
0474 
0475     list_for_each_entry(session, &daemon->sessions, list) {
0476         if (session->pid != -1)
0477             return true;
0478     }
0479 
0480     return false;
0481 }
0482 
0483 static int daemon__wait(struct daemon *daemon, int secs)
0484 {
0485     struct pollfd pollfd = {
0486         .fd = daemon->signal_fd,
0487         .events = POLLIN,
0488     };
0489     time_t start;
0490 
0491     start = time(NULL);
0492 
0493     do {
0494         int err = poll(&pollfd, 1, 1000);
0495 
0496         if (err > 0) {
0497             handle_signalfd(daemon);
0498         } else if (err < 0) {
0499             perror("failed: poll\n");
0500             return -1;
0501         }
0502 
0503         if (start + secs < time(NULL))
0504             return -1;
0505     } while (daemon__has_alive_session(daemon));
0506 
0507     return 0;
0508 }
0509 
0510 static int daemon_session__control(struct daemon_session *session,
0511                    const char *msg, bool do_ack)
0512 {
0513     struct pollfd pollfd = { .events = POLLIN, };
0514     char control_path[PATH_MAX];
0515     char ack_path[PATH_MAX];
0516     int control, ack = -1, len;
0517     char buf[20];
0518     int ret = -1;
0519     ssize_t err;
0520 
0521     /* open the control file */
0522     scnprintf(control_path, sizeof(control_path), "%s/%s",
0523           session->base, SESSION_CONTROL);
0524 
0525     control = open(control_path, O_WRONLY|O_NONBLOCK);
0526     if (!control)
0527         return -1;
0528 
0529     if (do_ack) {
0530         /* open the ack file */
0531         scnprintf(ack_path, sizeof(ack_path), "%s/%s",
0532               session->base, SESSION_ACK);
0533 
0534         ack = open(ack_path, O_RDONLY, O_NONBLOCK);
0535         if (!ack) {
0536             close(control);
0537             return -1;
0538         }
0539     }
0540 
0541     /* write the command */
0542     len = strlen(msg);
0543 
0544     err = writen(control, msg, len);
0545     if (err != len) {
0546         pr_err("failed: write to control pipe: %d (%s)\n",
0547                errno, control_path);
0548         goto out;
0549     }
0550 
0551     if (!do_ack)
0552         goto out;
0553 
0554     /* wait for an ack */
0555     pollfd.fd = ack;
0556 
0557     if (!poll(&pollfd, 1, 2000)) {
0558         pr_err("failed: control ack timeout\n");
0559         goto out;
0560     }
0561 
0562     if (!(pollfd.revents & POLLIN)) {
0563         pr_err("failed: did not received an ack\n");
0564         goto out;
0565     }
0566 
0567     err = read(ack, buf, sizeof(buf));
0568     if (err > 0)
0569         ret = strcmp(buf, "ack\n");
0570     else
0571         perror("failed: read ack %d\n");
0572 
0573 out:
0574     if (ack != -1)
0575         close(ack);
0576 
0577     close(control);
0578     return ret;
0579 }
0580 
0581 static int setup_server_socket(struct daemon *daemon)
0582 {
0583     struct sockaddr_un addr;
0584     char path[PATH_MAX];
0585     int fd = socket(AF_UNIX, SOCK_STREAM, 0);
0586 
0587     if (fd < 0) {
0588         fprintf(stderr, "socket: %s\n", strerror(errno));
0589         return -1;
0590     }
0591 
0592     if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
0593         perror("failed: fcntl FD_CLOEXEC");
0594         close(fd);
0595         return -1;
0596     }
0597 
0598     scnprintf(path, sizeof(path), "%s/control", daemon->base);
0599 
0600     if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
0601         pr_err("failed: control path too long '%s'\n", path);
0602         close(fd);
0603         return -1;
0604     }
0605 
0606     memset(&addr, 0, sizeof(addr));
0607     addr.sun_family = AF_UNIX;
0608 
0609     strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
0610     unlink(path);
0611 
0612     if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
0613         perror("failed: bind");
0614         close(fd);
0615         return -1;
0616     }
0617 
0618     if (listen(fd, 1) == -1) {
0619         perror("failed: listen");
0620         close(fd);
0621         return -1;
0622     }
0623 
0624     return fd;
0625 }
0626 
0627 enum {
0628     CMD_LIST   = 0,
0629     CMD_SIGNAL = 1,
0630     CMD_STOP   = 2,
0631     CMD_PING   = 3,
0632     CMD_MAX,
0633 };
0634 
0635 #define SESSION_MAX 64
0636 
0637 union cmd {
0638     int cmd;
0639 
0640     /* CMD_LIST */
0641     struct {
0642         int cmd;
0643         int verbose;
0644         char    csv_sep;
0645     } list;
0646 
0647     /* CMD_SIGNAL */
0648     struct {
0649         int cmd;
0650         int sig;
0651         char    name[SESSION_MAX];
0652     } signal;
0653 
0654     /* CMD_PING */
0655     struct {
0656         int cmd;
0657         char    name[SESSION_MAX];
0658     } ping;
0659 };
0660 
0661 enum {
0662     PING_OK   = 0,
0663     PING_FAIL = 1,
0664     PING_MAX,
0665 };
0666 
0667 static int daemon_session__ping(struct daemon_session *session)
0668 {
0669     return daemon_session__control(session, "ping", true) ?  PING_FAIL : PING_OK;
0670 }
0671 
0672 static int cmd_session_list(struct daemon *daemon, union cmd *cmd, FILE *out)
0673 {
0674     char csv_sep = cmd->list.csv_sep;
0675     struct daemon_session *session;
0676     time_t curr = time(NULL);
0677 
0678     if (csv_sep) {
0679         fprintf(out, "%d%c%s%c%s%c%s/%s",
0680             /* pid daemon  */
0681             getpid(), csv_sep, "daemon",
0682             /* base */
0683             csv_sep, daemon->base,
0684             /* output */
0685             csv_sep, daemon->base, SESSION_OUTPUT);
0686 
0687         fprintf(out, "%c%s/%s",
0688             /* lock */
0689             csv_sep, daemon->base, "lock");
0690 
0691         fprintf(out, "%c%lu",
0692             /* session up time */
0693             csv_sep, (curr - daemon->start) / 60);
0694 
0695         fprintf(out, "\n");
0696     } else {
0697         fprintf(out, "[%d:daemon] base: %s\n", getpid(), daemon->base);
0698         if (cmd->list.verbose) {
0699             fprintf(out, "  output:  %s/%s\n",
0700                 daemon->base, SESSION_OUTPUT);
0701             fprintf(out, "  lock:    %s/lock\n",
0702                 daemon->base);
0703             fprintf(out, "  up:      %lu minutes\n",
0704                 (curr - daemon->start) / 60);
0705         }
0706     }
0707 
0708     list_for_each_entry(session, &daemon->sessions, list) {
0709         if (csv_sep) {
0710             fprintf(out, "%d%c%s%c%s",
0711                 /* pid */
0712                 session->pid,
0713                 /* name */
0714                 csv_sep, session->name,
0715                 /* base */
0716                 csv_sep, session->run);
0717 
0718             fprintf(out, "%c%s%c%s/%s",
0719                 /* session dir */
0720                 csv_sep, session->base,
0721                 /* session output */
0722                 csv_sep, session->base, SESSION_OUTPUT);
0723 
0724             fprintf(out, "%c%s/%s%c%s/%s",
0725                 /* session control */
0726                 csv_sep, session->base, SESSION_CONTROL,
0727                 /* session ack */
0728                 csv_sep, session->base, SESSION_ACK);
0729 
0730             fprintf(out, "%c%lu",
0731                 /* session up time */
0732                 csv_sep, (curr - session->start) / 60);
0733 
0734             fprintf(out, "\n");
0735         } else {
0736             fprintf(out, "[%d:%s] perf record %s\n",
0737                 session->pid, session->name, session->run);
0738             if (!cmd->list.verbose)
0739                 continue;
0740             fprintf(out, "  base:    %s\n",
0741                 session->base);
0742             fprintf(out, "  output:  %s/%s\n",
0743                 session->base, SESSION_OUTPUT);
0744             fprintf(out, "  control: %s/%s\n",
0745                 session->base, SESSION_CONTROL);
0746             fprintf(out, "  ack:     %s/%s\n",
0747                 session->base, SESSION_ACK);
0748             fprintf(out, "  up:      %lu minutes\n",
0749                 (curr - session->start) / 60);
0750         }
0751     }
0752 
0753     return 0;
0754 }
0755 
0756 static int daemon_session__signal(struct daemon_session *session, int sig)
0757 {
0758     if (session->pid < 0)
0759         return -1;
0760     return kill(session->pid, sig);
0761 }
0762 
0763 static int cmd_session_kill(struct daemon *daemon, union cmd *cmd, FILE *out)
0764 {
0765     struct daemon_session *session;
0766     bool all = false;
0767 
0768     all = !strcmp(cmd->signal.name, "all");
0769 
0770     list_for_each_entry(session, &daemon->sessions, list) {
0771         if (all || !strcmp(cmd->signal.name, session->name)) {
0772             daemon_session__signal(session, cmd->signal.sig);
0773             fprintf(out, "signal %d sent to session '%s [%d]'\n",
0774                 cmd->signal.sig, session->name, session->pid);
0775         }
0776     }
0777 
0778     return 0;
0779 }
0780 
0781 static const char *ping_str[PING_MAX] = {
0782     [PING_OK]   = "OK",
0783     [PING_FAIL] = "FAIL",
0784 };
0785 
0786 static int cmd_session_ping(struct daemon *daemon, union cmd *cmd, FILE *out)
0787 {
0788     struct daemon_session *session;
0789     bool all = false, found = false;
0790 
0791     all = !strcmp(cmd->ping.name, "all");
0792 
0793     list_for_each_entry(session, &daemon->sessions, list) {
0794         if (all || !strcmp(cmd->ping.name, session->name)) {
0795             int state = daemon_session__ping(session);
0796 
0797             fprintf(out, "%-4s %s\n", ping_str[state], session->name);
0798             found = true;
0799         }
0800     }
0801 
0802     if (!found && !all) {
0803         fprintf(out, "%-4s %s (not found)\n",
0804             ping_str[PING_FAIL], cmd->ping.name);
0805     }
0806     return 0;
0807 }
0808 
0809 static int handle_server_socket(struct daemon *daemon, int sock_fd)
0810 {
0811     int ret = -1, fd;
0812     FILE *out = NULL;
0813     union cmd cmd;
0814 
0815     fd = accept(sock_fd, NULL, NULL);
0816     if (fd < 0) {
0817         perror("failed: accept");
0818         return -1;
0819     }
0820 
0821     if (sizeof(cmd) != readn(fd, &cmd, sizeof(cmd))) {
0822         perror("failed: read");
0823         goto out;
0824     }
0825 
0826     out = fdopen(fd, "w");
0827     if (!out) {
0828         perror("failed: fdopen");
0829         goto out;
0830     }
0831 
0832     switch (cmd.cmd) {
0833     case CMD_LIST:
0834         ret = cmd_session_list(daemon, &cmd, out);
0835         break;
0836     case CMD_SIGNAL:
0837         ret = cmd_session_kill(daemon, &cmd, out);
0838         break;
0839     case CMD_STOP:
0840         done = 1;
0841         ret = 0;
0842         pr_debug("perf daemon is exciting\n");
0843         break;
0844     case CMD_PING:
0845         ret = cmd_session_ping(daemon, &cmd, out);
0846         break;
0847     default:
0848         break;
0849     }
0850 
0851     fclose(out);
0852 out:
0853     /* If out is defined, then fd is closed via fclose. */
0854     if (!out)
0855         close(fd);
0856     return ret;
0857 }
0858 
0859 static int setup_client_socket(struct daemon *daemon)
0860 {
0861     struct sockaddr_un addr;
0862     char path[PATH_MAX];
0863     int fd = socket(AF_UNIX, SOCK_STREAM, 0);
0864 
0865     if (fd == -1) {
0866         perror("failed: socket");
0867         return -1;
0868     }
0869 
0870     scnprintf(path, sizeof(path), "%s/control", daemon->base);
0871 
0872     if (strlen(path) + 1 >= sizeof(addr.sun_path)) {
0873         pr_err("failed: control path too long '%s'\n", path);
0874         close(fd);
0875         return -1;
0876     }
0877 
0878     memset(&addr, 0, sizeof(addr));
0879     addr.sun_family = AF_UNIX;
0880     strlcpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
0881 
0882     if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
0883         perror("failed: connect");
0884         close(fd);
0885         return -1;
0886     }
0887 
0888     return fd;
0889 }
0890 
0891 static void daemon_session__kill(struct daemon_session *session,
0892                  struct daemon *daemon)
0893 {
0894     int how = 0;
0895 
0896     do {
0897         switch (how) {
0898         case 0:
0899             daemon_session__control(session, "stop", false);
0900             break;
0901         case 1:
0902             daemon_session__signal(session, SIGTERM);
0903             break;
0904         case 2:
0905             daemon_session__signal(session, SIGKILL);
0906             break;
0907         default:
0908             pr_err("failed to wait for session %s\n",
0909                    session->name);
0910             return;
0911         }
0912         how++;
0913 
0914     } while (daemon_session__wait(session, daemon, 10));
0915 }
0916 
0917 static void daemon__signal(struct daemon *daemon, int sig)
0918 {
0919     struct daemon_session *session;
0920 
0921     list_for_each_entry(session, &daemon->sessions, list)
0922         daemon_session__signal(session, sig);
0923 }
0924 
0925 static void daemon_session__delete(struct daemon_session *session)
0926 {
0927     free(session->base);
0928     free(session->name);
0929     free(session->run);
0930     free(session);
0931 }
0932 
0933 static void daemon_session__remove(struct daemon_session *session)
0934 {
0935     list_del(&session->list);
0936     daemon_session__delete(session);
0937 }
0938 
0939 static void daemon__stop(struct daemon *daemon)
0940 {
0941     struct daemon_session *session;
0942 
0943     list_for_each_entry(session, &daemon->sessions, list)
0944         daemon_session__control(session, "stop", false);
0945 }
0946 
0947 static void daemon__kill(struct daemon *daemon)
0948 {
0949     int how = 0;
0950 
0951     do {
0952         switch (how) {
0953         case 0:
0954             daemon__stop(daemon);
0955             break;
0956         case 1:
0957             daemon__signal(daemon, SIGTERM);
0958             break;
0959         case 2:
0960             daemon__signal(daemon, SIGKILL);
0961             break;
0962         default:
0963             pr_err("failed to wait for sessions\n");
0964             return;
0965         }
0966         how++;
0967 
0968     } while (daemon__wait(daemon, 10));
0969 }
0970 
0971 static void daemon__exit(struct daemon *daemon)
0972 {
0973     struct daemon_session *session, *h;
0974 
0975     list_for_each_entry_safe(session, h, &daemon->sessions, list)
0976         daemon_session__remove(session);
0977 
0978     free(daemon->config_real);
0979     free(daemon->config_base);
0980     free(daemon->base);
0981 }
0982 
0983 static int daemon__reconfig(struct daemon *daemon)
0984 {
0985     struct daemon_session *session, *n;
0986 
0987     list_for_each_entry_safe(session, n, &daemon->sessions, list) {
0988         /* No change. */
0989         if (session->state == OK)
0990             continue;
0991 
0992         /* Remove session. */
0993         if (session->state == KILL) {
0994             if (session->pid > 0) {
0995                 daemon_session__kill(session, daemon);
0996                 pr_info("reconfig: session '%s' killed\n", session->name);
0997             }
0998             daemon_session__remove(session);
0999             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 
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 
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 
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 
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 
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  */
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 
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 
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 
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 
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 
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 
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 
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 
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 
1493 int cmd_daemon(int argc, const char **argv)
1494 {
1495     struct option daemon_options[] = {
1496         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1497         OPT_STRING(0, "config", &__daemon.config,
1498             "config file", "config file path"),
1499         OPT_STRING(0, "base", &__daemon.base_user,
1500             "directory", "base directory"),
1501         OPT_STRING_OPTARG('x', "field-separator", &__daemon.csv_sep,
1502             "field separator", "print counts with custom separator", ","),
1503         OPT_END()
1504     };
1505 
1506     perf_exe(__daemon.perf, sizeof(__daemon.perf));
1507     __daemon.out = stdout;
1508 
1509     argc = parse_options(argc, argv, daemon_options, daemon_usage,
1510                  PARSE_OPT_STOP_AT_NON_OPTION);
1511 
1512     if (argc) {
1513         if (!strcmp(argv[0], "start"))
1514             return __cmd_start(&__daemon, daemon_options, argc, argv);
1515         if (!strcmp(argv[0], "signal"))
1516             return __cmd_signal(&__daemon, daemon_options, argc, argv);
1517         else if (!strcmp(argv[0], "stop"))
1518             return __cmd_stop(&__daemon, daemon_options, argc, argv);
1519         else if (!strcmp(argv[0], "ping"))
1520             return __cmd_ping(&__daemon, daemon_options, argc, argv);
1521 
1522         pr_err("failed: unknown command '%s'\n", argv[0]);
1523         return -1;
1524     }
1525 
1526     if (setup_config(&__daemon)) {
1527         pr_err("failed: config not found\n");
1528         return -1;
1529     }
1530 
1531     return send_cmd_list(&__daemon);
1532 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!