1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* This file implements the 'tcp:' goldfish pipe type which allows 18 * guest clients to directly connect to a TCP port through /dev/qemu_pipe. 19 */ 20 21 #include "android/sockets.h" 22 #include "android/utils/assert.h" 23 #include "android/utils/panic.h" 24 #include "android/utils/system.h" 25 #include "android/async-utils.h" 26 #include "android/opengles.h" 27 #include "android/looper.h" 28 #include "hw/android/goldfish/pipe.h" 29 30 /* Implement the OpenGL fast-pipe */ 31 32 /* Set to 1 or 2 for debug traces */ 33 // #define DEBUG 1 34 35 #if DEBUG >= 1 36 # define D(...) printf(__VA_ARGS__), printf("\n") 37 #else 38 # define D(...) ((void)0) 39 #endif 40 41 #if DEBUG >= 2 42 # define DD(...) printf(__VA_ARGS__), printf("\n") 43 # define DDASSERT(cond) _ANDROID_ASSERT(cond, "Assertion failure: ", #cond) 44 # define DDASSERT_INT_OP(cond,val,op) _ANDROID_ASSERT_INT_OP(cond,val,op) 45 #else 46 # define DD(...) ((void)0) 47 # define DDASSERT(cond) ((void)0) 48 # define DDASSERT_INT_OP(cond,val,op) ((void)0) 49 #endif 50 51 #define DDASSERT_INT_LT(cond,val) DDASSERT_INT_OP(cond,val,<) 52 #define DDASSERT_INT_LTE(cond,val) DDASSERT_INT_OP(cond,val,<=) 53 #define DDASSERT_INT_GT(cond,val) DDASSERT_INT_OP(cond,val,>) 54 #define DDASSERT_INT_GTE(cond,val) DDASSERT_INT_OP(cond,val,>=) 55 #define DDASSERT_INT_EQ(cond,val) DDASSERT_INT_OP(cond,val,==) 56 #define DDASSERT_INT_NEQ(cond,val) DDASSERT_INT_OP(cond,val,!=) 57 58 enum { 59 STATE_INIT, 60 STATE_CONNECTING, 61 STATE_CONNECTED, 62 STATE_CLOSING_GUEST, 63 STATE_CLOSING_SOCKET 64 }; 65 66 typedef struct { 67 void* hwpipe; 68 int state; 69 int wakeWanted; 70 LoopIo io[1]; 71 AsyncConnector connector[1]; 72 } NetPipe; 73 74 static void 75 netPipe_free( NetPipe* pipe ) 76 { 77 int fd; 78 79 /* Close the socket */ 80 fd = pipe->io->fd; 81 loopIo_done(pipe->io); 82 socket_close(fd); 83 84 /* Release the pipe object */ 85 AFREE(pipe); 86 } 87 88 89 static void 90 netPipe_resetState( NetPipe* pipe ) 91 { 92 if ((pipe->wakeWanted & PIPE_WAKE_WRITE) != 0) { 93 loopIo_wantWrite(pipe->io); 94 } else { 95 loopIo_dontWantWrite(pipe->io); 96 } 97 98 if (pipe->state == STATE_CONNECTED && (pipe->wakeWanted & PIPE_WAKE_READ) != 0) { 99 loopIo_wantRead(pipe->io); 100 } else { 101 loopIo_dontWantRead(pipe->io); 102 } 103 } 104 105 106 /* This function is only called when the socket is disconnected. 107 * See netPipe_closeFromGuest() for the case when the guest requires 108 * the disconnection. */ 109 static void 110 netPipe_closeFromSocket( void* opaque ) 111 { 112 NetPipe* pipe = opaque; 113 114 D("%s", __FUNCTION__); 115 116 /* If the guest already ordered the pipe to be closed, delete immediately */ 117 if (pipe->state == STATE_CLOSING_GUEST) { 118 netPipe_free(pipe); 119 return; 120 } 121 122 /* Force the closure of the QEMUD channel - if a guest is blocked 123 * waiting for a wake signal, it will receive an error. */ 124 if (pipe->hwpipe != NULL) { 125 goldfish_pipe_close(pipe->hwpipe); 126 pipe->hwpipe = NULL; 127 } 128 129 pipe->state = STATE_CLOSING_SOCKET; 130 netPipe_resetState(pipe); 131 } 132 133 134 /* This is the function that gets called each time there is an asynchronous 135 * event on the network pipe. 136 */ 137 static void 138 netPipe_io_func( void* opaque, int fd, unsigned events ) 139 { 140 NetPipe* pipe = opaque; 141 int wakeFlags = 0; 142 143 /* Run the connector if we are in the CONNECTING state */ 144 /* TODO: Add some sort of time-out, to deal with the case */ 145 /* when the server is wedged. */ 146 if (pipe->state == STATE_CONNECTING) { 147 AsyncStatus status = asyncConnector_run(pipe->connector); 148 if (status == ASYNC_NEED_MORE) { 149 return; 150 } 151 else if (status == ASYNC_ERROR) { 152 /* Could not connect, tell our client by closing the channel. */ 153 154 netPipe_closeFromSocket(pipe); 155 return; 156 } 157 pipe->state = STATE_CONNECTED; 158 netPipe_resetState(pipe); 159 return; 160 } 161 162 /* Otherwise, accept incoming data */ 163 if ((events & LOOP_IO_READ) != 0) { 164 if ((pipe->wakeWanted & PIPE_WAKE_READ) != 0) { 165 wakeFlags |= PIPE_WAKE_READ; 166 } 167 } 168 169 if ((events & LOOP_IO_WRITE) != 0) { 170 if ((pipe->wakeWanted & PIPE_WAKE_WRITE) != 0) { 171 wakeFlags |= PIPE_WAKE_WRITE; 172 } 173 } 174 175 /* Send wake signal to the guest if needed */ 176 if (wakeFlags != 0) { 177 goldfish_pipe_wake(pipe->hwpipe, wakeFlags); 178 pipe->wakeWanted &= ~wakeFlags; 179 } 180 181 /* Reset state */ 182 netPipe_resetState(pipe); 183 } 184 185 186 void* 187 netPipe_initFromAddress( void* hwpipe, const SockAddress* address, Looper* looper ) 188 { 189 NetPipe* pipe; 190 191 ANEW0(pipe); 192 193 pipe->hwpipe = hwpipe; 194 pipe->state = STATE_INIT; 195 196 { 197 AsyncStatus status; 198 199 int fd = socket_create( sock_address_get_family(address), SOCKET_STREAM ); 200 if (fd < 0) { 201 D("%s: Could create socket from address family!", __FUNCTION__); 202 netPipe_free(pipe); 203 return NULL; 204 } 205 206 loopIo_init(pipe->io, looper, fd, netPipe_io_func, pipe); 207 status = asyncConnector_init(pipe->connector, address, pipe->io); 208 pipe->state = STATE_CONNECTING; 209 210 if (status == ASYNC_ERROR) { 211 D("%s: Could not connect to socket: %s", 212 __FUNCTION__, errno_str); 213 netPipe_free(pipe); 214 return NULL; 215 } 216 if (status == ASYNC_COMPLETE) { 217 pipe->state = STATE_CONNECTED; 218 netPipe_resetState(pipe); 219 } 220 } 221 222 return pipe; 223 } 224 225 226 /* Called when the guest wants to close the channel. This is different 227 * from netPipe_closeFromSocket() which is called when the socket is 228 * disconnected. */ 229 static void 230 netPipe_closeFromGuest( void* opaque ) 231 { 232 NetPipe* pipe = opaque; 233 netPipe_free(pipe); 234 } 235 236 static int netPipeReadySend(NetPipe *pipe) 237 { 238 if (pipe->state == STATE_CONNECTED) 239 return 0; 240 else if (pipe->state == STATE_CONNECTING) 241 return PIPE_ERROR_AGAIN; 242 else if (pipe->hwpipe == NULL) 243 return PIPE_ERROR_INVAL; 244 else 245 return PIPE_ERROR_IO; 246 } 247 248 static int 249 netPipe_sendBuffers( void* opaque, const GoldfishPipeBuffer* buffers, int numBuffers ) 250 { 251 NetPipe* pipe = opaque; 252 int count = 0; 253 int ret = 0; 254 int buffStart = 0; 255 const GoldfishPipeBuffer* buff = buffers; 256 const GoldfishPipeBuffer* buffEnd = buff + numBuffers; 257 258 ret = netPipeReadySend(pipe); 259 if (ret != 0) 260 return ret; 261 262 for (; buff < buffEnd; buff++) 263 count += buff->size; 264 265 buff = buffers; 266 while (count > 0) { 267 int avail = buff->size - buffStart; 268 int len = socket_send(pipe->io->fd, buff->data + buffStart, avail); 269 270 /* the write succeeded */ 271 if (len > 0) { 272 buffStart += len; 273 if (buffStart >= buff->size) { 274 buff++; 275 buffStart = 0; 276 } 277 count -= len; 278 ret += len; 279 continue; 280 } 281 282 /* we reached the end of stream? */ 283 if (len == 0) { 284 if (ret == 0) 285 ret = PIPE_ERROR_IO; 286 break; 287 } 288 289 /* if we already wrote some stuff, simply return */ 290 if (ret > 0) { 291 break; 292 } 293 294 /* need to return an appropriate error code */ 295 if (errno == EAGAIN || errno == EWOULDBLOCK) { 296 ret = PIPE_ERROR_AGAIN; 297 } else { 298 ret = PIPE_ERROR_IO; 299 } 300 break; 301 } 302 303 return ret; 304 } 305 306 static int 307 netPipe_recvBuffers( void* opaque, GoldfishPipeBuffer* buffers, int numBuffers ) 308 { 309 NetPipe* pipe = opaque; 310 int count = 0; 311 int ret = 0; 312 int buffStart = 0; 313 GoldfishPipeBuffer* buff = buffers; 314 GoldfishPipeBuffer* buffEnd = buff + numBuffers; 315 316 for (; buff < buffEnd; buff++) 317 count += buff->size; 318 319 buff = buffers; 320 while (count > 0) { 321 int avail = buff->size - buffStart; 322 int len = socket_recv(pipe->io->fd, buff->data + buffStart, avail); 323 324 /* the read succeeded */ 325 if (len > 0) { 326 buffStart += len; 327 if (buffStart >= buff->size) { 328 buff++; 329 buffStart = 0; 330 } 331 count -= len; 332 ret += len; 333 continue; 334 } 335 336 /* we reached the end of stream? */ 337 if (len == 0) { 338 if (ret == 0) 339 ret = PIPE_ERROR_IO; 340 break; 341 } 342 343 /* if we already read some stuff, simply return */ 344 if (ret > 0) { 345 break; 346 } 347 348 /* need to return an appropriate error code */ 349 if (errno == EAGAIN || errno == EWOULDBLOCK) { 350 ret = PIPE_ERROR_AGAIN; 351 } else { 352 ret = PIPE_ERROR_IO; 353 } 354 break; 355 } 356 return ret; 357 } 358 359 static unsigned 360 netPipe_poll( void* opaque ) 361 { 362 NetPipe* pipe = opaque; 363 unsigned mask = loopIo_poll(pipe->io); 364 unsigned ret = 0; 365 366 if (mask & LOOP_IO_READ) 367 ret |= PIPE_POLL_IN; 368 if (mask & LOOP_IO_WRITE) 369 ret |= PIPE_POLL_OUT; 370 371 return ret; 372 } 373 374 static void 375 netPipe_wakeOn( void* opaque, int flags ) 376 { 377 NetPipe* pipe = opaque; 378 379 DD("%s: flags=%d", __FUNCTION__, flags); 380 381 pipe->wakeWanted |= flags; 382 netPipe_resetState(pipe); 383 } 384 385 386 void* 387 netPipe_initTcp( void* hwpipe, void* _looper, const char* args ) 388 { 389 /* Build SockAddress from arguments. Acceptable formats are: 390 * <port> 391 */ 392 SockAddress address; 393 uint16_t port; 394 void* ret; 395 396 if (args == NULL) { 397 D("%s: Missing address!", __FUNCTION__); 398 return NULL; 399 } 400 D("%s: Port is '%s'", __FUNCTION__, args); 401 402 /* Now, look at the port number */ 403 { 404 char* end; 405 long val = strtol(args, &end, 10); 406 if (end == NULL || *end != '\0' || val <= 0 || val > 65535) { 407 D("%s: Invalid port number: '%s'", __FUNCTION__, args); 408 } 409 port = (uint16_t)val; 410 } 411 sock_address_init_inet(&address, SOCK_ADDRESS_INET_LOOPBACK, port); 412 413 ret = netPipe_initFromAddress(hwpipe, &address, _looper); 414 415 sock_address_done(&address); 416 return ret; 417 } 418 419 #ifndef _WIN32 420 void* 421 netPipe_initUnix( void* hwpipe, void* _looper, const char* args ) 422 { 423 /* Build SockAddress from arguments. Acceptable formats are: 424 * 425 * <path> 426 */ 427 SockAddress address; 428 void* ret; 429 430 if (args == NULL || args[0] == '\0') { 431 D("%s: Missing address!", __FUNCTION__); 432 return NULL; 433 } 434 D("%s: Address is '%s'", __FUNCTION__, args); 435 436 sock_address_init_unix(&address, args); 437 438 ret = netPipe_initFromAddress(hwpipe, &address, _looper); 439 440 sock_address_done(&address); 441 return ret; 442 } 443 #endif 444 445 /********************************************************************** 446 ********************************************************************** 447 ***** 448 ***** N E T W O R K P I P E M E S S A G E S 449 ***** 450 *****/ 451 452 static const GoldfishPipeFuncs netPipeTcp_funcs = { 453 netPipe_initTcp, 454 netPipe_closeFromGuest, 455 netPipe_sendBuffers, 456 netPipe_recvBuffers, 457 netPipe_poll, 458 netPipe_wakeOn, 459 NULL, /* we can't save these */ 460 NULL, /* we can't load these */ 461 }; 462 463 #ifndef _WIN32 464 static const GoldfishPipeFuncs netPipeUnix_funcs = { 465 netPipe_initUnix, 466 netPipe_closeFromGuest, 467 netPipe_sendBuffers, 468 netPipe_recvBuffers, 469 netPipe_poll, 470 netPipe_wakeOn, 471 NULL, /* we can't save these */ 472 NULL, /* we can't load these */ 473 }; 474 #endif 475 476 /* This is set to 1 in android_init_opengles() below, and tested 477 * by openglesPipe_init() to refuse a pipe connection if the function 478 * was never called. 479 */ 480 static int _opengles_init; 481 482 static void* 483 openglesPipe_init( void* hwpipe, void* _looper, const char* args ) 484 { 485 NetPipe *pipe; 486 487 if (!_opengles_init) { 488 /* This should never happen, unless there is a bug in the 489 * emulator's initialization, or the system image. */ 490 D("Trying to open the OpenGLES pipe without GPU emulation!"); 491 return NULL; 492 } 493 494 char server_addr[PATH_MAX]; 495 android_gles_server_path(server_addr, sizeof(server_addr)); 496 #ifndef _WIN32 497 if (android_gles_fast_pipes) { 498 pipe = (NetPipe *)netPipe_initUnix(hwpipe, _looper, server_addr); 499 D("Creating Unix OpenGLES pipe for GPU emulation: %s", server_addr); 500 } else { 501 #else /* _WIN32 */ 502 { 503 #endif 504 /* Connect through TCP as a fallback */ 505 pipe = (NetPipe *)netPipe_initTcp(hwpipe, _looper, server_addr); 506 D("Creating TCP OpenGLES pipe for GPU emulation!"); 507 } 508 if (pipe != NULL) { 509 // Disable TCP nagle algorithm to improve throughput of small packets 510 socket_set_nodelay(pipe->io->fd); 511 512 // On Win32, adjust buffer sizes 513 #ifdef _WIN32 514 { 515 int sndbuf = 128 * 1024; 516 int len = sizeof(sndbuf); 517 if (setsockopt(pipe->io->fd, SOL_SOCKET, SO_SNDBUF, 518 (char*)&sndbuf, len) == SOCKET_ERROR) { 519 D("Failed to set SO_SNDBUF to %d error=0x%x\n", 520 sndbuf, WSAGetLastError()); 521 } 522 } 523 #endif /* _WIN32 */ 524 } 525 526 return pipe; 527 } 528 529 static const GoldfishPipeFuncs openglesPipe_funcs = { 530 openglesPipe_init, 531 netPipe_closeFromGuest, 532 netPipe_sendBuffers, 533 netPipe_recvBuffers, 534 netPipe_poll, 535 netPipe_wakeOn, 536 NULL, /* we can't save these */ 537 NULL, /* we can't load these */ 538 }; 539 540 void 541 android_net_pipes_init(void) 542 { 543 Looper* looper = looper_newCore(); 544 545 goldfish_pipe_add_type( "tcp", looper, &netPipeTcp_funcs ); 546 #ifndef _WIN32 547 goldfish_pipe_add_type( "unix", looper, &netPipeUnix_funcs ); 548 #endif 549 goldfish_pipe_add_type( "opengles", looper, &openglesPipe_funcs ); 550 } 551 552 int 553 android_init_opengles_pipes(void) 554 { 555 /* TODO: Check that we can load and initialize the host emulation 556 * libraries, and return -1 in case of error. 557 */ 558 _opengles_init = 1; 559 return 0; 560 } 561
