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