| /* |
| * QEMU System Emulator - managing I/O handler |
| * |
| * Copyright (c) 2003-2008 Fabrice Bellard |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| #include "config-host.h" |
| #include "qemu-common.h" |
| #include "qemu/queue.h" |
| #include "block/aio.h" |
| #include "qemu/main-loop.h" |
| |
| #ifndef _WIN32 |
| #include <sys/wait.h> |
| #endif |
| |
| typedef struct IOHandlerRecord { |
| IOCanReadHandler *fd_read_poll; |
| IOHandler *fd_read; |
| IOHandler *fd_write; |
| void *opaque; |
| QLIST_ENTRY(IOHandlerRecord) next; |
| int fd; |
| int pollfds_idx; |
| bool deleted; |
| } IOHandlerRecord; |
| |
| static QLIST_HEAD(, IOHandlerRecord) io_handlers = |
| QLIST_HEAD_INITIALIZER(io_handlers); |
| |
| |
| /* XXX: fd_read_poll should be suppressed, but an API change is |
| necessary in the character devices to suppress fd_can_read(). */ |
| int qemu_set_fd_handler2(int fd, |
| IOCanReadHandler *fd_read_poll, |
| IOHandler *fd_read, |
| IOHandler *fd_write, |
| void *opaque) |
| { |
| IOHandlerRecord *ioh; |
| |
| assert(fd >= 0); |
| |
| if (!fd_read && !fd_write) { |
| QLIST_FOREACH(ioh, &io_handlers, next) { |
| if (ioh->fd == fd) { |
| ioh->deleted = 1; |
| break; |
| } |
| } |
| } else { |
| QLIST_FOREACH(ioh, &io_handlers, next) { |
| if (ioh->fd == fd) |
| goto found; |
| } |
| ioh = g_malloc0(sizeof(IOHandlerRecord)); |
| QLIST_INSERT_HEAD(&io_handlers, ioh, next); |
| found: |
| ioh->fd = fd; |
| ioh->fd_read_poll = fd_read_poll; |
| ioh->fd_read = fd_read; |
| ioh->fd_write = fd_write; |
| ioh->opaque = opaque; |
| ioh->pollfds_idx = -1; |
| ioh->deleted = 0; |
| qemu_notify_event(); |
| } |
| return 0; |
| } |
| |
| int qemu_set_fd_handler(int fd, |
| IOHandler *fd_read, |
| IOHandler *fd_write, |
| void *opaque) |
| { |
| return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque); |
| } |
| |
| void qemu_iohandler_fill(GArray *pollfds) |
| { |
| IOHandlerRecord *ioh; |
| |
| QLIST_FOREACH(ioh, &io_handlers, next) { |
| int events = 0; |
| |
| if (ioh->deleted) |
| continue; |
| if (ioh->fd_read && |
| (!ioh->fd_read_poll || |
| ioh->fd_read_poll(ioh->opaque) != 0)) { |
| events |= G_IO_IN | G_IO_HUP | G_IO_ERR; |
| } |
| if (ioh->fd_write) { |
| events |= G_IO_OUT | G_IO_ERR; |
| } |
| if (events) { |
| GPollFD pfd = { |
| .fd = ioh->fd, |
| .events = events, |
| }; |
| ioh->pollfds_idx = pollfds->len; |
| g_array_append_val(pollfds, pfd); |
| } else { |
| ioh->pollfds_idx = -1; |
| } |
| } |
| } |
| |
| void qemu_iohandler_poll(GArray *pollfds, int ret) |
| { |
| if (ret > 0) { |
| IOHandlerRecord *pioh, *ioh; |
| |
| QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) { |
| int revents = 0; |
| |
| if (!ioh->deleted && ioh->pollfds_idx != -1) { |
| GPollFD *pfd = &g_array_index(pollfds, GPollFD, |
| ioh->pollfds_idx); |
| revents = pfd->revents; |
| } |
| |
| if (!ioh->deleted && ioh->fd_read && |
| (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) { |
| ioh->fd_read(ioh->opaque); |
| } |
| if (!ioh->deleted && ioh->fd_write && |
| (revents & (G_IO_OUT | G_IO_ERR))) { |
| ioh->fd_write(ioh->opaque); |
| } |
| |
| /* Do this last in case read/write handlers marked it for deletion */ |
| if (ioh->deleted) { |
| QLIST_REMOVE(ioh, next); |
| g_free(ioh); |
| } |
| } |
| } |
| } |
| |
| /* reaping of zombies. right now we're not passing the status to |
| anyone, but it would be possible to add a callback. */ |
| #ifndef _WIN32 |
| typedef struct ChildProcessRecord { |
| int pid; |
| QLIST_ENTRY(ChildProcessRecord) next; |
| } ChildProcessRecord; |
| |
| static QLIST_HEAD(, ChildProcessRecord) child_watches = |
| QLIST_HEAD_INITIALIZER(child_watches); |
| |
| static QEMUBH *sigchld_bh; |
| |
| static void sigchld_handler(int signal) |
| { |
| qemu_bh_schedule(sigchld_bh); |
| } |
| |
| static void sigchld_bh_handler(void *opaque) |
| { |
| ChildProcessRecord *rec, *next; |
| |
| QLIST_FOREACH_SAFE(rec, &child_watches, next, next) { |
| if (waitpid(rec->pid, NULL, WNOHANG) == rec->pid) { |
| QLIST_REMOVE(rec, next); |
| g_free(rec); |
| } |
| } |
| } |
| |
| static void qemu_init_child_watch(void) |
| { |
| struct sigaction act; |
| sigchld_bh = qemu_bh_new(sigchld_bh_handler, NULL); |
| |
| act.sa_handler = sigchld_handler; |
| act.sa_flags = SA_NOCLDSTOP; |
| sigaction(SIGCHLD, &act, NULL); |
| } |
| |
| int qemu_add_child_watch(pid_t pid) |
| { |
| ChildProcessRecord *rec; |
| |
| if (!sigchld_bh) { |
| qemu_init_child_watch(); |
| } |
| |
| QLIST_FOREACH(rec, &child_watches, next) { |
| if (rec->pid == pid) { |
| return 1; |
| } |
| } |
| rec = g_malloc0(sizeof(ChildProcessRecord)); |
| rec->pid = pid; |
| QLIST_INSERT_HEAD(&child_watches, rec, next); |
| return 0; |
| } |
| #endif |