xref: /openbmc/qemu/io/channel-command.c (revision 2e1cacfb)
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-util.h"
24 #include "io/channel-watch.h"
25 #include "qapi/error.h"
26 #include "qemu/module.h"
27 #include "qemu/sockets.h"
28 #include "trace.h"
29 
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/HANDLE 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                             GPid 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,
64 #ifdef WIN32
65                                       GetProcessId(pid)
66 #else
67                                       pid
68 #endif
69         );
70     return ioc;
71 }
72 
73 QIOChannelCommand *
74 qio_channel_command_new_spawn(const char *const argv[],
75                               int flags,
76                               Error **errp)
77 {
78     g_autoptr(GError) err = NULL;
79     GPid pid = 0;
80     GSpawnFlags gflags = G_SPAWN_CLOEXEC_PIPES | G_SPAWN_DO_NOT_REAP_CHILD;
81     int stdinfd = -1, stdoutfd = -1;
82 
83     flags = flags & O_ACCMODE;
84     gflags |= flags == O_WRONLY ? G_SPAWN_STDOUT_TO_DEV_NULL : 0;
85 
86     if (!g_spawn_async_with_pipes(NULL, (char **)argv, NULL, gflags, NULL, NULL,
87                                   &pid,
88                                   flags == O_RDONLY ? NULL : &stdinfd,
89                                   flags == O_WRONLY ? NULL : &stdoutfd,
90                                   NULL, &err)) {
91         error_setg(errp, "%s", err->message);
92         return NULL;
93     }
94 
95     return qio_channel_command_new_pid(stdinfd, stdoutfd, pid);
96 }
97 
98 #ifndef WIN32
99 static int qio_channel_command_abort(QIOChannelCommand *ioc,
100                                      Error **errp)
101 {
102     pid_t ret;
103     int status;
104     int step = 0;
105 
106     /* See if intermediate process has exited; if not, try a nice
107      * SIGTERM followed by a more severe SIGKILL.
108      */
109  rewait:
110     trace_qio_channel_command_abort(ioc, ioc->pid);
111     ret = waitpid(ioc->pid, &status, WNOHANG);
112     trace_qio_channel_command_wait(ioc, ioc->pid, ret, status);
113     if (ret == (pid_t)-1) {
114         if (errno == EINTR) {
115             goto rewait;
116         } else {
117             error_setg_errno(errp, errno,
118                              "Cannot wait on pid %llu",
119                              (unsigned long long)ioc->pid);
120             return -1;
121         }
122     } else if (ret == 0) {
123         if (step == 0) {
124             kill(ioc->pid, SIGTERM);
125         } else if (step == 1) {
126             kill(ioc->pid, SIGKILL);
127         } else {
128             error_setg(errp,
129                        "Process %llu refused to die",
130                        (unsigned long long)ioc->pid);
131             return -1;
132         }
133         step++;
134         usleep(10 * 1000);
135         goto rewait;
136     }
137 
138     return 0;
139 }
140 #else
141 static int qio_channel_command_abort(QIOChannelCommand *ioc,
142                                      Error **errp)
143 {
144     DWORD ret;
145 
146     TerminateProcess(ioc->pid, 0);
147     ret = WaitForSingleObject(ioc->pid, 1000);
148     if (ret != WAIT_OBJECT_0) {
149         error_setg(errp,
150                    "Process %llu refused to die",
151                    (unsigned long long)GetProcessId(ioc->pid));
152         return -1;
153     }
154 
155     return 0;
156 }
157 #endif /* ! WIN32 */
158 
159 
160 static void qio_channel_command_init(Object *obj)
161 {
162     QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
163     ioc->readfd = -1;
164     ioc->writefd = -1;
165     ioc->pid = 0;
166 }
167 
168 static void qio_channel_command_finalize(Object *obj)
169 {
170     QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
171     if (ioc->readfd != -1) {
172         close(ioc->readfd);
173     }
174     if (ioc->writefd != -1 &&
175         ioc->writefd != ioc->readfd) {
176         close(ioc->writefd);
177     }
178     ioc->writefd = ioc->readfd = -1;
179     if (ioc->pid > 0) {
180         qio_channel_command_abort(ioc, NULL);
181         g_spawn_close_pid(ioc->pid);
182     }
183 }
184 
185 #ifdef WIN32
186 static bool win32_fd_poll(int fd, gushort events)
187 {
188     GPollFD pfd = { .fd = _get_osfhandle(fd), .events = events };
189     int res;
190 
191     do {
192         res = g_poll(&pfd, 1, 0);
193     } while (res < 0 && errno == EINTR);
194     if (res == 0) {
195         return false;
196     }
197 
198     return true;
199 }
200 #endif
201 
202 static ssize_t qio_channel_command_readv(QIOChannel *ioc,
203                                          const struct iovec *iov,
204                                          size_t niov,
205                                          int **fds,
206                                          size_t *nfds,
207                                          int flags,
208                                          Error **errp)
209 {
210     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
211     ssize_t ret;
212 
213 #ifdef WIN32
214     if (!cioc->blocking && !win32_fd_poll(cioc->readfd, G_IO_IN)) {
215         return QIO_CHANNEL_ERR_BLOCK;
216     }
217 #endif
218 
219  retry:
220     ret = readv(cioc->readfd, iov, niov);
221     if (ret < 0) {
222         if (errno == EAGAIN) {
223             return QIO_CHANNEL_ERR_BLOCK;
224         }
225         if (errno == EINTR) {
226             goto retry;
227         }
228 
229         error_setg_errno(errp, errno,
230                          "Unable to read from command");
231         return -1;
232     }
233 
234     return ret;
235 }
236 
237 static ssize_t qio_channel_command_writev(QIOChannel *ioc,
238                                           const struct iovec *iov,
239                                           size_t niov,
240                                           int *fds,
241                                           size_t nfds,
242                                           int flags,
243                                           Error **errp)
244 {
245     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
246     ssize_t ret;
247 
248 #ifdef WIN32
249     if (!cioc->blocking && !win32_fd_poll(cioc->writefd, G_IO_OUT)) {
250         return QIO_CHANNEL_ERR_BLOCK;
251     }
252 #endif
253 
254  retry:
255     ret = writev(cioc->writefd, iov, niov);
256     if (ret <= 0) {
257         if (errno == EAGAIN) {
258             return QIO_CHANNEL_ERR_BLOCK;
259         }
260         if (errno == EINTR) {
261             goto retry;
262         }
263         error_setg_errno(errp, errno, "%s",
264                          "Unable to write to command");
265         return -1;
266     }
267     return ret;
268 }
269 
270 static int qio_channel_command_set_blocking(QIOChannel *ioc,
271                                             bool enabled,
272                                             Error **errp)
273 {
274     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
275 
276 #ifdef WIN32
277     cioc->blocking = enabled;
278 #else
279 
280     if ((cioc->writefd >= 0 && !g_unix_set_fd_nonblocking(cioc->writefd, !enabled, NULL)) ||
281         (cioc->readfd >= 0 && !g_unix_set_fd_nonblocking(cioc->readfd, !enabled, NULL))) {
282         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
283         return -1;
284     }
285 #endif
286     return 0;
287 }
288 
289 
290 static int qio_channel_command_close(QIOChannel *ioc,
291                                      Error **errp)
292 {
293     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
294     int rv = 0;
295 #ifndef WIN32
296     pid_t wp;
297 #endif
298 
299     /* We close FDs before killing, because that
300      * gives a better chance of clean shutdown
301      */
302     if (cioc->readfd != -1 &&
303         close(cioc->readfd) < 0) {
304         rv = -1;
305     }
306     if (cioc->writefd != -1 &&
307         cioc->writefd != cioc->readfd &&
308         close(cioc->writefd) < 0) {
309         rv = -1;
310     }
311     cioc->writefd = cioc->readfd = -1;
312 
313 #ifndef WIN32
314     do {
315         wp = waitpid(cioc->pid, NULL, 0);
316     } while (wp == (pid_t)-1 && errno == EINTR);
317     if (wp == (pid_t)-1) {
318         error_setg_errno(errp, errno, "Failed to wait for pid %llu",
319                          (unsigned long long)cioc->pid);
320         return -1;
321     }
322 #else
323     WaitForSingleObject(cioc->pid, INFINITE);
324 #endif
325 
326     if (rv < 0) {
327         error_setg_errno(errp, errno, "%s",
328                          "Unable to close command");
329     }
330     return rv;
331 }
332 
333 
334 static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
335                                                    AioContext *read_ctx,
336                                                    IOHandler *io_read,
337                                                    AioContext *write_ctx,
338                                                    IOHandler *io_write,
339                                                    void *opaque)
340 {
341     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
342 
343     qio_channel_util_set_aio_fd_handler(cioc->readfd, read_ctx, io_read,
344                                         cioc->writefd, write_ctx, io_write,
345                                         opaque);
346 }
347 
348 
349 static GSource *qio_channel_command_create_watch(QIOChannel *ioc,
350                                                  GIOCondition condition)
351 {
352     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
353     return qio_channel_create_fd_pair_watch(ioc,
354                                             cioc->readfd,
355                                             cioc->writefd,
356                                             condition);
357 }
358 
359 
360 static void qio_channel_command_class_init(ObjectClass *klass,
361                                            void *class_data G_GNUC_UNUSED)
362 {
363     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
364 
365     ioc_klass->io_writev = qio_channel_command_writev;
366     ioc_klass->io_readv = qio_channel_command_readv;
367     ioc_klass->io_set_blocking = qio_channel_command_set_blocking;
368     ioc_klass->io_close = qio_channel_command_close;
369     ioc_klass->io_create_watch = qio_channel_command_create_watch;
370     ioc_klass->io_set_aio_fd_handler = qio_channel_command_set_aio_fd_handler;
371 }
372 
373 static const TypeInfo qio_channel_command_info = {
374     .parent = TYPE_QIO_CHANNEL,
375     .name = TYPE_QIO_CHANNEL_COMMAND,
376     .instance_size = sizeof(QIOChannelCommand),
377     .instance_init = qio_channel_command_init,
378     .instance_finalize = qio_channel_command_finalize,
379     .class_init = qio_channel_command_class_init,
380 };
381 
382 static void qio_channel_command_register_types(void)
383 {
384     type_register_static(&qio_channel_command_info);
385 }
386 
387 type_init(qio_channel_command_register_types);
388