Merge tag 'pull-riscv-to-apply-20220703-1' of github.com:alistair23/qemu into staging
[qemu.git] / io / channel-command.c
1 /*
2 * QEMU I/O channels external command driver
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "qemu/osdep.h"
22 #include "io/channel-command.h"
23 #include "io/channel-watch.h"
24 #include "qapi/error.h"
25 #include "qemu/module.h"
26 #include "qemu/sockets.h"
27 #include "trace.h"
28
29 #ifndef WIN32
30 /**
31 * qio_channel_command_new_pid:
32 * @writefd: the FD connected to the command's stdin
33 * @readfd: the FD connected to the command's stdout
34 * @pid: the PID of the running child command
35 * @errp: pointer to a NULL-initialized error object
36 *
37 * Create a channel for performing I/O with the
38 * previously spawned command identified by @pid.
39 * The two file descriptors provide the connection
40 * to command's stdio streams, either one or which
41 * may be -1 to indicate that stream is not open.
42 *
43 * The channel will take ownership of the process
44 * @pid and will kill it when closing the channel.
45 * Similarly it will take responsibility for
46 * closing the file descriptors @writefd and @readfd.
47 *
48 * Returns: the command channel object, or NULL on error
49 */
50 static QIOChannelCommand *
51 qio_channel_command_new_pid(int writefd,
52 int readfd,
53 pid_t pid)
54 {
55 QIOChannelCommand *ioc;
56
57 ioc = QIO_CHANNEL_COMMAND(object_new(TYPE_QIO_CHANNEL_COMMAND));
58
59 ioc->readfd = readfd;
60 ioc->writefd = writefd;
61 ioc->pid = pid;
62
63 trace_qio_channel_command_new_pid(ioc, writefd, readfd, pid);
64 return ioc;
65 }
66
67 QIOChannelCommand *
68 qio_channel_command_new_spawn(const char *const argv[],
69 int flags,
70 Error **errp)
71 {
72 pid_t pid = -1;
73 int stdinfd[2] = { -1, -1 };
74 int stdoutfd[2] = { -1, -1 };
75 int devnull = -1;
76 bool stdinnull = false, stdoutnull = false;
77 QIOChannelCommand *ioc;
78
79 flags = flags & O_ACCMODE;
80
81 if (flags == O_RDONLY) {
82 stdinnull = true;
83 }
84 if (flags == O_WRONLY) {
85 stdoutnull = true;
86 }
87
88 if (stdinnull || stdoutnull) {
89 devnull = open("/dev/null", O_RDWR);
90 if (devnull < 0) {
91 error_setg_errno(errp, errno,
92 "Unable to open /dev/null");
93 goto error;
94 }
95 }
96
97 if ((!stdinnull && !g_unix_open_pipe(stdinfd, FD_CLOEXEC, NULL)) ||
98 (!stdoutnull && !g_unix_open_pipe(stdoutfd, FD_CLOEXEC, NULL))) {
99 error_setg_errno(errp, errno,
100 "Unable to open pipe");
101 goto error;
102 }
103
104 pid = qemu_fork(errp);
105 if (pid < 0) {
106 goto error;
107 }
108
109 if (pid == 0) { /* child */
110 dup2(stdinnull ? devnull : stdinfd[0], STDIN_FILENO);
111 dup2(stdoutnull ? devnull : stdoutfd[1], STDOUT_FILENO);
112 /* Leave stderr connected to qemu's stderr */
113
114 if (!stdinnull) {
115 close(stdinfd[0]);
116 close(stdinfd[1]);
117 }
118 if (!stdoutnull) {
119 close(stdoutfd[0]);
120 close(stdoutfd[1]);
121 }
122 if (devnull != -1) {
123 close(devnull);
124 }
125
126 execv(argv[0], (char * const *)argv);
127 _exit(1);
128 }
129
130 if (!stdinnull) {
131 close(stdinfd[0]);
132 }
133 if (!stdoutnull) {
134 close(stdoutfd[1]);
135 }
136
137 ioc = qio_channel_command_new_pid(stdinnull ? devnull : stdinfd[1],
138 stdoutnull ? devnull : stdoutfd[0],
139 pid);
140 trace_qio_channel_command_new_spawn(ioc, argv[0], flags);
141 return ioc;
142
143 error:
144 if (devnull != -1) {
145 close(devnull);
146 }
147 if (stdinfd[0] != -1) {
148 close(stdinfd[0]);
149 }
150 if (stdinfd[1] != -1) {
151 close(stdinfd[1]);
152 }
153 if (stdoutfd[0] != -1) {
154 close(stdoutfd[0]);
155 }
156 if (stdoutfd[1] != -1) {
157 close(stdoutfd[1]);
158 }
159 return NULL;
160 }
161
162 #else /* WIN32 */
163 QIOChannelCommand *
164 qio_channel_command_new_spawn(const char *const argv[],
165 int flags,
166 Error **errp)
167 {
168 error_setg_errno(errp, ENOSYS,
169 "Command spawn not supported on this platform");
170 return NULL;
171 }
172 #endif /* WIN32 */
173
174 #ifndef WIN32
175 static int qio_channel_command_abort(QIOChannelCommand *ioc,
176 Error **errp)
177 {
178 pid_t ret;
179 int status;
180 int step = 0;
181
182 /* See if intermediate process has exited; if not, try a nice
183 * SIGTERM followed by a more severe SIGKILL.
184 */
185 rewait:
186 trace_qio_channel_command_abort(ioc, ioc->pid);
187 ret = waitpid(ioc->pid, &status, WNOHANG);
188 trace_qio_channel_command_wait(ioc, ioc->pid, ret, status);
189 if (ret == (pid_t)-1) {
190 if (errno == EINTR) {
191 goto rewait;
192 } else {
193 error_setg_errno(errp, errno,
194 "Cannot wait on pid %llu",
195 (unsigned long long)ioc->pid);
196 return -1;
197 }
198 } else if (ret == 0) {
199 if (step == 0) {
200 kill(ioc->pid, SIGTERM);
201 } else if (step == 1) {
202 kill(ioc->pid, SIGKILL);
203 } else {
204 error_setg(errp,
205 "Process %llu refused to die",
206 (unsigned long long)ioc->pid);
207 return -1;
208 }
209 step++;
210 usleep(10 * 1000);
211 goto rewait;
212 }
213
214 return 0;
215 }
216 #endif /* ! WIN32 */
217
218
219 static void qio_channel_command_init(Object *obj)
220 {
221 QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
222 ioc->readfd = -1;
223 ioc->writefd = -1;
224 ioc->pid = -1;
225 }
226
227 static void qio_channel_command_finalize(Object *obj)
228 {
229 QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
230 if (ioc->readfd != -1) {
231 close(ioc->readfd);
232 }
233 if (ioc->writefd != -1 &&
234 ioc->writefd != ioc->readfd) {
235 close(ioc->writefd);
236 }
237 ioc->writefd = ioc->readfd = -1;
238 if (ioc->pid > 0) {
239 #ifndef WIN32
240 qio_channel_command_abort(ioc, NULL);
241 #endif
242 }
243 }
244
245
246 static ssize_t qio_channel_command_readv(QIOChannel *ioc,
247 const struct iovec *iov,
248 size_t niov,
249 int **fds,
250 size_t *nfds,
251 Error **errp)
252 {
253 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
254 ssize_t ret;
255
256 retry:
257 ret = readv(cioc->readfd, iov, niov);
258 if (ret < 0) {
259 if (errno == EAGAIN) {
260 return QIO_CHANNEL_ERR_BLOCK;
261 }
262 if (errno == EINTR) {
263 goto retry;
264 }
265
266 error_setg_errno(errp, errno,
267 "Unable to read from command");
268 return -1;
269 }
270
271 return ret;
272 }
273
274 static ssize_t qio_channel_command_writev(QIOChannel *ioc,
275 const struct iovec *iov,
276 size_t niov,
277 int *fds,
278 size_t nfds,
279 int flags,
280 Error **errp)
281 {
282 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
283 ssize_t ret;
284
285 retry:
286 ret = writev(cioc->writefd, iov, niov);
287 if (ret <= 0) {
288 if (errno == EAGAIN) {
289 return QIO_CHANNEL_ERR_BLOCK;
290 }
291 if (errno == EINTR) {
292 goto retry;
293 }
294 error_setg_errno(errp, errno, "%s",
295 "Unable to write to command");
296 return -1;
297 }
298 return ret;
299 }
300
301 static int qio_channel_command_set_blocking(QIOChannel *ioc,
302 bool enabled,
303 Error **errp)
304 {
305 #ifdef WIN32
306 /* command spawn is not supported on win32 */
307 g_assert_not_reached();
308 #else
309 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
310
311 if (!g_unix_set_fd_nonblocking(cioc->writefd, !enabled, NULL) ||
312 !g_unix_set_fd_nonblocking(cioc->readfd, !enabled, NULL)) {
313 error_setg_errno(errp, errno, "Failed to set FD nonblocking");
314 return -1;
315 }
316 #endif
317 return 0;
318 }
319
320
321 static int qio_channel_command_close(QIOChannel *ioc,
322 Error **errp)
323 {
324 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
325 int rv = 0;
326 #ifndef WIN32
327 pid_t wp;
328 #endif
329
330 /* We close FDs before killing, because that
331 * gives a better chance of clean shutdown
332 */
333 if (cioc->readfd != -1 &&
334 close(cioc->readfd) < 0) {
335 rv = -1;
336 }
337 if (cioc->writefd != -1 &&
338 cioc->writefd != cioc->readfd &&
339 close(cioc->writefd) < 0) {
340 rv = -1;
341 }
342 cioc->writefd = cioc->readfd = -1;
343
344 #ifndef WIN32
345 do {
346 wp = waitpid(cioc->pid, NULL, 0);
347 } while (wp == (pid_t)-1 && errno == EINTR);
348 if (wp == (pid_t)-1) {
349 error_setg_errno(errp, errno, "Failed to wait for pid %llu",
350 (unsigned long long)cioc->pid);
351 return -1;
352 }
353 #endif
354
355 if (rv < 0) {
356 error_setg_errno(errp, errno, "%s",
357 "Unable to close command");
358 }
359 return rv;
360 }
361
362
363 static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
364 AioContext *ctx,
365 IOHandler *io_read,
366 IOHandler *io_write,
367 void *opaque)
368 {
369 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
370 aio_set_fd_handler(ctx, cioc->readfd, false,
371 io_read, NULL, NULL, NULL, opaque);
372 aio_set_fd_handler(ctx, cioc->writefd, false,
373 NULL, io_write, NULL, NULL, opaque);
374 }
375
376
377 static GSource *qio_channel_command_create_watch(QIOChannel *ioc,
378 GIOCondition condition)
379 {
380 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
381 return qio_channel_create_fd_pair_watch(ioc,
382 cioc->readfd,
383 cioc->writefd,
384 condition);
385 }
386
387
388 static void qio_channel_command_class_init(ObjectClass *klass,
389 void *class_data G_GNUC_UNUSED)
390 {
391 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
392
393 ioc_klass->io_writev = qio_channel_command_writev;
394 ioc_klass->io_readv = qio_channel_command_readv;
395 ioc_klass->io_set_blocking = qio_channel_command_set_blocking;
396 ioc_klass->io_close = qio_channel_command_close;
397 ioc_klass->io_create_watch = qio_channel_command_create_watch;
398 ioc_klass->io_set_aio_fd_handler = qio_channel_command_set_aio_fd_handler;
399 }
400
401 static const TypeInfo qio_channel_command_info = {
402 .parent = TYPE_QIO_CHANNEL,
403 .name = TYPE_QIO_CHANNEL_COMMAND,
404 .instance_size = sizeof(QIOChannelCommand),
405 .instance_init = qio_channel_command_init,
406 .instance_finalize = qio_channel_command_finalize,
407 .class_init = qio_channel_command_class_init,
408 };
409
410 static void qio_channel_command_register_types(void)
411 {
412 type_register_static(&qio_channel_command_info);
413 }
414
415 type_init(qio_channel_command_register_types);