1 /* 2 * QEMU monitor file descriptor passing 3 * 4 * Copyright (c) 2003-2004 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25 #include "qemu/osdep.h" 26 #include "monitor-internal.h" 27 #include "qapi/error.h" 28 #include "qapi/qapi-commands-misc.h" 29 #include "qapi/qmp/qerror.h" 30 #include "qemu/ctype.h" 31 #include "qemu/cutils.h" 32 #include "sysemu/runstate.h" 33 34 /* file descriptors passed via SCM_RIGHTS */ 35 typedef struct mon_fd_t mon_fd_t; 36 struct mon_fd_t { 37 char *name; 38 int fd; 39 QLIST_ENTRY(mon_fd_t) next; 40 }; 41 42 /* file descriptor associated with a file descriptor set */ 43 typedef struct MonFdsetFd MonFdsetFd; 44 struct MonFdsetFd { 45 int fd; 46 char *opaque; 47 QLIST_ENTRY(MonFdsetFd) next; 48 }; 49 50 /* file descriptor set containing fds passed via SCM_RIGHTS */ 51 typedef struct MonFdset MonFdset; 52 struct MonFdset { 53 int64_t id; 54 QLIST_HEAD(, MonFdsetFd) fds; 55 QLIST_HEAD(, MonFdsetFd) dup_fds; 56 QLIST_ENTRY(MonFdset) next; 57 }; 58 59 /* Protects mon_fdsets */ 60 static QemuMutex mon_fdsets_lock; 61 static QLIST_HEAD(, MonFdset) mon_fdsets; 62 63 static bool monitor_add_fd(Monitor *mon, int fd, const char *fdname, Error **errp) 64 { 65 mon_fd_t *monfd; 66 67 if (qemu_isdigit(fdname[0])) { 68 close(fd); 69 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname", 70 "a name not starting with a digit"); 71 return false; 72 } 73 74 /* See close() call below. */ 75 qemu_mutex_lock(&mon->mon_lock); 76 QLIST_FOREACH(monfd, &mon->fds, next) { 77 int tmp_fd; 78 79 if (strcmp(monfd->name, fdname) != 0) { 80 continue; 81 } 82 83 tmp_fd = monfd->fd; 84 monfd->fd = fd; 85 qemu_mutex_unlock(&mon->mon_lock); 86 /* Make sure close() is outside critical section */ 87 close(tmp_fd); 88 return true; 89 } 90 91 monfd = g_new0(mon_fd_t, 1); 92 monfd->name = g_strdup(fdname); 93 monfd->fd = fd; 94 95 QLIST_INSERT_HEAD(&mon->fds, monfd, next); 96 qemu_mutex_unlock(&mon->mon_lock); 97 return true; 98 } 99 100 #ifdef CONFIG_POSIX 101 void qmp_getfd(const char *fdname, Error **errp) 102 { 103 Monitor *cur_mon = monitor_cur(); 104 int fd; 105 106 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr); 107 if (fd == -1) { 108 error_setg(errp, "No file descriptor supplied via SCM_RIGHTS"); 109 return; 110 } 111 112 monitor_add_fd(cur_mon, fd, fdname, errp); 113 } 114 #endif 115 116 void qmp_closefd(const char *fdname, Error **errp) 117 { 118 Monitor *cur_mon = monitor_cur(); 119 mon_fd_t *monfd; 120 int tmp_fd; 121 122 qemu_mutex_lock(&cur_mon->mon_lock); 123 QLIST_FOREACH(monfd, &cur_mon->fds, next) { 124 if (strcmp(monfd->name, fdname) != 0) { 125 continue; 126 } 127 128 QLIST_REMOVE(monfd, next); 129 tmp_fd = monfd->fd; 130 g_free(monfd->name); 131 g_free(monfd); 132 qemu_mutex_unlock(&cur_mon->mon_lock); 133 /* Make sure close() is outside critical section */ 134 close(tmp_fd); 135 return; 136 } 137 138 qemu_mutex_unlock(&cur_mon->mon_lock); 139 error_setg(errp, "File descriptor named '%s' not found", fdname); 140 } 141 142 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp) 143 { 144 mon_fd_t *monfd; 145 146 QEMU_LOCK_GUARD(&mon->mon_lock); 147 QLIST_FOREACH(monfd, &mon->fds, next) { 148 int fd; 149 150 if (strcmp(monfd->name, fdname) != 0) { 151 continue; 152 } 153 154 fd = monfd->fd; 155 assert(fd >= 0); 156 157 /* caller takes ownership of fd */ 158 QLIST_REMOVE(monfd, next); 159 g_free(monfd->name); 160 g_free(monfd); 161 162 return fd; 163 } 164 165 error_setg(errp, "File descriptor named '%s' has not been found", fdname); 166 return -1; 167 } 168 169 static void monitor_fdset_free(MonFdset *mon_fdset) 170 { 171 QLIST_REMOVE(mon_fdset, next); 172 g_free(mon_fdset); 173 } 174 175 static void monitor_fdset_free_if_empty(MonFdset *mon_fdset) 176 { 177 /* 178 * Only remove an empty fdset. The fds are owned by the user and 179 * should have been removed with qmp_remove_fd(). The dup_fds are 180 * owned by QEMU and should have been removed with qemu_close(). 181 */ 182 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) { 183 monitor_fdset_free(mon_fdset); 184 } 185 } 186 187 static void monitor_fdset_fd_free(MonFdsetFd *mon_fdset_fd) 188 { 189 close(mon_fdset_fd->fd); 190 g_free(mon_fdset_fd->opaque); 191 QLIST_REMOVE(mon_fdset_fd, next); 192 g_free(mon_fdset_fd); 193 } 194 195 void monitor_fdsets_cleanup(void) 196 { 197 MonFdset *mon_fdset; 198 MonFdset *mon_fdset_next; 199 200 QEMU_LOCK_GUARD(&mon_fdsets_lock); 201 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) { 202 monitor_fdset_free_if_empty(mon_fdset); 203 } 204 } 205 206 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, 207 const char *opaque, Error **errp) 208 { 209 int fd; 210 Monitor *mon = monitor_cur(); 211 AddfdInfo *fdinfo; 212 213 fd = qemu_chr_fe_get_msgfd(&mon->chr); 214 if (fd == -1) { 215 error_setg(errp, "No file descriptor supplied via SCM_RIGHTS"); 216 goto error; 217 } 218 219 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id, opaque, errp); 220 if (fdinfo) { 221 return fdinfo; 222 } 223 224 error: 225 if (fd != -1) { 226 close(fd); 227 } 228 return NULL; 229 } 230 231 #ifdef WIN32 232 void qmp_get_win32_socket(const char *infos, const char *fdname, Error **errp) 233 { 234 g_autofree WSAPROTOCOL_INFOW *info = NULL; 235 gsize len; 236 SOCKET sk; 237 int fd; 238 239 info = (void *)g_base64_decode(infos, &len); 240 if (len != sizeof(*info)) { 241 error_setg(errp, "Invalid WSAPROTOCOL_INFOW value"); 242 return; 243 } 244 245 sk = WSASocketW(FROM_PROTOCOL_INFO, 246 FROM_PROTOCOL_INFO, 247 FROM_PROTOCOL_INFO, 248 info, 0, 0); 249 if (sk == INVALID_SOCKET) { 250 error_setg_win32(errp, WSAGetLastError(), "Couldn't import socket"); 251 return; 252 } 253 254 fd = _open_osfhandle(sk, _O_BINARY); 255 if (fd < 0) { 256 error_setg_errno(errp, errno, "Failed to associate a FD with the SOCKET"); 257 closesocket(sk); 258 return; 259 } 260 261 monitor_add_fd(monitor_cur(), fd, fdname, errp); 262 } 263 #endif 264 265 266 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp) 267 { 268 MonFdset *mon_fdset; 269 MonFdsetFd *mon_fdset_fd, *mon_fdset_fd_next; 270 char fd_str[60]; 271 272 QEMU_LOCK_GUARD(&mon_fdsets_lock); 273 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 274 if (mon_fdset->id != fdset_id) { 275 continue; 276 } 277 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, 278 mon_fdset_fd_next) { 279 if (has_fd) { 280 if (mon_fdset_fd->fd != fd) { 281 continue; 282 } 283 monitor_fdset_fd_free(mon_fdset_fd); 284 break; 285 } else { 286 monitor_fdset_fd_free(mon_fdset_fd); 287 } 288 } 289 if (has_fd && !mon_fdset_fd) { 290 goto error; 291 } 292 monitor_fdset_free_if_empty(mon_fdset); 293 return; 294 } 295 296 error: 297 if (has_fd) { 298 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64, 299 fdset_id, fd); 300 } else { 301 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id); 302 } 303 error_setg(errp, "File descriptor named '%s' not found", fd_str); 304 } 305 306 FdsetInfoList *qmp_query_fdsets(Error **errp) 307 { 308 MonFdset *mon_fdset; 309 MonFdsetFd *mon_fdset_fd; 310 FdsetInfoList *fdset_list = NULL; 311 312 QEMU_LOCK_GUARD(&mon_fdsets_lock); 313 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 314 FdsetInfo *fdset_info = g_malloc0(sizeof(*fdset_info)); 315 316 fdset_info->fdset_id = mon_fdset->id; 317 318 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) { 319 FdsetFdInfo *fdsetfd_info; 320 321 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info)); 322 fdsetfd_info->fd = mon_fdset_fd->fd; 323 fdsetfd_info->opaque = g_strdup(mon_fdset_fd->opaque); 324 325 QAPI_LIST_PREPEND(fdset_info->fds, fdsetfd_info); 326 } 327 328 QAPI_LIST_PREPEND(fdset_list, fdset_info); 329 } 330 331 return fdset_list; 332 } 333 334 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, 335 const char *opaque, Error **errp) 336 { 337 MonFdset *mon_fdset = NULL; 338 MonFdsetFd *mon_fdset_fd; 339 AddfdInfo *fdinfo; 340 341 QEMU_LOCK_GUARD(&mon_fdsets_lock); 342 if (has_fdset_id) { 343 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 344 /* Break if match found or match impossible due to ordering by ID */ 345 if (fdset_id <= mon_fdset->id) { 346 if (fdset_id < mon_fdset->id) { 347 mon_fdset = NULL; 348 } 349 break; 350 } 351 } 352 } 353 354 if (mon_fdset == NULL) { 355 int64_t fdset_id_prev = -1; 356 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets); 357 358 if (has_fdset_id) { 359 if (fdset_id < 0) { 360 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id", 361 "a non-negative value"); 362 return NULL; 363 } 364 /* Use specified fdset ID */ 365 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 366 mon_fdset_cur = mon_fdset; 367 if (fdset_id < mon_fdset_cur->id) { 368 break; 369 } 370 } 371 } else { 372 /* Use first available fdset ID */ 373 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 374 mon_fdset_cur = mon_fdset; 375 if (fdset_id_prev == mon_fdset_cur->id - 1) { 376 fdset_id_prev = mon_fdset_cur->id; 377 continue; 378 } 379 break; 380 } 381 } 382 383 mon_fdset = g_malloc0(sizeof(*mon_fdset)); 384 if (has_fdset_id) { 385 mon_fdset->id = fdset_id; 386 } else { 387 mon_fdset->id = fdset_id_prev + 1; 388 } 389 390 /* The fdset list is ordered by fdset ID */ 391 if (!mon_fdset_cur) { 392 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next); 393 } else if (mon_fdset->id < mon_fdset_cur->id) { 394 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next); 395 } else { 396 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next); 397 } 398 } 399 400 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd)); 401 mon_fdset_fd->fd = fd; 402 mon_fdset_fd->opaque = g_strdup(opaque); 403 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next); 404 405 fdinfo = g_malloc0(sizeof(*fdinfo)); 406 fdinfo->fdset_id = mon_fdset->id; 407 fdinfo->fd = mon_fdset_fd->fd; 408 409 return fdinfo; 410 } 411 412 int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags, Error **errp) 413 { 414 #ifdef _WIN32 415 error_setg(errp, "Platform does not support fd passing (fdset)"); 416 return -ENOENT; 417 #else 418 MonFdset *mon_fdset; 419 420 QEMU_LOCK_GUARD(&mon_fdsets_lock); 421 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 422 MonFdsetFd *mon_fdset_fd; 423 MonFdsetFd *mon_fdset_fd_dup; 424 int fd = -1; 425 int dup_fd; 426 int mon_fd_flags; 427 int mask = O_ACCMODE; 428 429 #ifdef O_DIRECT 430 mask |= O_DIRECT; 431 #endif 432 433 if (mon_fdset->id != fdset_id) { 434 continue; 435 } 436 437 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) { 438 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL); 439 if (mon_fd_flags == -1) { 440 error_setg(errp, "Failed to read file status flags for fd=%d", 441 mon_fdset_fd->fd); 442 return -1; 443 } 444 445 if ((flags & mask) == (mon_fd_flags & mask)) { 446 fd = mon_fdset_fd->fd; 447 break; 448 } 449 } 450 451 if (fd == -1) { 452 errno = EACCES; 453 error_setg(errp, 454 "Failed to find file descriptor with matching flags=0x%x", 455 flags); 456 return -1; 457 } 458 459 dup_fd = qemu_dup_flags(fd, flags); 460 if (dup_fd == -1) { 461 error_setg(errp, "Failed to dup() given file descriptor fd=%d", fd); 462 return -1; 463 } 464 465 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup)); 466 mon_fdset_fd_dup->fd = dup_fd; 467 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next); 468 return dup_fd; 469 } 470 471 error_setg(errp, "Failed to find fdset /dev/fdset/%" PRId64, fdset_id); 472 errno = ENOENT; 473 return -1; 474 #endif 475 } 476 477 void monitor_fdset_dup_fd_remove(int dup_fd) 478 { 479 MonFdset *mon_fdset; 480 MonFdsetFd *mon_fdset_fd_dup; 481 482 QEMU_LOCK_GUARD(&mon_fdsets_lock); 483 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { 484 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) { 485 if (mon_fdset_fd_dup->fd == dup_fd) { 486 QLIST_REMOVE(mon_fdset_fd_dup, next); 487 g_free(mon_fdset_fd_dup); 488 monitor_fdset_free_if_empty(mon_fdset); 489 return; 490 } 491 } 492 } 493 } 494 495 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp) 496 { 497 int fd; 498 499 if (!qemu_isdigit(fdname[0]) && mon) { 500 fd = monitor_get_fd(mon, fdname, errp); 501 } else { 502 fd = qemu_parse_fd(fdname); 503 if (fd < 0) { 504 error_setg(errp, "Invalid file descriptor number '%s'", 505 fdname); 506 } 507 } 508 509 return fd; 510 } 511 512 static void __attribute__((__constructor__)) monitor_fds_init(void) 513 { 514 qemu_mutex_init(&mon_fdsets_lock); 515 } 516