channel-command.c (11337B)
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);