qemu

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