lib/process.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "process.h"
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <signal.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/wait.h>
  26 #include <unistd.h>
  27 #include "coverage.h"
  28 #include "dynamic-string.h"
  29 #include "fatal-signal.h"
  30 #include "list.h"
  31 #include "ovs-thread.h"
  32 #include "poll-loop.h"
  33 #include "signals.h"
  34 #include "socket-util.h"
  35 #include "util.h"
  36 #include "vlog.h"
  37
  38 VLOG_DEFINE_THIS_MODULE(process);
  39
  40 COVERAGE_DEFINE(process_start);
  41
  42 struct process {
  43     struct list node;
  44     char *name;
  45     pid_t pid;
  46
  47     /* State. */
  48     bool exited;
  49     int status;
  50 };
  51
  52 /* Pipe used to signal child termination. */
  53 static int fds[2];
  54
  55 /* All processes. */
  56 static struct list all_processes = LIST_INITIALIZER(&all_processes);
  57
  58 static void sigchld_handler(int signr OVS_UNUSED);
  59
  60 /* Initializes the process subsystem (if it is not already initialized).  Calls
  61  * exit() if initialization fails.
  62  *
  63  * This function may not be called after creating any additional threads.
  64  *
  65  * Calling this function is optional; it will be called automatically by
  66  * process_start() if necessary.  Calling it explicitly allows the client to
  67  * prevent the process from exiting at an unexpected time. */
  68 void
  69 process_init(void)
  70 {
  71     static bool inited;
  72     struct sigaction sa;
  73
  74     assert_single_threaded();
  75     if (inited) {
  76         return;
  77     }
  78     inited = true;
  79
  80     /* Create notification pipe. */
  81     xpipe_nonblocking(fds);
  82
  83     /* Set up child termination signal handler. */
  84     memset(&sa, 0, sizeof sa);
  85     sa.sa_handler = sigchld_handler;
  86     sigemptyset(&sa.sa_mask);
  87     sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
  88     xsigaction(SIGCHLD, &sa, NULL);
  89 }
  90
  91 char *
  92 process_escape_args(char **argv)
  93 {
  94     struct ds ds = DS_EMPTY_INITIALIZER;
  95     char **argp;
  96     for (argp = argv; *argp; argp++) {
  97         const char *arg = *argp;
  98         const char *p;
  99         if (argp != argv) {
 100             ds_put_char(&ds, ' ');
 101         }
 102         if (arg[strcspn(arg, " \t\r\n\v\\\'\"")]) {
 103             ds_put_char(&ds, '"');
 104             for (p = arg; *p; p++) {
 105                 if (*p == '\\' || *p == '\"') {
 106                     ds_put_char(&ds, '\\');
 107                 }
 108                 ds_put_char(&ds, *p);
 109             }
 110             ds_put_char(&ds, '"');
 111         } else {
 112             ds_put_cstr(&ds, arg);
 113         }
 114     }
 115     return ds_cstr(&ds);
 116 }
 117
 118 /* Prepare to start a process whose command-line arguments are given by the
 119  * null-terminated 'argv' array.  Returns 0 if successful, otherwise a
 120  * positive errno value. */
 121 static int
 122 process_prestart(char **argv)
 123 {
 124     char *binary;
 125
 126     process_init();
 127
 128     /* Log the process to be started. */
 129     if (VLOG_IS_DBG_ENABLED()) {
 130         char *args = process_escape_args(argv);
 131         VLOG_DBG("starting subprocess: %s", args);
 132         free(args);
 133     }
 134
 135     /* execvp() will search PATH too, but the error in that case is more
 136      * obscure, since it is only reported post-fork. */
 137     binary = process_search_path(argv[0]);
 138     if (!binary) {
 139         VLOG_ERR("%s not found in PATH", argv[0]);
 140         return ENOENT;
 141     }
 142     free(binary);
 143
 144     return 0;
 145 }
 146
 147 /* Creates and returns a new struct process with the specified 'name' and
 148  * 'pid'. */
 149 static struct process *
 150 process_register(const char *name, pid_t pid)
 151 {
 152     struct process *p;
 153     const char *slash;
 154
 155     p = xzalloc(sizeof *p);
 156     p->pid = pid;
 157     slash = strrchr(name, '/');
 158     p->name = xstrdup(slash ? slash + 1 : name);
 159     p->exited = false;
 160
 161     list_push_back(&all_processes, &p->node);
 162
 163     return p;
 164 }
 165
 166 /* Starts a subprocess with the arguments in the null-terminated argv[] array.
 167  * argv[0] is used as the name of the process.  Searches the PATH environment
 168  * variable to find the program to execute.
 169  *
 170  * This function may not be called after creating any additional threads.
 171  *
 172  * All file descriptors are closed before executing the subprocess, except for
 173  * fds 0, 1, and 2.
 174  *
 175  * Returns 0 if successful, otherwise a positive errno value indicating the
 176  * error.  If successful, '*pp' is assigned a new struct process that may be
 177  * used to query the process's status.  On failure, '*pp' is set to NULL. */
 178 int
 179 process_start(char **argv, struct process **pp)
 180 {
 181     pid_t pid;
 182     int error;
 183
 184     assert_single_threaded();
 185
 186     *pp = NULL;
 187     COVERAGE_INC(process_start);
 188     error = process_prestart(argv);
 189     if (error) {
 190         return error;
 191     }
 192
 193     pid = fork();
 194     if (pid < 0) {
 195         VLOG_WARN("fork failed: %s", ovs_strerror(errno));
 196         return errno;
 197     } else if (pid) {
 198         /* Running in parent process. */
 199         *pp = process_register(argv[0], pid);
 200         return 0;
 201     } else {
 202         /* Running in child process. */
 203         int fd_max = get_max_fds();
 204         int fd;
 205
 206         fatal_signal_fork();
 207         for (fd = 3; fd < fd_max; fd++) {
 208             close(fd);
 209         }
 210         execvp(argv[0], argv);
 211         fprintf(stderr, "execvp(\"%s\") failed: %s\n",
 212                 argv[0], ovs_strerror(errno));
 213         _exit(1);
 214     }
 215 }
 216
 217 /* Destroys process 'p'. */
 218 void
 219 process_destroy(struct process *p)
 220 {
 221     if (p) {
 222         list_remove(&p->node);
 223         free(p->name);
 224         free(p);
 225     }
 226 }
 227
 228 /* Sends signal 'signr' to process 'p'.  Returns 0 if successful, otherwise a
 229  * positive errno value. */
 230 int
 231 process_kill(const struct process *p, int signr)
 232 {
 233     return (p->exited ? ESRCH
 234             : !kill(p->pid, signr) ? 0
 235             : errno);
 236 }
 237
 238 /* Returns the pid of process 'p'. */
 239 pid_t
 240 process_pid(const struct process *p)
 241 {
 242     return p->pid;
 243 }
 244
 245 /* Returns the name of process 'p' (the name passed to process_start() with any
 246  * leading directories stripped). */
 247 const char *
 248 process_name(const struct process *p)
 249 {
 250     return p->name;
 251 }
 252
 253 /* Returns true if process 'p' has exited, false otherwise. */
 254 bool
 255 process_exited(struct process *p)
 256 {
 257     return p->exited;
 258 }
 259
 260 /* Returns process 'p''s exit status, as reported by waitpid(2).
 261  * process_status(p) may be called only after process_exited(p) has returned
 262  * true. */
 263 int
 264 process_status(const struct process *p)
 265 {
 266     ovs_assert(p->exited);
 267     return p->status;
 268 }
 269
 270 /* Given 'status', which is a process status in the form reported by waitpid(2)
 271  * and returned by process_status(), returns a string describing how the
 272  * process terminated.  The caller is responsible for freeing the string when
 273  * it is no longer needed. */
 274 char *
 275 process_status_msg(int status)
 276 {
 277     struct ds ds = DS_EMPTY_INITIALIZER;
 278     if (WIFEXITED(status)) {
 279         ds_put_format(&ds, "exit status %d", WEXITSTATUS(status));
 280     } else if (WIFSIGNALED(status)) {
 281         char namebuf[SIGNAL_NAME_BUFSIZE];
 282
 283         ds_put_format(&ds, "killed (%s)",
 284                       signal_name(WTERMSIG(status), namebuf, sizeof namebuf));
 285     } else if (WIFSTOPPED(status)) {
 286         char namebuf[SIGNAL_NAME_BUFSIZE];
 287
 288         ds_put_format(&ds, "stopped (%s)",
 289                       signal_name(WSTOPSIG(status), namebuf, sizeof namebuf));
 290     } else {
 291         ds_put_format(&ds, "terminated abnormally (%x)", status);
 292     }
 293     if (WCOREDUMP(status)) {
 294         ds_put_cstr(&ds, ", core dumped");
 295     }
 296     return ds_cstr(&ds);
 297 }
 298
 299 /* Executes periodic maintenance activities required by the process module. */
 300 void
 301 process_run(void)
 302 {
 303     char buf[_POSIX_PIPE_BUF];
 304
 305     if (!list_is_empty(&all_processes) && read(fds[0], buf, sizeof buf) > 0) {
 306         struct process *p;
 307
 308         LIST_FOR_EACH (p, node, &all_processes) {
 309             if (!p->exited) {
 310                 int retval, status;
 311                 do {
 312                     retval = waitpid(p->pid, &status, WNOHANG);
 313                 } while (retval == -1 && errno == EINTR);
 314                 if (retval == p->pid) {
 315                     p->exited = true;
 316                     p->status = status;
 317                 } else if (retval < 0) {
 318                     VLOG_WARN("waitpid: %s", ovs_strerror(errno));
 319                     p->exited = true;
 320                     p->status = -1;
 321                 }
 322             }
 323         }
 324     }
 325 }
 326
 327
 328 /* Causes the next call to poll_block() to wake up when process 'p' has
 329  * exited. */
 330 void
 331 process_wait(struct process *p)
 332 {
 333     if (p->exited) {
 334         poll_immediate_wake();
 335     } else {
 336         poll_fd_wait(fds[0], POLLIN);
 337     }
 338 }
 339
 340 char *
 341 process_search_path(const char *name)
 342 {
 343     char *save_ptr = NULL;
 344     char *path, *dir;
 345     struct stat s;
 346
 347     if (strchr(name, '/') || !getenv("PATH")) {
 348         return stat(name, &s) == 0 ? xstrdup(name) : NULL;
 349     }
 350
 351     path = xstrdup(getenv("PATH"));
 352     for (dir = strtok_r(path, ":", &save_ptr); dir;
 353          dir = strtok_r(NULL, ":", &save_ptr)) {
 354         char *file = xasprintf("%s/%s", dir, name);
 355         if (stat(file, &s) == 0) {
 356             free(path);
 357             return file;
 358         }
 359         free(file);
 360     }
 361     free(path);
 362     return NULL;
 363 }
 364 \f
 365 static void
 366 sigchld_handler(int signr OVS_UNUSED)
 367 {
 368     ignore(write(fds[1], "", 1));
 369 }