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