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 errno == EWOULDBLOCK) { 241 return QIO_CHANNEL_ERR_BLOCK; 242 } 243 if (errno == EINTR) { 244 goto retry; 245 } 246 247 error_setg_errno(errp, errno, 248 "Unable to read from command"); 249 return -1; 250 } 251 252 return ret; 253 } 254 255 static ssize_t qio_channel_command_writev(QIOChannel *ioc, 256 const struct iovec *iov, 257 size_t niov, 258 int *fds, 259 size_t nfds, 260 Error **errp) 261 { 262 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc); 263 ssize_t ret; 264 265 retry: 266 ret = writev(cioc->writefd, iov, niov); 267 if (ret <= 0) { 268 if (errno == EAGAIN || 269 errno == EWOULDBLOCK) { 270 return QIO_CHANNEL_ERR_BLOCK; 271 } 272 if (errno == EINTR) { 273 goto retry; 274 } 275 error_setg_errno(errp, errno, "%s", 276 "Unable to write to command"); 277 return -1; 278 } 279 return ret; 280 } 281 282 static int qio_channel_command_set_blocking(QIOChannel *ioc, 283 bool enabled, 284 Error **errp) 285 { 286 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc); 287 288 if (enabled) { 289 qemu_set_block(cioc->writefd); 290 qemu_set_block(cioc->readfd); 291 } else { 292 qemu_set_nonblock(cioc->writefd); 293 qemu_set_nonblock(cioc->readfd); 294 } 295 296 return 0; 297 } 298 299 300 static int qio_channel_command_close(QIOChannel *ioc, 301 Error **errp) 302 { 303 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc); 304 int rv = 0; 305 306 /* We close FDs before killing, because that 307 * gives a better chance of clean shutdown 308 */ 309 if (cioc->readfd != -1 && 310 close(cioc->readfd) < 0) { 311 rv = -1; 312 } 313 if (cioc->writefd != -1 && 314 cioc->writefd != cioc->readfd && 315 close(cioc->writefd) < 0) { 316 rv = -1; 317 } 318 cioc->writefd = cioc->readfd = -1; 319 #ifndef WIN32 320 if (qio_channel_command_abort(cioc, errp) < 0) { 321 return -1; 322 } 323 #endif 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 GSource *qio_channel_command_create_watch(QIOChannel *ioc, 333 GIOCondition condition) 334 { 335 QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc); 336 return qio_channel_create_fd_pair_watch(ioc, 337 cioc->readfd, 338 cioc->writefd, 339 condition); 340 } 341 342 343 static void qio_channel_command_class_init(ObjectClass *klass, 344 void *class_data G_GNUC_UNUSED) 345 { 346 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass); 347 348 ioc_klass->io_writev = qio_channel_command_writev; 349 ioc_klass->io_readv = qio_channel_command_readv; 350 ioc_klass->io_set_blocking = qio_channel_command_set_blocking; 351 ioc_klass->io_close = qio_channel_command_close; 352 ioc_klass->io_create_watch = qio_channel_command_create_watch; 353 } 354 355 static const TypeInfo qio_channel_command_info = { 356 .parent = TYPE_QIO_CHANNEL, 357 .name = TYPE_QIO_CHANNEL_COMMAND, 358 .instance_size = sizeof(QIOChannelCommand), 359 .instance_init = qio_channel_command_init, 360 .instance_finalize = qio_channel_command_finalize, 361 .class_init = qio_channel_command_class_init, 362 }; 363 364 static void qio_channel_command_register_types(void) 365 { 366 type_register_static(&qio_channel_command_info); 367 } 368 369 type_init(qio_channel_command_register_types); 370