1// SPDX-License-Identifier: GPL-2.0
2#include <unistd.h>
3#include <sys/types.h>
4#include <sys/stat.h>
5#include <ctype.h>
6#include <fcntl.h>
7#include <string.h>
8#include <linux/compiler.h>
9#include <linux/string.h>
10#include <errno.h>
11#include <sys/wait.h>
12#include "subcmd-util.h"
13#include "run-command.h"
14#include "exec-cmd.h"
15
16#define STRERR_BUFSIZE 128
17
18static inline void close_pair(int fd[2])
19{
20 close(fd[0]);
21 close(fd[1]);
22}
23
24static inline void dup_devnull(int to)
25{
26 int fd = open("/dev/null", O_RDWR);
27 dup2(fd, to);
28 close(fd);
29}
30
31int start_command(struct child_process *cmd)
32{
33 int need_in, need_out, need_err;
34 int fdin[2], fdout[2], fderr[2];
35 char sbuf[STRERR_BUFSIZE];
36
37 /*
38 * In case of errors we must keep the promise to close FDs
39 * that have been passed in via ->in and ->out.
40 */
41
42 need_in = !cmd->no_stdin && cmd->in < 0;
43 if (need_in) {
44 if (pipe(fdin) < 0) {
45 if (cmd->out > 0)
46 close(cmd->out);
47 return -ERR_RUN_COMMAND_PIPE;
48 }
49 cmd->in = fdin[1];
50 }
51
52 need_out = !cmd->no_stdout
53 && !cmd->stdout_to_stderr
54 && cmd->out < 0;
55 if (need_out) {
56 if (pipe(fdout) < 0) {
57 if (need_in)
58 close_pair(fd: fdin);
59 else if (cmd->in)
60 close(cmd->in);
61 return -ERR_RUN_COMMAND_PIPE;
62 }
63 cmd->out = fdout[0];
64 }
65
66 need_err = !cmd->no_stderr && cmd->err < 0;
67 if (need_err) {
68 if (pipe(fderr) < 0) {
69 if (need_in)
70 close_pair(fd: fdin);
71 else if (cmd->in)
72 close(cmd->in);
73 if (need_out)
74 close_pair(fd: fdout);
75 else if (cmd->out)
76 close(cmd->out);
77 return -ERR_RUN_COMMAND_PIPE;
78 }
79 cmd->err = fderr[0];
80 }
81
82 fflush(NULL);
83 cmd->pid = fork();
84 if (!cmd->pid) {
85 if (cmd->no_stdin)
86 dup_devnull(to: 0);
87 else if (need_in) {
88 dup2(fdin[0], 0);
89 close_pair(fd: fdin);
90 } else if (cmd->in) {
91 dup2(cmd->in, 0);
92 close(cmd->in);
93 }
94
95 if (cmd->no_stderr)
96 dup_devnull(to: 2);
97 else if (need_err) {
98 dup2(fderr[1], 2);
99 close_pair(fd: fderr);
100 }
101
102 if (cmd->no_stdout)
103 dup_devnull(to: 1);
104 else if (cmd->stdout_to_stderr)
105 dup2(2, 1);
106 else if (need_out) {
107 dup2(fdout[1], 1);
108 close_pair(fd: fdout);
109 } else if (cmd->out > 1) {
110 dup2(cmd->out, 1);
111 close(cmd->out);
112 }
113
114 if (cmd->dir && chdir(cmd->dir))
115 die(err: "exec %s: cd to %s failed (%s)", cmd->argv[0],
116 cmd->dir, str_error_r(errno, sbuf, sizeof(sbuf)));
117 if (cmd->env) {
118 for (; *cmd->env; cmd->env++) {
119 if (strchr(*cmd->env, '='))
120 putenv((char*)*cmd->env);
121 else
122 unsetenv(*cmd->env);
123 }
124 }
125 if (cmd->preexec_cb)
126 cmd->preexec_cb();
127 if (cmd->no_exec_cmd)
128 exit(cmd->no_exec_cmd(cmd));
129 if (cmd->exec_cmd) {
130 execv_cmd(argv: cmd->argv);
131 } else {
132 execvp(cmd->argv[0], (char *const*) cmd->argv);
133 }
134 exit(127);
135 }
136
137 if (cmd->pid < 0) {
138 int err = errno;
139 if (need_in)
140 close_pair(fd: fdin);
141 else if (cmd->in)
142 close(cmd->in);
143 if (need_out)
144 close_pair(fd: fdout);
145 else if (cmd->out)
146 close(cmd->out);
147 if (need_err)
148 close_pair(fd: fderr);
149 return err == ENOENT ?
150 -ERR_RUN_COMMAND_EXEC :
151 -ERR_RUN_COMMAND_FORK;
152 }
153
154 if (need_in)
155 close(fdin[0]);
156 else if (cmd->in)
157 close(cmd->in);
158
159 if (need_out)
160 close(fdout[1]);
161 else if (cmd->out)
162 close(cmd->out);
163
164 if (need_err)
165 close(fderr[1]);
166
167 return 0;
168}
169
170static int wait_or_whine(struct child_process *cmd, bool block)
171{
172 bool finished = cmd->finished;
173 int result = cmd->finish_result;
174
175 while (!finished) {
176 int status, code;
177 pid_t waiting = waitpid(cmd->pid, &status, block ? 0 : WNOHANG);
178
179 if (!block && waiting == 0)
180 break;
181
182 if (waiting < 0 && errno == EINTR)
183 continue;
184
185 finished = true;
186 if (waiting < 0) {
187 char sbuf[STRERR_BUFSIZE];
188
189 fprintf(stderr, " Error: waitpid failed (%s)",
190 str_error_r(errno, sbuf, sizeof(sbuf)));
191 result = -ERR_RUN_COMMAND_WAITPID;
192 } else if (waiting != cmd->pid) {
193 result = -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
194 } else if (WIFSIGNALED(status)) {
195 result = -ERR_RUN_COMMAND_WAITPID_SIGNAL;
196 } else if (!WIFEXITED(status)) {
197 result = -ERR_RUN_COMMAND_WAITPID_NOEXIT;
198 } else {
199 code = WEXITSTATUS(status);
200 switch (code) {
201 case 127:
202 result = -ERR_RUN_COMMAND_EXEC;
203 break;
204 case 0:
205 result = 0;
206 break;
207 default:
208 result = -code;
209 break;
210 }
211 }
212 }
213 if (finished) {
214 cmd->finished = 1;
215 cmd->finish_result = result;
216 }
217 return result;
218}
219
220/*
221 * Conservative estimate of number of characaters needed to hold an a decoded
222 * integer, assume each 3 bits needs a character byte and plus a possible sign
223 * character.
224 */
225#ifndef is_signed_type
226#define is_signed_type(type) (((type)(-1)) < (type)1)
227#endif
228#define MAX_STRLEN_TYPE(type) (sizeof(type) * 8 / 3 + (is_signed_type(type) ? 1 : 0))
229
230int check_if_command_finished(struct child_process *cmd)
231{
232#ifdef __linux__
233 char filename[6 + MAX_STRLEN_TYPE(typeof(cmd->pid)) + 7 + 1];
234 char status_line[256];
235 FILE *status_file;
236
237 /*
238 * Check by reading /proc/<pid>/status as calling waitpid causes
239 * stdout/stderr to be closed and data lost.
240 */
241 sprintf(filename, "/proc/%u/status", cmd->pid);
242 status_file = fopen(filename, "r");
243 if (status_file == NULL) {
244 /* Open failed assume finish_command was called. */
245 return true;
246 }
247 while (fgets(status_line, sizeof(status_line), status_file) != NULL) {
248 char *p;
249
250 if (strncmp(status_line, "State:", 6))
251 continue;
252
253 fclose(status_file);
254 p = status_line + 6;
255 while (isspace(*p))
256 p++;
257 return *p == 'Z' ? 1 : 0;
258 }
259 /* Read failed assume finish_command was called. */
260 fclose(status_file);
261 return 1;
262#else
263 wait_or_whine(cmd, /*block=*/false);
264 return cmd->finished;
265#endif
266}
267
268int finish_command(struct child_process *cmd)
269{
270 return wait_or_whine(cmd, /*block=*/true);
271}
272
273int run_command(struct child_process *cmd)
274{
275 int code = start_command(cmd);
276 if (code)
277 return code;
278 return finish_command(cmd);
279}
280
281static void prepare_run_command_v_opt(struct child_process *cmd,
282 const char **argv,
283 int opt)
284{
285 memset(cmd, 0, sizeof(*cmd));
286 cmd->argv = argv;
287 cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
288 cmd->exec_cmd = opt & RUN_EXEC_CMD ? 1 : 0;
289 cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
290}
291
292int run_command_v_opt(const char **argv, int opt)
293{
294 struct child_process cmd;
295 prepare_run_command_v_opt(cmd: &cmd, argv, opt);
296 return run_command(cmd: &cmd);
297}
298

source code of linux/tools/lib/subcmd/run-command.c