git.ozlabs.org Git - petitboot/blob - lib/process/process.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; version 2 of the License.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public License
  12  * along with this program; if not, write to the Free Software
  13  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14  */
  15
  16 #include <assert.h>
  17 #include <errno.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/wait.h>
  21
  22 #include <process/process.h>
  23 #include <talloc/talloc.h>
  24 #include <waiter/waiter.h>
  25 #include <log/log.h>
  26
  27 struct procset {
  28         struct waitset          *waitset;
  29         struct list             async_list;
  30         int                     sigchld_pipe[2];
  31         struct waiter           *sigchld_waiter;
  32 };
  33
  34 /* Internal data type for process handling
  35  *
  36  * Allocation: these structures may have multiple references:
  37  *  - from the original ctx pointer
  38  *  - due to inclusion in async_list
  39  *  - due to a currently-registered waiter
  40  *
  41  */
  42 struct process_info {
  43 #ifdef DEBUG
  44         /* prevent talloc_free(process) from working */
  45         int                     __pad;
  46 #endif
  47         struct process          process;
  48         struct list_item        async_list;
  49         int                     stdout_buf_len;
  50         struct waiter           *stdout_waiter;
  51         int                     stdout_pipe[2];
  52         void                    *orig_ctx;
  53 };
  54
  55 static struct procset *procset;
  56
  57 static struct process_info *get_info(struct process *process)
  58 {
  59         return container_of(process, struct process_info, process);
  60 }
  61
  62 /* Read as much as possible into the currently-allocated stdout buffer, and
  63  * possibly realloc it for the next read */
  64 static int process_read_stdout_once(struct process_info *procinfo)
  65 {
  66         struct process *process = &procinfo->process;
  67         int rc, fd, max_len;
  68
  69         assert(process->keep_stdout);
  70
  71         fd = procinfo->stdout_pipe[0];
  72
  73         max_len =  procinfo->stdout_buf_len - process->stdout_len - 1;
  74
  75         rc = read(fd, process->stdout_buf + process->stdout_len, max_len);
  76         if (rc <= 0)
  77                 return rc;
  78
  79         process->stdout_len += rc;
  80         if (process->stdout_len == procinfo->stdout_buf_len - 1) {
  81                 procinfo->stdout_buf_len *= 2;
  82                 process->stdout_buf = talloc_realloc(procinfo,
  83                                 process->stdout_buf, char,
  84                                 procinfo->stdout_buf_len);
  85         }
  86
  87         return rc;
  88 }
  89
  90 static int process_setup_stdout_pipe(struct process_info *procinfo)
  91 {
  92         int rc;
  93
  94         if (!procinfo->process.keep_stdout)
  95                 return 0;
  96
  97         procinfo->stdout_buf_len = 4096;
  98         procinfo->process.stdout_len = 0;
  99         procinfo->process.stdout_buf = talloc_array(procinfo, char,
 100                         procinfo->stdout_buf_len);
 101
 102         rc = pipe(procinfo->stdout_pipe);
 103         if (rc) {
 104                 pb_log("pipe failed");
 105                 return rc;
 106         }
 107         return 0;
 108 }
 109
 110 static void process_setup_stdout_parent(struct process_info *procinfo)
 111 {
 112         if (!procinfo->process.keep_stdout)
 113                 return;
 114
 115         close(procinfo->stdout_pipe[1]);
 116 }
 117
 118 static void process_setup_stdout_child(struct process_info *procinfo)
 119 {
 120         int log = fileno(pb_log_get_stream());
 121
 122         if (procinfo->process.keep_stdout)
 123                 dup2(procinfo->stdout_pipe[1], STDOUT_FILENO);
 124         else
 125                 dup2(log, STDOUT_FILENO);
 126
 127         dup2(log, STDERR_FILENO);
 128 }
 129
 130 static void process_finish_stdout(struct process_info *procinfo)
 131 {
 132         close(procinfo->stdout_pipe[0]);
 133         procinfo->process.stdout_buf[procinfo->process.stdout_len] = '\0';
 134 }
 135
 136 static int process_read_stdout(struct process_info *procinfo)
 137 {
 138         int rc;
 139
 140         if (!procinfo->process.keep_stdout)
 141                 return 0;
 142
 143         do {
 144                 rc = process_read_stdout_once(procinfo);
 145         } while (rc > 0);
 146
 147         process_finish_stdout(procinfo);
 148
 149         return rc < 0 ? rc : 0;
 150 }
 151
 152 static int process_stdout_cb(void *arg)
 153 {
 154         struct process_info *procinfo = arg;
 155         int rc;
 156
 157         rc = process_read_stdout_once(procinfo);
 158
 159         /* if we're going to signal to the waitset that we're done (ie, non-zero
 160          * return value), then the waiters will remove us, so we drop the
 161          * reference */
 162         if (rc < 0) {
 163                 talloc_unlink(procset, procinfo);
 164                 procinfo->stdout_waiter = NULL;
 165                 rc = -1;
 166         } else {
 167                 rc = 0;
 168         }
 169
 170         return rc;
 171 }
 172
 173 static void sigchld_sigaction(int signo, siginfo_t *info,
 174                 void *arg __attribute__((unused)))
 175 {
 176         pid_t pid;
 177         int rc;
 178
 179         if (signo != SIGCHLD)
 180                 return;
 181
 182         pid = info->si_pid;
 183
 184         rc = write(procset->sigchld_pipe[1], &pid, sizeof(pid));
 185         if (rc != sizeof(pid))
 186                 pb_log("%s: write failed: %s\n", __func__, strerror(errno));
 187 }
 188
 189 static int sigchld_pipe_event(void *arg)
 190 {
 191         struct process_info *procinfo;
 192         struct procset *procset = arg;
 193         struct process *process;
 194         int pid, rc;
 195
 196         rc = read(procset->sigchld_pipe[0], &pid, sizeof(pid));
 197         if (rc != sizeof(pid))
 198                 return 0;
 199
 200         process = NULL;
 201         list_for_each_entry(&procset->async_list, procinfo, async_list) {
 202                 if (procinfo->process.pid == pid) {
 203                         process = &procinfo->process;
 204                         break;
 205                 }
 206         }
 207
 208         /* We'll receive SIGCHLD for synchronous processes too; just ignore */
 209         if (!process)
 210                 return 0;
 211
 212         rc = waitpid(process->pid, &process->exit_status, WNOHANG);
 213
 214         /* if the process is still running, ignore the event. We leave
 215          * the process in async_list so we can manage the final signal */
 216         if (rc == 0)
 217                 return 0;
 218
 219         /* ensure we have all of the child's stdout */
 220         process_read_stdout(procinfo);
 221
 222         if (process->exit_cb)
 223                 process->exit_cb(process);
 224
 225         list_remove(&procinfo->async_list);
 226         talloc_unlink(procset, procinfo);
 227
 228         return 0;
 229 }
 230
 231 static int process_fini(void *p)
 232 {
 233         struct procset *procset = p;
 234         struct sigaction sa;
 235
 236         memset(&sa, 0, sizeof(sa));
 237         sa.sa_handler = SIG_DFL;
 238
 239         sigaction(SIGCHLD, &sa, NULL);
 240
 241         waiter_remove(procset->sigchld_waiter);
 242
 243         close(procset->sigchld_pipe[0]);
 244         close(procset->sigchld_pipe[1]);
 245         return 0;
 246 }
 247
 248 struct procset *process_init(void *ctx, struct waitset *set)
 249 {
 250         struct sigaction sa;
 251         int rc;
 252
 253         procset = talloc(ctx, struct procset);
 254         procset->waitset = set;
 255         list_init(&procset->async_list);
 256
 257         rc = pipe(procset->sigchld_pipe);
 258         if (rc) {
 259                 pb_log("%s: pipe() failed: %s\n", __func__, strerror(errno));
 260                 goto err_free;
 261         }
 262
 263         procset->sigchld_waiter = waiter_register_io(set,
 264                                         procset->sigchld_pipe[0], WAIT_IN,
 265                                         sigchld_pipe_event, procset);
 266         if (!procset->sigchld_waiter)
 267                 goto err_close;
 268
 269         memset(&sa, 0, sizeof(sa));
 270         sa.sa_sigaction = sigchld_sigaction;
 271         sa.sa_flags = SA_SIGINFO | SA_NOCLDSTOP;
 272
 273         rc = sigaction(SIGCHLD, &sa, NULL);
 274         if (rc) {
 275                 pb_log("%s: sigaction() failed: %s\n", __func__,
 276                                 strerror(errno));
 277                 goto err_remove;
 278         }
 279
 280         talloc_set_destructor(procset, process_fini);
 281
 282         return procset;
 283
 284 err_remove:
 285         waiter_remove(procset->sigchld_waiter);
 286 err_close:
 287         close(procset->sigchld_pipe[0]);
 288         close(procset->sigchld_pipe[1]);
 289 err_free:
 290         talloc_free(procset);
 291         return NULL;
 292 }
 293
 294 struct process *process_create(void *ctx)
 295 {
 296         struct process_info *info = talloc_zero(ctx, struct process_info);
 297         info->orig_ctx = ctx;
 298         return &info->process;
 299 }
 300
 301 void process_release(struct process *process)
 302 {
 303         struct process_info *info = get_info(process);
 304         talloc_unlink(info->orig_ctx, info);
 305 }
 306
 307 static int process_run_common(struct process_info *procinfo)
 308 {
 309         struct process *process = &procinfo->process;
 310         const char *arg;
 311         char *logmsg;
 312         pid_t pid;
 313         int rc, i;
 314
 315         logmsg = talloc_asprintf(procinfo, " exe:  %s\n argv:", process->path);
 316         for (i = 0, arg = process->argv[i]; arg; i++, arg = process->argv[i])
 317                 logmsg = talloc_asprintf_append(logmsg, " '%s'", arg);
 318
 319         pb_log("Running command:\n%s\n", logmsg);
 320
 321         rc = process_setup_stdout_pipe(procinfo);
 322         if (rc)
 323                 return rc;
 324
 325         pid = fork();
 326         if (pid < 0) {
 327                 pb_log("%s: fork failed: %s\n", __func__, strerror(errno));
 328                 return pid;
 329         }
 330
 331         if (pid == 0) {
 332                 process_setup_stdout_child(procinfo);
 333                 execvp(process->path, (char * const *)process->argv);
 334                 exit(EXIT_FAILURE);
 335         }
 336
 337         process_setup_stdout_parent(procinfo);
 338         process->pid = pid;
 339
 340         return 0;
 341 }
 342
 343 int process_run_sync(struct process *process)
 344 {
 345         struct process_info *procinfo = get_info(process);
 346         int rc;
 347
 348         rc = process_run_common(procinfo);
 349         if (rc)
 350                 return rc;
 351
 352         process_read_stdout(procinfo);
 353
 354         rc = waitpid(process->pid, &process->exit_status, 0);
 355         if (rc == -1) {
 356                 pb_log("%s: waitpid failed: %s\n", __func__, strerror(errno));
 357                 return rc;
 358         }
 359
 360         return 0;
 361 }
 362
 363 int process_run_async(struct process *process)
 364 {
 365         struct process_info *procinfo = get_info(process);
 366         int rc;
 367
 368         rc = process_run_common(procinfo);
 369         if (rc)
 370                 return rc;
 371
 372         if (process->keep_stdout) {
 373                 procinfo->stdout_waiter = waiter_register_io(procset->waitset,
 374                                                 procinfo->stdout_pipe[0],
 375                                                 WAIT_IN, process_stdout_cb,
 376                                                 procinfo);
 377                 talloc_reference(procset, procinfo);
 378         }
 379
 380         list_add(&procset->async_list, &procinfo->async_list);
 381         talloc_reference(procset, procinfo);
 382
 383         return 0;
 384 }
 385
 386 void process_stop_async(struct process *process)
 387 {
 388         kill(process->pid, SIGTERM);
 389 }
 390
 391 int process_run_simple_argv(void *ctx, const char *argv[])
 392 {
 393         struct process *process;
 394         int rc;
 395
 396         process = process_create(ctx);
 397
 398         process->path = argv[0];
 399         process->argv = argv;
 400
 401         rc = process_run_sync(process);
 402
 403         if (!rc)
 404                 rc = process->exit_status;
 405
 406         process_release(process);
 407
 408         return rc;
 409 }
 410
 411 int process_run_simple(void *ctx, const char *name, ...)
 412 {
 413         int rc, i, n_argv = 1;
 414         const char **argv;
 415         va_list ap;
 416
 417         va_start(ap, name);
 418         while (va_arg(ap, char *))
 419                 n_argv++;
 420         va_end(ap);
 421
 422         argv = talloc_array(ctx, const char *, n_argv + 1);
 423         argv[0] = name;
 424
 425         va_start(ap, name);
 426         for (i = 1; i < n_argv; i++)
 427                 argv[i] = va_arg(ap, const char *);
 428         va_end(ap);
 429
 430         argv[i] = NULL;
 431
 432         rc = process_run_simple_argv(ctx, argv);
 433
 434         talloc_free(argv);
 435
 436         return rc;
 437 }