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         bool                    dry_run;
  33 };
  34
  35 /* Internal data type for process handling
  36  *
  37  * Allocation: these structures may have multiple references:
  38  *  - from the original ctx pointer
  39  *  - due to inclusion in async_list
  40  *  - due to a currently-registered waiter
  41  *
  42  */
  43 struct process_info {
  44 #ifdef DEBUG
  45         /* prevent talloc_free(process) from working */
  46         int                     __pad;
  47 #endif
  48         struct process          process;
  49         struct list_item        async_list;
  50         int                     stdout_buf_len;
  51         struct waiter           *stdout_waiter;
  52         int                     stdout_pipe[2];
  53         int                     stdin_pipe[2];
  54         void                    *orig_ctx;
  55 };
  56
  57 static struct procset *procset;
  58
  59 static struct process_info *get_info(struct process *process)
  60 {
  61         return container_of(process, struct process_info, process);
  62 }
  63
  64 struct process *procinfo_get_process(struct process_info *procinfo)
  65 {
  66         return &procinfo->process;
  67 }
  68
  69 /* Read as much as possible into the currently-allocated stdout buffer, and
  70  * possibly realloc it for the next read
  71  * If the line pointer is not NULL, it is set to the start of the latest
  72  * output.
  73  *
  74  * Returns:
  75  *  > 0 on success (even though no bytes may have been read)
  76  *    0 on EOF (no error, but no more reads can be performed)
  77  *  < 0 on error
  78  **/
  79 static int process_read_stdout_once(struct process_info *procinfo, char **line)
  80 {
  81         struct process *process = &procinfo->process;
  82         int rc, fd, max_len;
  83
  84         assert(process->keep_stdout);
  85
  86         fd = procinfo->stdout_pipe[0];
  87
  88         max_len =  procinfo->stdout_buf_len - process->stdout_len - 1;
  89
  90         rc = read(fd, process->stdout_buf + process->stdout_len, max_len);
  91         if (rc == 0)
  92                 return 0;
  93         if (rc < 0) {
  94                 if (errno == EINTR)
  95                         return 1;
  96                 pb_log_fn("read failed: %s\n", strerror(errno));
  97                 return rc;
  98         }
  99
 100         if (line)
 101                 *line = process->stdout_buf + process->stdout_len;
 102
 103         process->stdout_len += rc;
 104         if (process->stdout_len == procinfo->stdout_buf_len - 1) {
 105                 procinfo->stdout_buf_len *= 2;
 106                 process->stdout_buf = talloc_realloc(procinfo,
 107                                 process->stdout_buf, char,
 108                                 procinfo->stdout_buf_len);
 109         }
 110
 111         return 1;
 112 }
 113
 114 static int process_setup_stdout_pipe(struct process_info *procinfo)
 115 {
 116         int rc;
 117
 118         if (!procinfo->process.keep_stdout || procinfo->process.raw_stdout)
 119                 return 0;
 120
 121         procinfo->stdout_buf_len = 4096;
 122         procinfo->process.stdout_len = 0;
 123         procinfo->process.stdout_buf = talloc_array(procinfo, char,
 124                         procinfo->stdout_buf_len);
 125
 126         rc = pipe(procinfo->stdout_pipe);
 127         if (rc) {
 128                 pb_log("pipe failed");
 129                 return rc;
 130         }
 131         return 0;
 132 }
 133
 134 static void process_setup_stdin_parent(struct process_info *procinfo)
 135 {
 136         FILE *in;
 137
 138         if (!procinfo->process.pipe_stdin)
 139                 return;
 140
 141         close(procinfo->stdin_pipe[0]);
 142         in = fdopen(procinfo->stdin_pipe[1], "w");
 143         if (!in) {
 144                 pb_log_fn("Failed to open stdin\n");
 145                 return;
 146         }
 147         fputs(procinfo->process.pipe_stdin, in);
 148         fflush(in);
 149 }
 150
 151 static void process_setup_stdin_child(struct process_info *procinfo)
 152 {
 153         if (procinfo->process.pipe_stdin) {
 154                 close(procinfo->stdin_pipe[1]);
 155                 dup2(procinfo->stdin_pipe[0], STDIN_FILENO);
 156         }
 157 }
 158 static void process_setup_stdout_parent(struct process_info *procinfo)
 159 {
 160         if (!procinfo->process.keep_stdout || procinfo->process.raw_stdout)
 161                 return;
 162
 163         close(procinfo->stdout_pipe[1]);
 164
 165 }
 166
 167 static void process_setup_stdout_child(struct process_info *procinfo)
 168 {
 169         int log = fileno(pb_log_get_stream());
 170
 171         if (procinfo->process.raw_stdout)
 172                 return;
 173
 174         if (procinfo->process.keep_stdout)
 175                 dup2(procinfo->stdout_pipe[1], STDOUT_FILENO);
 176         else
 177                 dup2(log, STDOUT_FILENO);
 178
 179         if (procinfo->process.keep_stdout && procinfo->process.add_stderr)
 180                 dup2(procinfo->stdout_pipe[1], STDERR_FILENO);
 181         else
 182                 dup2(log, STDERR_FILENO);
 183 }
 184
 185 static void process_finish_stdout(struct process_info *procinfo)
 186 {
 187         close(procinfo->stdout_pipe[0]);
 188         procinfo->process.stdout_buf[procinfo->process.stdout_len] = '\0';
 189 }
 190
 191 static int process_read_stdout(struct process_info *procinfo)
 192 {
 193         int rc;
 194
 195         if (!procinfo->process.keep_stdout)
 196                 return 0;
 197
 198         do {
 199                 rc = process_read_stdout_once(procinfo, NULL);
 200         } while (rc > 0);
 201
 202         process_finish_stdout(procinfo);
 203
 204         return rc < 0 ? rc : 0;
 205 }
 206
 207 int process_process_stdout(struct process_info *procinfo, char **line)
 208 {
 209         int rc;
 210
 211         rc = process_read_stdout_once(procinfo, line);
 212
 213         /* if we're going to signal to the waitset that we're done (ie, non-zero
 214          * return value), then the waiters will remove us, so we drop the
 215          * reference */
 216         if (rc < 0) {
 217                 talloc_unlink(procset, procinfo);
 218                 procinfo->stdout_waiter = NULL;
 219                 rc = -1;
 220         } else {
 221                 rc = 0;
 222         }
 223
 224         return rc;
 225 }
 226
 227 static void sigchld_sigaction(int signo, siginfo_t *info,
 228                 void *arg __attribute__((unused)))
 229 {
 230         pid_t pid;
 231         int rc;
 232
 233         if (signo != SIGCHLD)
 234                 return;
 235
 236         pid = info->si_pid;
 237
 238         rc = write(procset->sigchld_pipe[1], &pid, sizeof(pid));
 239         if (rc != sizeof(pid))
 240                 pb_log_fn("write failed: %s\n", strerror(errno));
 241 }
 242
 243 static int sigchld_pipe_event(void *arg)
 244 {
 245         struct process_info *procinfo;
 246         struct procset *procset = arg;
 247         struct process *process;
 248         int pid, rc;
 249
 250         rc = read(procset->sigchld_pipe[0], &pid, sizeof(pid));
 251         if (rc != sizeof(pid))
 252                 return 0;
 253
 254         process = NULL;
 255         list_for_each_entry(&procset->async_list, procinfo, async_list) {
 256                 if (procinfo->process.pid == pid) {
 257                         process = &procinfo->process;
 258                         break;
 259                 }
 260         }
 261
 262         /* We'll receive SIGCHLD for synchronous processes too; just ignore */
 263         if (!process)
 264                 return 0;
 265
 266         rc = waitpid(process->pid, &process->exit_status, WNOHANG);
 267
 268         /* if the process is still running, ignore the event. We leave
 269          * the process in async_list so we can manage the final signal */
 270         if (rc == 0)
 271                 return 0;
 272
 273         /* ensure we have all of the child's stdout */
 274         process_read_stdout(procinfo);
 275
 276         if (process->exit_cb)
 277                 process->exit_cb(process);
 278
 279         list_remove(&procinfo->async_list);
 280         talloc_unlink(procset, procinfo);
 281
 282         return 0;
 283 }
 284
 285 static int process_fini(void *p)
 286 {
 287         struct procset *procset = p;
 288         struct sigaction sa;
 289
 290         memset(&sa, 0, sizeof(sa));
 291         sa.sa_handler = SIG_DFL;
 292
 293         sigaction(SIGCHLD, &sa, NULL);
 294
 295         waiter_remove(procset->sigchld_waiter);
 296
 297         close(procset->sigchld_pipe[0]);
 298         close(procset->sigchld_pipe[1]);
 299         return 0;
 300 }
 301
 302 struct procset *process_init(void *ctx, struct waitset *set, bool dry_run)
 303 {
 304         struct sigaction sa;
 305         int rc;
 306
 307         procset = talloc(ctx, struct procset);
 308         procset->waitset = set;
 309         procset->dry_run = dry_run;
 310         list_init(&procset->async_list);
 311
 312         rc = pipe(procset->sigchld_pipe);
 313         if (rc) {
 314                 pb_log_fn("pipe() failed: %s\n", strerror(errno));
 315                 goto err_free;
 316         }
 317
 318         procset->sigchld_waiter = waiter_register_io(set,
 319                                         procset->sigchld_pipe[0], WAIT_IN,
 320                                         sigchld_pipe_event, procset);
 321         if (!procset->sigchld_waiter)
 322                 goto err_close;
 323
 324         memset(&sa, 0, sizeof(sa));
 325         sa.sa_sigaction = sigchld_sigaction;
 326         sa.sa_flags = SA_SIGINFO | SA_NOCLDSTOP;
 327
 328         rc = sigaction(SIGCHLD, &sa, NULL);
 329         if (rc) {
 330                 pb_log_fn("sigaction() failed: %s\n",
 331                                 strerror(errno));
 332                 goto err_remove;
 333         }
 334
 335         talloc_set_destructor(procset, process_fini);
 336
 337         return procset;
 338
 339 err_remove:
 340         waiter_remove(procset->sigchld_waiter);
 341 err_close:
 342         close(procset->sigchld_pipe[0]);
 343         close(procset->sigchld_pipe[1]);
 344 err_free:
 345         talloc_free(procset);
 346         return NULL;
 347 }
 348
 349 struct process *process_create(void *ctx)
 350 {
 351         struct process_info *info = talloc_zero(ctx, struct process_info);
 352         info->orig_ctx = ctx;
 353         return &info->process;
 354 }
 355
 356 void process_release(struct process *process)
 357 {
 358         struct process_info *info = get_info(process);
 359         talloc_unlink(info->orig_ctx, info);
 360 }
 361
 362 static int process_run_common(struct process_info *procinfo)
 363 {
 364         struct process *process = &procinfo->process;
 365         const char *arg;
 366         char *logmsg;
 367         pid_t pid;
 368         int rc, i;
 369
 370         logmsg = talloc_asprintf(procinfo, " exe:  %s\n argv:", process->path);
 371         for (i = 0, arg = process->argv[i]; arg; i++, arg = process->argv[i])
 372                 logmsg = talloc_asprintf_append(logmsg, " '%s'", arg);
 373
 374         pb_log("Running command:\n%s\n", logmsg);
 375
 376         rc = process_setup_stdout_pipe(procinfo);
 377         if (rc)
 378                 return rc;
 379         if (procinfo->process.pipe_stdin) {
 380                 rc = pipe(procinfo->stdin_pipe);
 381                 if (rc)
 382                         return rc;
 383         }
 384
 385         pid = fork();
 386         if (pid < 0) {
 387                 pb_log_fn("fork failed: %s\n", strerror(errno));
 388                 return pid;
 389         }
 390
 391         if (pid == 0) {
 392                 process_setup_stdout_child(procinfo);
 393                 process_setup_stdin_child(procinfo);
 394                 if (procset->dry_run)
 395                         exit(EXIT_SUCCESS);
 396                 execvp(process->path, (char * const *)process->argv);
 397                 exit(EXIT_FAILURE);
 398         }
 399
 400         process_setup_stdout_parent(procinfo);
 401         process_setup_stdin_parent(procinfo);
 402         process->pid = pid;
 403
 404         return 0;
 405 }
 406
 407 int process_run_sync(struct process *process)
 408 {
 409         struct process_info *procinfo = get_info(process);
 410         int rc;
 411
 412         rc = process_run_common(procinfo);
 413         if (rc)
 414                 return rc;
 415
 416         process_read_stdout(procinfo);
 417
 418         for (;;) {
 419                 rc = waitpid(process->pid, &process->exit_status, 0);
 420                 if (rc >= 0)
 421                         break;
 422                 if (errno == EINTR)
 423                         continue;
 424
 425                 pb_log_fn("waitpid failed: %s\n", strerror(errno));
 426                 return rc;
 427         }
 428
 429         return 0;
 430 }
 431
 432 static int process_stdout_cb(struct process_info *procinfo)
 433 {
 434         return process_process_stdout(procinfo, NULL);
 435 }
 436
 437 int process_run_async(struct process *process)
 438 {
 439         struct process_info *procinfo = get_info(process);
 440         int rc;
 441
 442         rc = process_run_common(procinfo);
 443         if (rc)
 444                 return rc;
 445
 446         if (process->keep_stdout) {
 447                 waiter_cb stdout_cb = process->stdout_cb ?:
 448                         (waiter_cb)process_stdout_cb;
 449                 procinfo->stdout_waiter = waiter_register_io(procset->waitset,
 450                                                 procinfo->stdout_pipe[0],
 451                                                 WAIT_IN, stdout_cb, procinfo);
 452                 talloc_reference(procset, procinfo);
 453         }
 454
 455         list_add(&procset->async_list, &procinfo->async_list);
 456         talloc_reference(procset, procinfo);
 457
 458         return 0;
 459 }
 460
 461 void process_stop_async(struct process *process)
 462 {
 463         /* Avoid signalling an old pid */
 464         if (process->cancelled)
 465                 return;
 466
 467         pb_debug("process: sending SIGTERM to pid %d\n", process->pid);
 468         kill(process->pid, SIGTERM);
 469         process->cancelled = true;
 470 }
 471
 472 void process_stop_async_all(void)
 473 {
 474         struct process_info *procinfo;
 475         struct process *process = NULL;
 476
 477         pb_debug("process: cancelling all async jobs\n");
 478
 479         list_for_each_entry(&procset->async_list, procinfo, async_list) {
 480                 process = &procinfo->process;
 481                 /* Ignore the process completion - callbacks may use stale data */
 482                 process->exit_cb = NULL;
 483                 process->stdout_cb = NULL;
 484                 process_stop_async(process);
 485         }
 486 }
 487
 488 int process_get_stdout_argv(void *ctx, struct process_stdout **stdout,
 489         const char *argv[])
 490 {
 491         struct process *p;
 492         int rc;
 493
 494         p = process_create(NULL);
 495         p->path = argv[0];
 496         p->argv = argv;
 497
 498         if (stdout) {
 499                 p->keep_stdout = true;
 500                 *stdout = NULL;
 501         }
 502
 503         rc = process_run_sync(p);
 504
 505         if (!rc)
 506                 rc = p->exit_status;
 507         else {
 508                 pb_debug("%s: process_run_sync failed: %s.\n", __func__,
 509                         p->path);
 510                 if (stdout)
 511                         pb_debug("%s: stdout: %s\n\n", __func__, p->stdout_buf);
 512                 goto exit;
 513         }
 514
 515         if (!stdout)
 516                 goto exit;
 517
 518         *stdout = talloc(ctx, struct process_stdout);
 519
 520         if (!*stdout) {
 521                 rc = -1;
 522                 goto exit;
 523         }
 524
 525         (*stdout)->len = p->stdout_len;
 526         (*stdout)->buf = talloc_memdup(*stdout, p->stdout_buf,
 527                 p->stdout_len + 1);
 528         (*stdout)->buf[p->stdout_len] = 0;
 529
 530 exit:
 531         process_release(p);
 532         return rc;
 533 }
 534
 535 int process_get_stdout(void *ctx, struct process_stdout **stdout,
 536         const char *path, ...)
 537 {
 538         int rc, i, n_argv = 1;
 539         const char **argv;
 540         va_list ap;
 541
 542         va_start(ap, path);
 543         while (va_arg(ap, char *))
 544                 n_argv++;
 545         va_end(ap);
 546
 547         argv = talloc_array(ctx, const char *, n_argv + 1);
 548         argv[0] = path;
 549
 550         va_start(ap, path);
 551         for (i = 1; i < n_argv; i++)
 552                 argv[i] = va_arg(ap, const char *);
 553         va_end(ap);
 554
 555         argv[i] = NULL;
 556
 557         rc = process_get_stdout_argv(ctx, stdout, argv);
 558
 559         talloc_free(argv);
 560
 561         return rc;
 562 }
 563
 564 bool process_exit_ok(struct process *process)
 565 {
 566         return WIFEXITED(process->exit_status) &&
 567                 WEXITSTATUS(process->exit_status) == 0;
 568 }