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