meson: convert hw/vfio
[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 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
30 QIOChannelCommand *
31 qio_channel_command_new_pid(int writefd,
32 int readfd,
33 pid_t pid)
34 {
35 QIOChannelCommand *ioc;
36
37 ioc = QIO_CHANNEL_COMMAND(object_new(TYPE_QIO_CHANNEL_COMMAND));
38
39 ioc->readfd = readfd;
40 ioc->writefd = writefd;
41 ioc->pid = pid;
42
43 trace_qio_channel_command_new_pid(ioc, writefd, readfd, pid);
44 return ioc;
45 }
46
47
48 #ifndef WIN32
49 QIOChannelCommand *
50 qio_channel_command_new_spawn(const char *const argv[],
51 int flags,
52 Error **errp)
53 {
54 pid_t pid = -1;
55 int stdinfd[2] = { -1, -1 };
56 int stdoutfd[2] = { -1, -1 };
57 int devnull = -1;
58 bool stdinnull = false, stdoutnull = false;
59 QIOChannelCommand *ioc;
60
61 flags = flags & O_ACCMODE;
62
63 if (flags == O_RDONLY) {
64 stdinnull = true;
65 }
66 if (flags == O_WRONLY) {
67 stdoutnull = true;
68 }
69
70 if (stdinnull || stdoutnull) {
71 devnull = open("/dev/null", O_RDWR);
72 if (devnull < 0) {
73 error_setg_errno(errp, errno,
74 "Unable to open /dev/null");
75 goto error;
76 }
77 }
78
79 if ((!stdinnull && pipe(stdinfd) < 0) ||
80 (!stdoutnull && pipe(stdoutfd) < 0)) {
81 error_setg_errno(errp, errno,
82 "Unable to open pipe");
83 goto error;
84 }
85
86 pid = qemu_fork(errp);
87 if (pid < 0) {
88 goto error;
89 }
90
91 if (pid == 0) { /* child */
92 dup2(stdinnull ? devnull : stdinfd[0], STDIN_FILENO);
93 dup2(stdoutnull ? devnull : stdoutfd[1], STDOUT_FILENO);
94 /* Leave stderr connected to qemu's stderr */
95
96 if (!stdinnull) {
97 close(stdinfd[0]);
98 close(stdinfd[1]);
99 }
100 if (!stdoutnull) {
101 close(stdoutfd[0]);
102 close(stdoutfd[1]);
103 }
104 if (devnull != -1) {
105 close(devnull);
106 }
107
108 execv(argv[0], (char * const *)argv);
109 _exit(1);
110 }
111
112 if (!stdinnull) {
113 close(stdinfd[0]);
114 }
115 if (!stdoutnull) {
116 close(stdoutfd[1]);
117 }
118
119 ioc = qio_channel_command_new_pid(stdinnull ? devnull : stdinfd[1],
120 stdoutnull ? devnull : stdoutfd[0],
121 pid);
122 trace_qio_channel_command_new_spawn(ioc, argv[0], flags);
123 return ioc;
124
125 error:
126 if (devnull != -1) {
127 close(devnull);
128 }
129 if (stdinfd[0] != -1) {
130 close(stdinfd[0]);
131 }
132 if (stdinfd[1] != -1) {
133 close(stdinfd[1]);
134 }
135 if (stdoutfd[0] != -1) {
136 close(stdoutfd[0]);
137 }
138 if (stdoutfd[1] != -1) {
139 close(stdoutfd[1]);
140 }
141 return NULL;
142 }
143
144 #else /* WIN32 */
145 QIOChannelCommand *
146 qio_channel_command_new_spawn(const char *const argv[],
147 int flags,
148 Error **errp)
149 {
150 error_setg_errno(errp, ENOSYS,
151 "Command spawn not supported on this platform");
152 return NULL;
153 }
154 #endif /* WIN32 */
155
156 #ifndef WIN32
157 static int qio_channel_command_abort(QIOChannelCommand *ioc,
158 Error **errp)
159 {
160 pid_t ret;
161 int status;
162 int step = 0;
163
164 /* See if intermediate process has exited; if not, try a nice
165 * SIGTERM followed by a more severe SIGKILL.
166 */
167 rewait:
168 trace_qio_channel_command_abort(ioc, ioc->pid);
169 ret = waitpid(ioc->pid, &status, WNOHANG);
170 trace_qio_channel_command_wait(ioc, ioc->pid, ret, status);
171 if (ret == (pid_t)-1) {
172 if (errno == EINTR) {
173 goto rewait;
174 } else {
175 error_setg_errno(errp, errno,
176 "Cannot wait on pid %llu",
177 (unsigned long long)ioc->pid);
178 return -1;
179 }
180 } else if (ret == 0) {
181 if (step == 0) {
182 kill(ioc->pid, SIGTERM);
183 } else if (step == 1) {
184 kill(ioc->pid, SIGKILL);
185 } else {
186 error_setg(errp,
187 "Process %llu refused to die",
188 (unsigned long long)ioc->pid);
189 return -1;
190 }
191 step++;
192 usleep(10 * 1000);
193 goto rewait;
194 }
195
196 return 0;
197 }
198 #endif /* ! WIN32 */
199
200
201 static void qio_channel_command_init(Object *obj)
202 {
203 QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
204 ioc->readfd = -1;
205 ioc->writefd = -1;
206 ioc->pid = -1;
207 }
208
209 static void qio_channel_command_finalize(Object *obj)
210 {
211 QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
212 if (ioc->readfd != -1) {
213 close(ioc->readfd);
214 }
215 if (ioc->writefd != -1 &&
216 ioc->writefd != ioc->readfd) {
217 close(ioc->writefd);
218 }
219 ioc->writefd = ioc->readfd = -1;
220 if (ioc->pid > 0) {
221 #ifndef WIN32
222 qio_channel_command_abort(ioc, NULL);
223 #endif
224 }
225 }
226
227
228 static ssize_t qio_channel_command_readv(QIOChannel *ioc,
229 const struct iovec *iov,
230 size_t niov,
231 int **fds,
232 size_t *nfds,
233 Error **errp)
234 {
235 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
236 ssize_t ret;
237
238 retry:
239 ret = readv(cioc->readfd, iov, niov);
240 if (ret < 0) {
241 if (errno == EAGAIN) {
242 return QIO_CHANNEL_ERR_BLOCK;
243 }
244 if (errno == EINTR) {
245 goto retry;
246 }
247
248 error_setg_errno(errp, errno,
249 "Unable to read from command");
250 return -1;
251 }
252
253 return ret;
254 }
255
256 static ssize_t qio_channel_command_writev(QIOChannel *ioc,
257 const struct iovec *iov,
258 size_t niov,
259 int *fds,
260 size_t nfds,
261 Error **errp)
262 {
263 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
264 ssize_t ret;
265
266 retry:
267 ret = writev(cioc->writefd, iov, niov);
268 if (ret <= 0) {
269 if (errno == EAGAIN) {
270 return QIO_CHANNEL_ERR_BLOCK;
271 }
272 if (errno == EINTR) {
273 goto retry;
274 }
275 error_setg_errno(errp, errno, "%s",
276 "Unable to write to command");
277 return -1;
278 }
279 return ret;
280 }
281
282 static int qio_channel_command_set_blocking(QIOChannel *ioc,
283 bool enabled,
284 Error **errp)
285 {
286 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
287
288 if (enabled) {
289 qemu_set_block(cioc->writefd);
290 qemu_set_block(cioc->readfd);
291 } else {
292 qemu_set_nonblock(cioc->writefd);
293 qemu_set_nonblock(cioc->readfd);
294 }
295
296 return 0;
297 }
298
299
300 static int qio_channel_command_close(QIOChannel *ioc,
301 Error **errp)
302 {
303 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
304 int rv = 0;
305 #ifndef WIN32
306 pid_t wp;
307 #endif
308
309 /* We close FDs before killing, because that
310 * gives a better chance of clean shutdown
311 */
312 if (cioc->readfd != -1 &&
313 close(cioc->readfd) < 0) {
314 rv = -1;
315 }
316 if (cioc->writefd != -1 &&
317 cioc->writefd != cioc->readfd &&
318 close(cioc->writefd) < 0) {
319 rv = -1;
320 }
321 cioc->writefd = cioc->readfd = -1;
322
323 #ifndef WIN32
324 do {
325 wp = waitpid(cioc->pid, NULL, 0);
326 } while (wp == (pid_t)-1 && errno == EINTR);
327 if (wp == (pid_t)-1) {
328 error_setg_errno(errp, errno, "Failed to wait for pid %llu",
329 (unsigned long long)cioc->pid);
330 return -1;
331 }
332 #endif
333
334 if (rv < 0) {
335 error_setg_errno(errp, errno, "%s",
336 "Unable to close command");
337 }
338 return rv;
339 }
340
341
342 static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
343 AioContext *ctx,
344 IOHandler *io_read,
345 IOHandler *io_write,
346 void *opaque)
347 {
348 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
349 aio_set_fd_handler(ctx, cioc->readfd, false, io_read, NULL, NULL, opaque);
350 aio_set_fd_handler(ctx, cioc->writefd, false, NULL, io_write, NULL, opaque);
351 }
352
353
354 static GSource *qio_channel_command_create_watch(QIOChannel *ioc,
355 GIOCondition condition)
356 {
357 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
358 return qio_channel_create_fd_pair_watch(ioc,
359 cioc->readfd,
360 cioc->writefd,
361 condition);
362 }
363
364
365 static void qio_channel_command_class_init(ObjectClass *klass,
366 void *class_data G_GNUC_UNUSED)
367 {
368 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
369
370 ioc_klass->io_writev = qio_channel_command_writev;
371 ioc_klass->io_readv = qio_channel_command_readv;
372 ioc_klass->io_set_blocking = qio_channel_command_set_blocking;
373 ioc_klass->io_close = qio_channel_command_close;
374 ioc_klass->io_create_watch = qio_channel_command_create_watch;
375 ioc_klass->io_set_aio_fd_handler = qio_channel_command_set_aio_fd_handler;
376 }
377
378 static const TypeInfo qio_channel_command_info = {
379 .parent = TYPE_QIO_CHANNEL,
380 .name = TYPE_QIO_CHANNEL_COMMAND,
381 .instance_size = sizeof(QIOChannelCommand),
382 .instance_init = qio_channel_command_init,
383 .instance_finalize = qio_channel_command_finalize,
384 .class_init = qio_channel_command_class_init,
385 };
386
387 static void qio_channel_command_register_types(void)
388 {
389 type_register_static(&qio_channel_command_info);
390 }
391
392 type_init(qio_channel_command_register_types);