Archipelago » qemu

#include <stdlib.h>

#include <stdio.h>

#include <stdbool.h>

#include <glib.h>

#include <windows.h>

#include <errno.h>

#include <io.h>

#include "qga/guest-agent-core.h"

#include "qga/channel.h"

typedef struct GAChannelReadState {

    guint thread_id;

    uint8_t *buf;

    size_t buf_size;

    size_t cur; /* current buffer start */

    size_t pending; /* pending buffered bytes to read */

    OVERLAPPED ov;

    bool ov_pending; /* whether on async read is outstanding */

} GAChannelReadState;

struct GAChannel {

    HANDLE handle;

    GAChannelCallback cb;

    gpointer user_data;

    GAChannelReadState rstate;

    GIOCondition pending_events; /* TODO: use GAWatch.pollfd.revents */

    GSource *source;

};

typedef struct GAWatch {

    GSource source;

    GPollFD pollfd;

    GAChannel *channel;

    GIOCondition events_mask;

} GAWatch;

/*

 * Called by glib prior to polling to set up poll events if polling is needed.

 *

 */

static gboolean ga_channel_prepare(GSource *source, gint *timeout_ms)

{

    GAWatch *watch = (GAWatch *)source;

    GAChannel *c = (GAChannel *)watch->channel;

    GAChannelReadState *rs = &c->rstate;

    DWORD count_read, count_to_read = 0;

    bool success;

    GIOCondition new_events = 0;

    g_debug("prepare");

    /* go ahead and submit another read if there's room in the buffer

     * and no previous reads are outstanding

     */

    if (!rs->ov_pending) {

        if (rs->cur + rs->pending >= rs->buf_size) {

            if (rs->cur) {

                memmove(rs->buf, rs->buf + rs->cur, rs->pending);

                rs->cur = 0;

            }

        }

        count_to_read = rs->buf_size - rs->cur - rs->pending;

    }

    if (rs->ov_pending || count_to_read <= 0) {

            goto out;

    }

    /* submit the read */

    success = ReadFile(c->handle, rs->buf + rs->cur + rs->pending,

                       count_to_read, &count_read, &rs->ov);

    if (success) {

        rs->pending += count_read;

        rs->ov_pending = false;

    } else {

        if (GetLastError() == ERROR_IO_PENDING) {

            rs->ov_pending = true;

        } else {

            new_events |= G_IO_ERR;

        }

    }

out:

    /* dont block forever, iterate the main loop every once and a while */

    *timeout_ms = 500;

    /* if there's data in the read buffer, or another event is pending,

     * skip polling and issue user cb.

     */

    if (rs->pending) {

        new_events |= G_IO_IN;

    }

    c->pending_events |= new_events;

    return !!c->pending_events;

}

/*

 * Called by glib after an outstanding read request is completed.

 */

static gboolean ga_channel_check(GSource *source)

{

    GAWatch *watch = (GAWatch *)source;

    GAChannel *c = (GAChannel *)watch->channel;

    GAChannelReadState *rs = &c->rstate;

    DWORD count_read, error;

    BOOL success;

    GIOCondition new_events = 0;

    g_debug("check");

    /* failing this implies we issued a read that completed immediately,

     * yet no data was placed into the buffer (and thus we did not skip

     * polling). but since EOF is not obtainable until we retrieve an

     * overlapped result, it must be the case that there was data placed

     * into the buffer, or an error was generated by Readfile(). in either

     * case, we should've skipped the polling for this round.

     */

    g_assert(rs->ov_pending);

    success = GetOverlappedResult(c->handle, &rs->ov, &count_read, FALSE);

    if (success) {

        g_debug("thread: overlapped result, count_read: %d", (int)count_read);

        rs->pending += count_read;

        new_events |= G_IO_IN;

    } else {

        error = GetLastError();

        if (error == 0 || error == ERROR_HANDLE_EOF ||

            error == ERROR_NO_SYSTEM_RESOURCES ||

            error == ERROR_OPERATION_ABORTED) {

            /* note: On WinXP SP3 with rhel6ga virtio-win-1.1.16 vioser drivers,

             * ENSR seems to be synonymous with when we'd normally expect

             * ERROR_HANDLE_EOF. So treat it as such. Microsoft's

             * recommendation for ERROR_NO_SYSTEM_RESOURCES is to

             * retry the read, so this happens to work out anyway. On newer

             * virtio-win driver, this seems to be replaced with EOA, so

             * handle that in the same fashion.

             */

            new_events |= G_IO_HUP;

        } else if (error != ERROR_IO_INCOMPLETE) {

            g_critical("error retrieving overlapped result: %d", (int)error);

            new_events |= G_IO_ERR;

        }

    }

    if (new_events) {

        rs->ov_pending = 0;

    }

    c->pending_events |= new_events;

    return !!c->pending_events;

}

/*

 * Called by glib after either prepare or check routines signal readiness

 */

static gboolean ga_channel_dispatch(GSource *source, GSourceFunc unused,

                                    gpointer user_data)

{

    GAWatch *watch = (GAWatch *)source;

    GAChannel *c = (GAChannel *)watch->channel;

    GAChannelReadState *rs = &c->rstate;

    gboolean success;

    g_debug("dispatch");

    success = c->cb(watch->pollfd.revents, c->user_data);

    if (c->pending_events & G_IO_ERR) {

        g_critical("channel error, removing source");

        return false;

    }

    /* TODO: replace rs->pending with watch->revents */

    c->pending_events &= ~G_IO_HUP;

    if (!rs->pending) {

        c->pending_events &= ~G_IO_IN;

    } else {

        c->pending_events = 0;

    }

    return success;

}

static void ga_channel_finalize(GSource *source)

{

    g_debug("finalize");

}

GSourceFuncs ga_channel_watch_funcs = {

    ga_channel_prepare,

    ga_channel_check,

    ga_channel_dispatch,

    ga_channel_finalize

};

static GSource *ga_channel_create_watch(GAChannel *c)

{

    GSource *source = g_source_new(&ga_channel_watch_funcs, sizeof(GAWatch));

    GAWatch *watch = (GAWatch *)source;

    watch->channel = c;

    watch->pollfd.fd = (gintptr) c->rstate.ov.hEvent;

    g_source_add_poll(source, &watch->pollfd);

    return source;

}

GIOStatus ga_channel_read(GAChannel *c, char *buf, size_t size, gsize *count)

{

    GAChannelReadState *rs = &c->rstate;

    GIOStatus status;

    size_t to_read = 0;

    if (c->pending_events & G_IO_ERR) {

        return G_IO_STATUS_ERROR;

    }

    *count = to_read = MIN(size, rs->pending);

    if (to_read) {

        memcpy(buf, rs->buf + rs->cur, to_read);

        rs->cur += to_read;

        rs->pending -= to_read;

        status = G_IO_STATUS_NORMAL;

    } else {

        status = G_IO_STATUS_AGAIN;

    }

    return status;

}

static GIOStatus ga_channel_write(GAChannel *c, const char *buf, size_t size,

                                  size_t *count)

{

    GIOStatus status;

    OVERLAPPED ov = {0};

    BOOL ret;

    DWORD written;

    ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    ret = WriteFile(c->handle, buf, size, &written, &ov);

    if (!ret) {

        if (GetLastError() == ERROR_IO_PENDING) {

            /* write is pending */

            ret = GetOverlappedResult(c->handle, &ov, &written, TRUE);

            if (!ret) {

                if (!GetLastError()) {

                    status = G_IO_STATUS_AGAIN;

                } else {

                    status = G_IO_STATUS_ERROR;

                }

            } else {

                /* write is complete */

                status = G_IO_STATUS_NORMAL;

                *count = written;

            }

        } else {

            status = G_IO_STATUS_ERROR;

        }

    } else {

        /* write returned immediately */

        status = G_IO_STATUS_NORMAL;

        *count = written;

    }

    if (ov.hEvent) {

        CloseHandle(ov.hEvent);

        ov.hEvent = NULL;

    }

    return status;

}

GIOStatus ga_channel_write_all(GAChannel *c, const char *buf, size_t size)

{

    GIOStatus status = G_IO_STATUS_NORMAL;;

    size_t count;

    while (size) {

        status = ga_channel_write(c, buf, size, &count);

        if (status == G_IO_STATUS_NORMAL) {

            size -= count;

            buf += count;

        } else if (status != G_IO_STATUS_AGAIN) {

            break;

        }

    }

    return status;

}

static gboolean ga_channel_open(GAChannel *c, GAChannelMethod method,

                                const gchar *path)

{

    if (!method == GA_CHANNEL_VIRTIO_SERIAL) {

        g_critical("unsupported communication method");

        return false;

    }

    c->handle = CreateFile(path, GENERIC_READ | GENERIC_WRITE, 0, NULL,

                           OPEN_EXISTING,

                           FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);

    if (c->handle == INVALID_HANDLE_VALUE) {

        g_critical("error opening path");

        return false;

    }

    return true;

}

GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,

                          GAChannelCallback cb, gpointer opaque)

{

    GAChannel *c = g_malloc0(sizeof(GAChannel));

    SECURITY_ATTRIBUTES sec_attrs;

    if (!ga_channel_open(c, method, path)) {

        g_critical("error opening channel");

        g_free(c);

        return NULL;

    }

    c->cb = cb;

    c->user_data = opaque;

    sec_attrs.nLength = sizeof(SECURITY_ATTRIBUTES);

    sec_attrs.lpSecurityDescriptor = NULL;

    sec_attrs.bInheritHandle = false;

    c->rstate.buf_size = QGA_READ_COUNT_DEFAULT;

    c->rstate.buf = g_malloc(QGA_READ_COUNT_DEFAULT);

    c->rstate.ov.hEvent = CreateEvent(&sec_attrs, FALSE, FALSE, NULL);

    c->source = ga_channel_create_watch(c);

    g_source_attach(c->source, NULL);

    return c;

}

void ga_channel_free(GAChannel *c)

{

    if (c->source) {

        g_source_destroy(c->source);

    }

    if (c->rstate.ov.hEvent) {

        CloseHandle(c->rstate.ov.hEvent);

    }

    g_free(c->rstate.buf);

    g_free(c);

}