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