diff options
| -rw-r--r-- | Makefile.common | 1 | ||||
| -rw-r--r-- | android/hw-qemud-pipe-net.c | 788 |
2 files changed, 789 insertions, 0 deletions
diff --git a/Makefile.common b/Makefile.common index 09fa4a1..fb3118e 100644 --- a/Makefile.common +++ b/Makefile.common @@ -375,6 +375,7 @@ CORE_MISC_SOURCES = \ android/hw-control.c \ android/hw-sensors.c \ android/hw-qemud.c \ + android/hw-qemud-pipe-net.c \ android/looper-qemu.c \ android/qemu-setup.c \ android/snapshot.c \ diff --git a/android/hw-qemud-pipe-net.c b/android/hw-qemud-pipe-net.c new file mode 100644 index 0000000..874bc69 --- /dev/null +++ b/android/hw-qemud-pipe-net.c @@ -0,0 +1,788 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "sockets.h" +#include "android/utils/assert.h" +#include "android/utils/panic.h" +#include "android/utils/system.h" +#include "android/async-utils.h" +#include "android/looper.h" +#include "android/hw-qemud-pipe.h" +#include "hw/goldfish_pipe.h" + +/* Implement the OpenGL fast-pipe */ + +/* Set to 1 or 2 for debug traces */ +#define DEBUG 0 + +#if DEBUG >= 1 +# define D(...) printf(__VA_ARGS__), printf("\n") +#else +# define D(...) ((void)0) +#endif + +#if DEBUG >= 2 +# define DD(...) printf(__VA_ARGS__), printf("\n") +# define DDASSERT(cond) _ANDROID_ASSERT(cond, "Assertion failure: ", #cond) +# define DDASSERT_INT_OP(cond,val,op) _ANDROID_ASSERT_INT_OP(cond,val,op) +#else +# define DD(...) ((void)0) +# define DDASSERT(cond) ((void)0) +# define DDASSERT_INT_OP(cond,val,op) ((void)0) +#endif + +#define DDASSERT_INT_LT(cond,val) DDASSERT_INT_OP(cond,val,<) +#define DDASSERT_INT_LTE(cond,val) DDASSERT_INT_OP(cond,val,<=) +#define DDASSERT_INT_GT(cond,val) DDASSERT_INT_OP(cond,val,>) +#define DDASSERT_INT_GTE(cond,val) DDASSERT_INT_OP(cond,val,>=) +#define DDASSERT_INT_EQ(cond,val) DDASSERT_INT_OP(cond,val,==) +#define DDASSERT_INT_NEQ(cond,val) DDASSERT_INT_OP(cond,val,!=) + + +/* Forward declarations */ + +typedef struct NetPipeInit { + Looper* looper; + SockAddress serverAddress[1]; +} NetPipeInit; + +/********************************************************************** + ********************************************************************** + ***** + ***** P I P E M E S S A G E S + ***** + *****/ + +typedef struct PipeMsg { + struct PipeMsg* next; + size_t size; + uint8_t data[1]; +} PipeMsg; + +static PipeMsg* +pipeMsg_alloc( size_t size ) +{ + PipeMsg* msg = android_alloc(sizeof(*msg) + size); + + msg->next = NULL; + msg->size = size; + return msg; +} + +static void +pipeMsg_free( PipeMsg* msg ) +{ + AFREE(msg); +} + +/********************************************************************** + ********************************************************************** + ***** + ***** M E S S A G E L I S T + ***** + *****/ + +typedef struct { + PipeMsg* firstMsg; /* first message in list */ + PipeMsg* lastMsg; /* last message in list */ + size_t firstBytes; /* bytes in firstMsg that were already sent */ + size_t lastBytes; /* bytes in lastMsg that were already received */ + size_t totalBytes; /* total bytes in list */ +} MsgList; + +/* Default receiver buffer size to accept incoming data */ +#define DEFAULT_RECEIVER_SIZE 8180 + +/* Initialize a message list - appropriate for sending them out */ +static void +msgList_initSend( MsgList* list ) +{ + list->firstMsg = NULL; + list->lastMsg = NULL; + list->firstBytes = 0; + list->lastBytes = 0; + list->totalBytes = 0; +} + +/* Initialize a message list for receiving data */ +static void +msgList_initReceive( MsgList* list ) +{ + msgList_initSend(list); + list->firstMsg = list->lastMsg = pipeMsg_alloc( DEFAULT_RECEIVER_SIZE ); +} + +/* Finalize a message list */ +static void +msgList_done( MsgList* list ) +{ + PipeMsg* msg; + + while ((msg = list->firstMsg) != NULL) { + list->firstMsg = msg->next; + pipeMsg_free(msg); + } + list->lastMsg = NULL; + + list->firstBytes = 0; + list->lastBytes = 0; + list->totalBytes = 0; +} + +static int +msgList_hasData( MsgList* list ) +{ + return list->totalBytes > 0; +} + +/* Append a list of buffers to a message list. + * + * This is a very simple implementation that simply mallocs a single + * new message containing all of the buffer's data, and append it to + * our link list. This also makes the implementation of msgList_send() + * quite simple, since there is no need to deal with the 'lastBytes' + * pointer (it is always assumed to be 'lastMsg->size'). + */ +static int +msgList_sendBuffers( MsgList* list, + const GoldfishPipeBuffer* buffers, + int numBuffers ) +{ + const GoldfishPipeBuffer* buff = buffers; + const GoldfishPipeBuffer* buffEnd = buff + numBuffers; + PipeMsg* msg; + size_t msgSize = 0; + size_t pos; + + /* Count the total number of bytes */ + for ( ; buff < buffEnd; buff++ ) { + msgSize += buff[0].size; + } + + /* Allocate a new message */ + msg = pipeMsg_alloc(msgSize); + if (msg == NULL) { + errno = ENOMEM; + return -1; + } + + /* Copy data from buffers to message */ + for ( pos = 0, buff = buffers; buff < buffEnd; buff++ ) { + memcpy(msg->data + pos, buff->data, buff->size); + pos += buff->size; + } + + /* Append message to current list */ + if (list->lastMsg != NULL) { + list->lastMsg->next = msg; + } else { + list->firstMsg = msg; + list->firstBytes = 0; + } + list->lastMsg = msg; + + list->totalBytes += msgSize; + + /* We are done */ + return 0; +} + +/* Try to send outgoing messages in the list through non-blocking socket 'fd'. + * Return 0 on success, and -1 on failure, where errno will be: + * + * ECONNRESET - connection reset by peer + * + * Note that 0 will be returned if socket_send() returns EAGAIN/EWOULDBLOCK. + */ +static int +msgList_send( MsgList* list, int fd ) +{ + int ret = 0; + + for (;;) { + PipeMsg* msg = list->firstMsg; + size_t sentBytes = list->firstBytes; + size_t availBytes; + + if (msg == NULL) { + /* We sent everything */ + return 0; + } + DDASSERT(sentBytes < msg->size); + availBytes = msg->size - sentBytes; + + ret = socket_send(fd, msg->data + sentBytes, availBytes); + if (ret <= 0) { + goto ERROR; + } + + list->totalBytes -= ret; + list->firstBytes += ret; + + if (list->firstBytes < msg->size) { + continue; + } + + /* We sent the full first packet - remove it from the head */ + list->firstBytes = 0; + list->firstMsg = msg->next; + if (list->firstMsg == NULL) { + list->lastMsg = NULL; + } + pipeMsg_free(msg); + } + +ERROR: + if (ret < 0) { /* EAGAIN/EWOULDBLOCK or disconnection */ + if (errno == EAGAIN || errno == EWOULDBLOCK) { + ret = 0; /* clear error - this is normal */ + } else { + DD("%s: socket_send() returned %d: %s\n", __FUNCTION__, errno, errno_str); + errno = ECONNRESET; + } + } else { +#if DEBUG >= 2 + int err = socket_get_error(fd); + DD("%s: socket_send() returned 0 (error=%d: %s)", __FUNCTION__, + err, strerror(err)); +#endif + errno = ECONNRESET; + ret = -1; + } + return ret; +} + + +/* Try to receive data into caller-provided buffers, and return the total + * size of bytes that were read. Returns -1 on error, with errno: + * + * ECONNRESET: Connection reset by peer + * EAGAIN: No incoming data, wait for it to arrive. + */ +static int +msgList_recvBuffers( MsgList* list, + GoldfishPipeBuffer* buffers, + int numBuffers ) +{ + GoldfishPipeBuffer* buff = buffers; + GoldfishPipeBuffer* buffEnd = buff + numBuffers; + size_t buffStart = 0; + PipeMsg* msg = list->firstMsg; + size_t msgStart = list->firstBytes; + size_t totalSize = 0; + + DDASSERT(msg != NULL); + + D("%s: ENTER list.firstBytes=%d list.lastBytes=%d list.totalBytes=%d list.firstSize=%d list.lastSize=%d list.firstEqualLast=%d", + __FUNCTION__, list->firstBytes, list->lastBytes, list->totalBytes, + list->firstMsg->size, list->lastMsg->size, list->firstMsg == list->lastMsg); + + /* If there is no incoming data, return EAGAIN */ + if (list->totalBytes == 0) { + errno = EAGAIN; + return -1; + } + + /* Now try to transfer as much from the list of incoming messages + * into the buffers. + */ + while (msg != NULL && buff < buffEnd) { + DDASSERT(msgStart < msg->size); + DDASSERT(buffStart < buff->size); + + /* Copy data from current message into next buffer. + * For a given message, first determine the start and end + * of available data. Then try to see how much of these + * we can copy to the current buffer. + */ + size_t msgEnd = msg->size; + + if (msg == list->lastMsg) { + msgEnd = list->lastBytes; + } + + size_t msgAvail = msgEnd - msgStart; + size_t buffAvail = buff->size - buffStart; + + if (msgAvail > buffAvail) { + msgAvail = buffAvail; + } + + DDASSERT(msgAvail > 0); + + D("%s: transfer %d bytes (msgStart=%d msgSize=%d buffStart=%d buffSize=%d)", + __FUNCTION__, msgAvail, msgStart, msg->size, buffStart, buff->size); + memcpy(buff->data + buffStart, msg->data + msgStart, msgAvail); + + /* Advance cursors */ + msgStart += msgAvail; + buffStart += msgAvail; + totalSize += msgAvail; + + /* Did we fill up the current buffer? */ + if (buffStart >= buff->size) { + buffStart = 0; + buff++; + } + + /* Did we empty the current message? */ + if (msgStart >= msgEnd) { + msgStart = 0; + /* If this is the last message, reset the 'first' and 'last' + * pointers to reuse it for the next recv(). */ + if (msg == list->lastMsg) { + list->lastBytes = 0; + msg = NULL; + } else { + /* Otherwise, delete the message, and jump to the next one */ + list->firstMsg = msg->next; + pipeMsg_free(msg); + msg = list->firstMsg; + } + } + + } + list->firstBytes = msgStart; + list->totalBytes -= totalSize; + + D("%s: EXIT list.firstBytes=%d list.lastBytes=%d list.totalBytes=%d list.firstSize=%d list.lastSize=%d list.firstEqualLast=%d", + __FUNCTION__, list->firstBytes, list->lastBytes, list->totalBytes, + list->firstMsg->size, list->lastMsg->size, list->firstMsg == list->lastMsg); + + return (int)totalSize; +} + + +/* Try to receive data from non-blocking socket 'fd'. + * Return 0 on success, or -1 on error, where errno can be: + * + * ECONNRESET - connection reset by peer + * ENOMEM - full message list, no room to receive more data + */ +static int +msgList_recv( MsgList* list, int fd ) +{ + int ret = 0; + + D("%s: ENTER list.firstBytes=%d list.lastBytes=%d list.totalBytes=%d list.firstSize=%d list.lastSize=%d list.firstEqualLast=%d", + __FUNCTION__, list->firstBytes, list->lastBytes, list->totalBytes, + list->firstMsg->size, list->lastMsg->size, list->firstMsg == list->lastMsg); + + for (;;) { + PipeMsg* last = list->lastMsg; + size_t lastBytes = list->lastBytes; + size_t availBytes; + + /* Compute how many bytes we can receive in the last buffer*/ + DDASSERT(last != NULL); + DDASSERT(last->size > 0); + DDASSERT(lastBytes < last->size); + + availBytes = last->size - lastBytes; + + /* Try to receive the data, act on errors */ + ret = socket_recv(fd, last->data + lastBytes, availBytes); + if (ret <= 0) { + goto ERROR; + } + + /* Acknowledge received data */ + list->lastBytes += ret; + list->totalBytes += ret; + + if (list->lastBytes < last->size) { + continue; + } + + /* We filled-up the last message buffer, allocate a new one */ + last = pipeMsg_alloc( DEFAULT_RECEIVER_SIZE ); + list->lastMsg->next = last; + list->lastMsg = last; + list->lastBytes = 0; + } + +ERROR: + if (ret < 0) { /* EAGAIN/EWOULDBLOCK or disconnection */ + if (errno == EAGAIN || errno == EWOULDBLOCK) { + ret = 0; /* clear error - this is normal */ + } else { + DD("%s: socket_send() returned %d: %s\n", __FUNCTION__, errno, errno_str); + errno = ECONNRESET; + } + } else /* ret == 0 */ { +#if DEBUG >= 2 + int err = socket_get_error(fd); + DD("%s: socket_send() returned 0 (error=%d: %s)", __FUNCTION__, + err, strerror(err)); +#endif + errno = ECONNRESET; + ret = -1; + } + D("%s: EXIT list.firstBytes=%d list.lastBytes=%d list.totalBytes=%d list.firstSize=%d list.lastSize=%d list.firstEqualLast=%d", + __FUNCTION__, list->firstBytes, list->lastBytes, list->totalBytes, + list->firstMsg->size, list->lastMsg->size, list->firstMsg == list->lastMsg); + + return ret; +} + + + +/********************************************************************** + ********************************************************************** + ***** + ***** P I P E H A N D L E R S + ***** + *****/ + +/* Technical Note: + * + * Each NetPipe object is connected to the following: + * + * - a remote rendering process through a normal TCP socket. + * - a Goldfish pipe (see hw/goldfish_pipe.h) to exchange messages with the guest. + * - a Qemud client (see android/hw-qemud.h) to signal state changes to the guest. + * + * REMOTE <---socket---> PIPE <------> GOLDFISH PIPE + * PROCESS <--+ + * | + * +---> QEMUD CHANNEL (android/hw-qemud.h) + * + */ +enum { + STATE_INIT, + STATE_CONNECTING, + STATE_CONNECTED, + STATE_CLOSING_GUEST, + STATE_CLOSING_SOCKET +}; + +#define DEFAULT_INCOMING_SIZE 4000 + +#define MAX_IN_BUFFERS 4 + +typedef struct { + QemudClient* client; + int state; + int wakeWanted; + + MsgList outList[1]; + MsgList inList[1]; + + LoopIo io[1]; + AsyncConnector connector[1]; + + GoldfishPipeBuffer outBuffer[1]; + GoldfishPipeBuffer inBuffers[MAX_IN_BUFFERS]; + int inBufferCount; + +} NetPipe; + +static void +netPipe_free( NetPipe* pipe ) +{ + int fd; + + /* Removing any pending incoming packet */ + msgList_done(pipe->outList); + msgList_done(pipe->inList); + + /* Close the socket */ + fd = pipe->io->fd; + loopIo_done(pipe->io); + socket_close(fd); + + /* Release the pipe object */ + AFREE(pipe); +} + + +static void +netPipe_resetState( NetPipe* pipe ) +{ + /* If there is a pending outgoing packet, open the valve */ + if (msgList_hasData(pipe->outList)) { + loopIo_wantWrite(pipe->io); + } else { + loopIo_dontWantWrite(pipe->io); + } + + /* Accept incoming data if we are not closing, and our input list isn't full */ + if (pipe->state == STATE_CONNECTED) { + loopIo_wantRead(pipe->io); + } else { + loopIo_dontWantRead(pipe->io); + } +} + + +/* This function is only called when the socket is disconnected. + * See netPipe_closeFromGuest() for the case when the guest requires + * the disconnection. */ +static void +netPipe_closeFromSocket( void* opaque ) +{ + NetPipe* pipe = opaque; + + /* If the guest already ordered the pipe to be closed, delete immediately */ + if (pipe->state == STATE_CLOSING_GUEST) { + netPipe_free(pipe); + return; + } + + /* Force the closure of the QEMUD channel - if a guest is blocked + * waiting for a wake signal, it will receive an error. */ + if (pipe->client != NULL) { + qemud_client_close(pipe->client); + pipe->client = NULL; + } + + /* Remove any outgoing packets - they won't go anywhere */ + msgList_done(pipe->outList); + + pipe->state = STATE_CLOSING_SOCKET; + netPipe_resetState(pipe); +} + + +/* This is the function that gets called each time there is an asynchronous + * event on the network pipe. + */ +static void +netPipe_io_func( void* opaque, int fd, unsigned events ) +{ + NetPipe* pipe = opaque; + int wakeFlags = 0; + + /* Run the connector if we are in the CONNECTING state */ + /* TODO: Add some sort of time-out, to deal with the case */ + /* where the renderer process is wedged. */ + if (pipe->state == STATE_CONNECTING) { + AsyncStatus status = asyncConnector_run(pipe->connector); + if (status == ASYNC_NEED_MORE) { + return; + } + else if (status == ASYNC_ERROR) { + /* Could not connect, tell our client by closing the channel. */ + + netPipe_closeFromSocket(pipe); + return; + } + pipe->state = STATE_CONNECTED; + netPipe_resetState(pipe); + return; + } + + /* Otherwise, accept incoming data */ + if ((events & LOOP_IO_READ) != 0) { + int ret; + + if ((pipe->wakeWanted & QEMUD_PIPE_WAKE_ON_RECV) != 0) { + wakeFlags |= QEMUD_PIPE_WAKE_ON_RECV; + } + + ret = msgList_recv(pipe->inList, fd); + if (ret < 0) { + wakeFlags &= ~QEMUD_PIPE_WAKE_ON_RECV; + + if (errno == ENOMEM) { /* shouldn't happen */ + DD("%s: msgList_recv() return ENOMEM!?\n", __FUNCTION__); + } else { + /* errno == ECONNRESET */ + DD("%s: msgList_recv() error, closing pipe\n", __FUNCTION__); + netPipe_closeFromSocket(pipe); + return; + } + } + } + + if ((events & LOOP_IO_WRITE) != 0) { + int ret; + + DDASSERT(msgList_hasData(pipe->outList)); + + ret = msgList_send(pipe->outList, fd); + if (ret < 0) { + DD("%s: msgList_send() error, closing pipe\n", __FUNCTION__); + netPipe_closeFromSocket(pipe); + return; + } + + if ((pipe->wakeWanted & QEMUD_PIPE_WAKE_ON_SEND) != 0) { + wakeFlags |= QEMUD_PIPE_WAKE_ON_SEND; + } + } + + /* Send wake signal to the guest if needed */ + if (wakeFlags != 0) { + uint8_t byte = (uint8_t) wakeFlags; + DD("%s: Sending wake flags %d (wanted=%d)", __FUNCTION__, byte, pipe->wakeWanted); + qemud_client_send(pipe->client, &byte, 1); + pipe->wakeWanted &= ~wakeFlags; + } + + /* Reset state */ + netPipe_resetState(pipe); +} + + +void* +netPipe_init( QemudClient* qcl, void* pipeOpaque ) +{ + NetPipe* pipe; + NetPipeInit* pipeSvc = pipeOpaque; + + ANEW0(pipe); + + pipe->client = qcl; + pipe->state = STATE_INIT; + + msgList_initSend(pipe->outList); + msgList_initReceive(pipe->inList); + +#define DEFAULT_OPENGLES_PORT 22468 + + { + AsyncStatus status; + + int fd = socket_create_inet( SOCKET_STREAM ); + if (fd < 0) { + netPipe_free(pipe); + return NULL; + } + + loopIo_init(pipe->io, pipeSvc->looper, fd, netPipe_io_func, pipe); + asyncConnector_init(pipe->connector, pipeSvc->serverAddress, pipe->io); + pipe->state = STATE_CONNECTING; + + status = asyncConnector_run(pipe->connector); + if (status == ASYNC_ERROR) { + D("%s: Could not create to renderer process: %s", + __FUNCTION__, errno_str); + netPipe_free(pipe); + return NULL; + } + if (status == ASYNC_COMPLETE) { + pipe->state = STATE_CONNECTED; + netPipe_resetState(pipe); + } + } + + return pipe; +} + +/* Called when the guest wants to close the channel. This is different + * from netPipe_closeFromSocket() which is called when the socket is + * disconnected. */ +static void +netPipe_closeFromGuest( void* opaque ) +{ + NetPipe* pipe = opaque; + + /* The qemud client is gone when we reach this code */ + pipe->client = NULL; + + /* Remove input messages */ + msgList_done(pipe->inList); + + /* If the socket is already closed, or if there are no + * outgoing messages, delete immediately */ + if (pipe->state == STATE_CLOSING_SOCKET || + !msgList_hasData(pipe->outList)) { + netPipe_free(pipe); + return; + } + + /* Otherwise, mark our pipe as closing, and wait until everything is + * sent before deleting the object. */ + pipe->state = STATE_CLOSING_GUEST; + netPipe_resetState(pipe); +} + + +static int +netPipe_sendBuffers( void* opaque, const GoldfishPipeBuffer* buffers, int numBuffers ) +{ + NetPipe* pipe = opaque; + int ret; + + ret = msgList_sendBuffers(pipe->outList, buffers, numBuffers); + netPipe_resetState(pipe); + return ret; +} + +static int +netPipe_recvBuffers( void* opaque, GoldfishPipeBuffer* buffers, int numBuffers ) +{ + NetPipe* pipe = opaque; + int ret; + + ret = msgList_recvBuffers(pipe->inList, buffers, numBuffers); + netPipe_resetState(pipe); + return ret; +} + +static void +netPipe_wakeOn( void* opaque, int flags ) +{ + NetPipe* pipe = opaque; + + pipe->wakeWanted |= flags; +} + +/********************************************************************** + ********************************************************************** + ***** + ***** N E T W O R K P I P E M E S S A G E S + ***** + *****/ + +static const QemudPipeHandlerFuncs net_pipe_handler_funcs = { + netPipe_init, + netPipe_closeFromGuest, + netPipe_sendBuffers, + netPipe_recvBuffers, + netPipe_wakeOn, +}; + + +static NetPipeInit _netPipeService[1]; + +/********************************************************************** + ********************************************************************** + ***** + ***** O P E N G L E S P I P E S E R V I C E + ***** + *****/ + +void +android_hw_opengles_init(void) +{ + NetPipeInit* svc = _netPipeService; + int ret; + + DD("%s: Registering service\n", __FUNCTION__); + + svc->looper = looper_newCore(); + + ret = sock_address_init_resolve(svc->serverAddress, + "127.0.0.1", + DEFAULT_OPENGLES_PORT, + 0); + if (ret < 0) { + APANIC("Could not resolve renderer process address!"); + } + + goldfish_pipe_add_type( "opengles", svc, &net_pipe_handler_funcs ); +} |