/*
* Allocate a new ThreadInfo structure, setup a connection to the
* server, allocate/init a packer context, bind this ThreadInfo to
* the calling thread with crSetTSD().
* We'll always call this function at least once even if we're not
* using threads.
*/
ThreadInfo *replicatespuNewThread( CRthread id )
{
ThreadInfo *thread;
#ifdef CHROMIUM_THREADSAFE_notyet
crLockMutex(&_ReplicateMutex);
#else
CRASSERT(replicate_spu.numThreads == 0);
#endif
CRASSERT(replicate_spu.numThreads < MAX_THREADS);
thread = &(replicate_spu.thread[replicate_spu.numThreads]);
thread->id = id;
thread->currentContext = NULL;
/* connect to the server */
thread->server.name = crStrdup( replicate_spu.name );
thread->server.buffer_size = replicate_spu.buffer_size;
if (replicate_spu.numThreads == 0) {
replicatespuConnectToServer( &(thread->server) );
CRASSERT(thread->server.conn);
replicate_spu.swap = thread->server.conn->swap;
}
else {
/* a new pthread */
replicatespuFlushAll( &(replicate_spu.thread[0]) );
crNetNewClient( replicate_spu.thread[0].server.conn, &(thread->server));
CRASSERT(thread->server.conn);
}
/* packer setup */
CRASSERT(thread->packer == NULL);
thread->packer = crPackNewContext( replicate_spu.swap );
CRASSERT(thread->packer);
crPackInitBuffer( &(thread->buffer), crNetAlloc(thread->server.conn),
thread->server.conn->buffer_size, thread->server.conn->mtu );
thread->buffer.canBarf = thread->server.conn->Barf ? GL_TRUE : GL_FALSE;
crPackSetBuffer( thread->packer, &thread->buffer );
crPackFlushFunc( thread->packer, replicatespuFlush );
crPackFlushArg( thread->packer, (void *) thread );
crPackSendHugeFunc( thread->packer, replicatespuHuge );
crPackSetContext( thread->packer );
#ifdef CHROMIUM_THREADSAFE_notyet
crSetTSD(&_ReplicateTSD, thread);
#endif
replicate_spu.numThreads++;
#ifdef CHROMIUM_THREADSAFE_notyet
crUnlockMutex(&_ReplicateMutex);
#endif
return thread;
}
void PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(void)
{
crLockMutex(&_PackMutex);
{
int i;
GET_THREAD(thread);
CRASSERT(!thread);
CRASSERT((pack_spu.numThreads>0) && (pack_spu.numThreads<MAX_THREADS));
for (i=0; i<MAX_THREADS; ++i)
{
if (!pack_spu.thread[i].inUse)
{
thread = &pack_spu.thread[i];
break;
}
}
CRASSERT(thread);
thread->inUse = GL_TRUE;
thread->id = crThreadID();
thread->currentContext = NULL;
thread->bInjectThread = GL_TRUE;
thread->netServer.name = crStrdup(pack_spu.name);
thread->netServer.buffer_size = 64 * 1024;
crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer));
CRASSERT(thread->netServer.conn);
CRASSERT(thread->packer == NULL);
thread->packer = crPackNewContext( pack_spu.swap );
CRASSERT(thread->packer);
crPackInitBuffer(&(thread->buffer), crNetAlloc(thread->netServer.conn),
thread->netServer.conn->buffer_size, thread->netServer.conn->mtu);
thread->buffer.canBarf = thread->netServer.conn->Barf ? GL_TRUE : GL_FALSE;
crPackSetBuffer( thread->packer, &thread->buffer );
crPackFlushFunc( thread->packer, packspuFlush );
crPackFlushArg( thread->packer, (void *) thread );
crPackSendHugeFunc( thread->packer, packspuHuge );
crPackSetContext( thread->packer );
crSetTSD(&_PackTSD, thread);
pack_spu.numThreads++;
}
crUnlockMutex(&_PackMutex);
}
GLint PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(struct VBOXUHGSMI *pHgsmi)
{
GLint con = 0;
int i;
GET_THREAD(thread);
CRASSERT(!thread);
crLockMutex(&_PackMutex);
{
CRASSERT(CRPACKSPU_IS_WDDM_CRHGSMI() || (pack_spu.numThreads>0));
CRASSERT(pack_spu.numThreads<MAX_THREADS);
for (i=0; i<MAX_THREADS; ++i)
{
if (!pack_spu.thread[i].inUse)
{
thread = &pack_spu.thread[i];
break;
}
}
CRASSERT(thread);
thread->inUse = GL_TRUE;
if (!CRPACKSPU_IS_WDDM_CRHGSMI())
thread->id = crThreadID();
else
thread->id = THREAD_OFFSET_MAGIC + i;
thread->currentContext = NULL;
thread->bInjectThread = GL_TRUE;
thread->netServer.name = crStrdup(pack_spu.name);
thread->netServer.buffer_size = 64 * 1024;
packspuConnectToServer(&(thread->netServer)
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, pHgsmi
#endif
);
CRASSERT(thread->netServer.conn);
CRASSERT(thread->packer == NULL);
thread->packer = crPackNewContext( pack_spu.swap );
CRASSERT(thread->packer);
crPackInitBuffer(&(thread->buffer), crNetAlloc(thread->netServer.conn),
thread->netServer.conn->buffer_size, thread->netServer.conn->mtu);
thread->buffer.canBarf = thread->netServer.conn->Barf ? GL_TRUE : GL_FALSE;
crPackSetBuffer( thread->packer, &thread->buffer );
crPackFlushFunc( thread->packer, packspuFlush );
crPackFlushArg( thread->packer, (void *) thread );
crPackSendHugeFunc( thread->packer, packspuHuge );
crPackSetContext( thread->packer );
crSetTSD(&_PackTSD, thread);
pack_spu.numThreads++;
}
crUnlockMutex(&_PackMutex);
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
CRASSERT(thread->id - THREAD_OFFSET_MAGIC < RT_ELEMENTS(pack_spu.thread)
&& GET_THREAD_VAL_ID(thread->id) == thread);
con = thread->id;
}
return con;
}
/*
* Allocate a new ThreadInfo structure, setup a connection to the
* server, allocate/init a packer context, bind this ThreadInfo to
* the calling thread with crSetTSD().
* We'll always call this function at least once even if we're not
* using threads.
*/
ThreadInfo *packspuNewThread( unsigned long id )
{
ThreadInfo *thread=NULL;
int i;
#ifdef CHROMIUM_THREADSAFE
crLockMutex(&_PackMutex);
#else
CRASSERT(pack_spu.numThreads == 0);
#endif
CRASSERT(pack_spu.numThreads < MAX_THREADS);
for (i=0; i<MAX_THREADS; ++i)
{
if (!pack_spu.thread[i].inUse)
{
thread = &pack_spu.thread[i];
break;
}
}
CRASSERT(thread);
thread->inUse = GL_TRUE;
thread->id = id;
thread->currentContext = NULL;
thread->bInjectThread = GL_FALSE;
/* connect to the server */
thread->netServer.name = crStrdup( pack_spu.name );
thread->netServer.buffer_size = pack_spu.buffer_size;
if (pack_spu.numThreads == 0) {
packspuConnectToServer( &(thread->netServer) );
if (!thread->netServer.conn) {
return NULL;
}
pack_spu.swap = thread->netServer.conn->swap;
}
else {
/* a new pthread */
crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer));
CRASSERT(thread->netServer.conn);
}
/* packer setup */
CRASSERT(thread->packer == NULL);
thread->packer = crPackNewContext( pack_spu.swap );
CRASSERT(thread->packer);
crPackInitBuffer( &(thread->buffer), crNetAlloc(thread->netServer.conn),
thread->netServer.conn->buffer_size, thread->netServer.conn->mtu );
thread->buffer.canBarf = thread->netServer.conn->Barf ? GL_TRUE : GL_FALSE;
crPackSetBuffer( thread->packer, &thread->buffer );
crPackFlushFunc( thread->packer, packspuFlush );
crPackFlushArg( thread->packer, (void *) thread );
crPackSendHugeFunc( thread->packer, packspuHuge );
crPackSetContext( thread->packer );
#ifdef CHROMIUM_THREADSAFE
crSetTSD(&_PackTSD, thread);
#endif
pack_spu.numThreads++;
#ifdef CHROMIUM_THREADSAFE
crUnlockMutex(&_PackMutex);
#endif
return thread;
}
/**
* This is the main routine responsible for replicating our GL state
* for a new VNC viewer. Called when we detect that a new VNC viewer
* has been started.
* \param ipaddress the IP address where the new viewer is running.
*/
void
replicatespuReplicate(int ipaddress)
{
GET_THREAD(thread);
struct in_addr addr;
char *hosturl;
char *ipstring;
int i, r_slot;
int serverPort;
crDebug("Replicate SPU: Enter replicatespuReplicate(ipaddress=0x%x)", ipaddress);
replicatespuFlushAll( (void *)thread );
#ifdef CHROMIUM_THREADSAFE_notyet
crLockMutex(&_ReplicateMutex);
#endif
/*
* Find empty slot.
* Slot 0 is the dummy slot (a non-existant server on devnull connection)
*/
for (r_slot = 1; r_slot < CR_MAX_REPLICANTS; r_slot++) {
if (!IS_CONNECTED(replicate_spu.rserver[r_slot].conn))
break;
}
if (r_slot == CR_MAX_REPLICANTS) {
crWarning("Replicate SPU: no more replicant slots available");
return;
}
/**
** OK, now rserver[r_slot] is free for use.
**/
/*
* At this time, we can only support one VNC viewer per host.
* Check for that here.
*/
for (i = 1; i < CR_MAX_REPLICANTS; i++) {
if (replicate_spu.ipnumbers[i] == ipaddress) {
CRConnection *conn = replicate_spu.rserver[i].conn;
/* If the connection appears to be active, it may actually be a dangling
* connection. Try flushing it now. If flushing fails, the connection
* type will definitely be CR_NO_CONNECTION (which we test below).
*/
if (conn) {
if (conn->type != CR_NO_CONNECTION) {
FlushConnection(i);
}
if (conn->type != CR_NO_CONNECTION) {
crWarning("Replicate SPU: Can't connect to multiple VNC viewers on one host.");
#if 0
/* The above test isn't 100% reliable and can prevent successful
* restart of a viewer on a host. For now, just print warning and
* continue.
*/
return;
#endif
}
}
}
}
replicate_spu.ipnumbers[r_slot] = ipaddress;
serverPort = replicate_spu.chromium_start_port + r_slot;
if (replicate_spu.vncAvailable) {
/* Send a ChromiumStart message to the VNC Server. The VNC Server will
* in turn send a ChromiumStart message to all the attached VNC viewers.
* The VNC Viewer/Chromium module will tell its crserver that there's
* a new OpenGL client.
* We pass the mothership port and crserver port in this message.
*/
char protocol[100], hostname[1000];
const char *mothershipURL;
unsigned short mothershipPort;
mothershipURL = crGetenv("CRMOTHERSHIP");
crDebug("Replicate SPU: CRMOTHERSHIP env var = %s", mothershipURL);
if (mothershipURL)
crParseURL(mothershipURL, protocol, hostname, &mothershipPort,
DEFAULT_MOTHERSHIP_PORT);
else
mothershipPort = DEFAULT_MOTHERSHIP_PORT;
crDebug("Replicate SPU: Sending ChromiumStart msg to VNC server, port=%d",
serverPort);
if (!XVncChromiumStart(replicate_spu.glx_display, ipaddress,
serverPort, mothershipPort)) {
crWarning("Replicate SPU: XVncChromiumStart() call failed");
}
}
addr.s_addr = ipaddress;
ipstring = inet_ntoa(addr);
hosturl = crAlloc(crStrlen(ipstring) + 9);
sprintf(hosturl, "tcpip://%s", ipstring);
crDebug("Replicate SPU attaching to %s on port %d", hosturl, serverPort);
/* connect to the remote VNC server */
replicate_spu.rserver[r_slot].name = crStrdup( replicate_spu.name );
replicate_spu.rserver[r_slot].buffer_size = replicate_spu.buffer_size;
replicate_spu.rserver[r_slot].conn
= crNetConnectToServer( hosturl, serverPort,
replicate_spu.rserver[r_slot].buffer_size, 1);
if (!replicate_spu.rserver[r_slot].conn) {
crWarning("Replicate SPU: failed to connect to %s", hosturl);
return;
}
CRASSERT(replicate_spu.rserver[r_slot].conn);
/*
* Setup the the packer flush function. While replicating state to
* a particular server we definitely don't want to do any broadcast
* flushing!
*/
crPackFlushFunc( thread->packer, replicatespuFlushOnePacker );
crPackSendHugeFunc( thread->packer, replicatespuHugeOnePacker );
NewServerIndex = r_slot;
/*
* Create server-side windows and contexts by walking tables of app windows
* and contexts. Note that windows can be created in random order,
* but contexts must be created in the order they were originally
* created, or shared contexts will break.
*/
crHashtableWalk(replicate_spu.windowTable, replicatespuReplicateWindow, thread);
crListApply(replicate_spu.contextList, replicatespuReplicateContext, thread);
/* MakeCurrent, the current context */
if (thread->currentContext) {
int serverWindow = thread->currentContext->currentWindow->id[r_slot];
int serverContext = thread->currentContext->rserverCtx[r_slot];
if (replicate_spu.swap)
crPackMakeCurrentSWAP(serverWindow, 0, serverContext);
else
crPackMakeCurrent(serverWindow, 0, serverContext);
crStateMakeCurrent( thread->currentContext->State );
}
/*
* Set window sizes
*/
crHashtableWalk(replicate_spu.windowTable, replicatespuResizeWindows, thread);
replicatespuFlushOne(thread, NewServerIndex);
/*
* restore normal, broadcasting packer flush function now.
*/
crPackFlushFunc( thread->packer, replicatespuFlush );
crPackSendHugeFunc( thread->packer, replicatespuHuge );
NewServerIndex = -1;
crDebug("Replicate SPU: leaving replicatespuReplicate");
#ifdef CHROMIUM_THREADSAFE_notyet
crUnlockMutex(&_ReplicateMutex);
#endif
}
