server_stream.c@ 53582

Last change on this file since 53582 was 52451, checked in by vboxsync, 10 years ago
crOpenGL: command blocks flushing
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 26.6 KB

Line
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include "server.h"
8	#include "cr_unpack.h"
9	#include "cr_error.h"
10	#include "cr_mem.h"
11	#include "server_dispatch.h"
12
13
14	/**
15	* Accept a new client connection, create a new CRClient and add to run queue.
16	*/
17	void
18	crServerAddNewClient(void)
19	{
20	CRClient newClient = (CRClient ) crCalloc(sizeof(CRClient));
21
22	if (newClient) {
23	newClient->spu_id = cr_server.client_spu_id;
24	newClient->conn = crNetAcceptClient( cr_server.protocol, NULL,
25	cr_server.tcpip_port,
26	cr_server.mtu, 1 );
27
28	newClient->currentCtxInfo = &cr_server.MainContextInfo;
29
30	/* add to array */
31	cr_server.clients[cr_server.numClients++] = newClient;
32
33	crServerAddToRunQueue( newClient );
34	}
35	}
36
37
38	/**
39	* Check if client is in the run queue.
40	*/
41	static GLboolean
42	FindClientInQueue(CRClient *client)
43	{
44	RunQueue *q = cr_server.run_queue;
45	while (q) {
46	if (q->client == client) {
47	return 1;
48	}
49	q = q->next;
50	if (q == cr_server.run_queue)
51	return 0; /* back head */
52	}
53	return 0;
54	}
55
56
57	#if 0
58	static int
59	PrintQueue(void)
60	{
61	RunQueue *q = cr_server.run_queue;
62	int count = 0;
63	crDebug("Queue entries:");
64	while (q) {
65	count++;
66	crDebug("Entry: %p client: %p", q, q->client);
67	q = q->next;
68	if (q == cr_server.run_queue)
69	return count;
70	}
71	return count;
72	}
73	#endif
74
75
76	void crServerAddToRunQueue( CRClient *client )
77	{
78	RunQueue q = (RunQueue ) crAlloc( sizeof( *q ) );
79
80	#ifdef VBOX_WITH_CRHGSMI
81	client->conn->pClient = client;
82	CRVBOXHGSMI_CMDDATA_CLEANUP(&client->conn->CmdData);
83	#endif
84
85	/* give this client a unique number if needed */
86	if (!client->number) {
87	client->number = client->conn->u32ClientID;
88	}
89
90	crDebug("Adding client %p to the run queue", client);
91
92	if (FindClientInQueue(client)) {
93	crError("CRServer: client %p already in the queue!", client);
94	}
95
96	q->client = client;
97	q->blocked = 0;
98
99	if (!cr_server.run_queue)
100	{
101	/* adding to empty queue */
102	cr_server.run_queue = q;
103	q->next = q;
104	q->prev = q;
105	}
106	else
107	{
108	/* insert in doubly-linked list */
109	q->next = cr_server.run_queue->next;
110	cr_server.run_queue->next->prev = q;
111
112	q->prev = cr_server.run_queue;
113	cr_server.run_queue->next = q;
114	}
115	}
116
117	static void crServerCleanupClient(CRClient *client)
118	{
119	int32_t pos;
120	CRClient *oldclient = cr_server.curClient;
121
122	cr_server.curClient = client;
123
124	/* Destroy any windows created by the client */
125	for (pos = 0; pos<CR_MAX_WINDOWS; pos++)
126	{
127	if (client->windowList[pos])
128	{
129	cr_server.dispatch.WindowDestroy(client->windowList[pos]);
130	}
131	}
132
133	/* Check if we have context(s) made by this client left, could happen if client side code is lazy */
134	for (pos = 0; pos<CR_MAX_CONTEXTS; pos++)
135	{
136	if (client->contextList[pos])
137	{
138	cr_server.dispatch.DestroyContext(client->contextList[pos]);
139	}
140	}
141
142	cr_server.curClient = oldclient;
143	}
144
145	static void crServerCleanupByPID(uint64_t pid)
146	{
147	CRClientNode pNode=cr_server.pCleanupClient, pNext;
148
149	while (pNode)
150	{
151	if (pNode->pClient->pid==pid)
152	{
153	crServerCleanupClient(pNode->pClient);
154	crFree(pNode->pClient);
155	if (pNode->prev)
156	{
157	pNode->prev->next=pNode->next;
158	}
159	else
160	{
161	cr_server.pCleanupClient=pNode->next;
162	}
163	if (pNode->next)
164	{
165	pNode->next->prev = pNode->prev;
166	}
167
168	pNext=pNode->next;
169	crFree(pNode);
170	pNode=pNext;
171	}
172	else
173	{
174	pNode=pNode->next;
175	}
176	}
177	}
178
179	void
180	crServerDeleteClient( CRClient *client )
181	{
182	int i, j;
183	int cleanup=1;
184
185	crDebug("Deleting client %p (%d msgs left)", client, crNetNumMessages(client->conn));
186
187	#if 0
188	if (crNetNumMessages(client->conn) > 0) {
189	crDebug("Delay destroying client: message still pending");
190	return;
191	}
192	#endif
193
194	if (!FindClientInQueue(client)) {
195	/* this should never happen */
196	crError("CRServer: client %p not found in the queue!", client);
197	}
198
199	/* remove from clients[] array */
200	for (i = 0; i < cr_server.numClients; i++) {
201	if (cr_server.clients[i] == client) {
202	/* found it */
203	for (j = i; j < cr_server.numClients - 1; j++)
204	cr_server.clients[j] = cr_server.clients[j + 1];
205	cr_server.numClients--;
206	break;
207	}
208	}
209
210	/* check if there're any other guest threads in same process */
211	for (i=0; i < cr_server.numClients; i++)
212	{
213	if (cr_server.clients[i]->pid==client->pid)
214	{
215	cleanup=0;
216	break;
217	}
218	}
219
220	if (cleanup)
221	{
222	crServerCleanupClient(client);
223	}
224
225	/* remove from the run queue */
226	if (cr_server.run_queue)
227	{
228	RunQueue *q = cr_server.run_queue;
229	RunQueue *qStart = cr_server.run_queue;
230	do {
231	if (q->client == client)
232	{
233	/* this test seems a bit excessive */
234	if ((q->next == q->prev) && (q->next == q) && (cr_server.run_queue == q))
235	{
236	/* We're removing/deleting the only client */
237	CRASSERT(cr_server.numClients == 0);
238	crFree(q);
239	cr_server.run_queue = NULL;
240	cr_server.curClient = NULL;
241	crDebug("Last client deleted - empty run queue.");
242	}
243	else
244	{
245	/* remove from doubly linked list and free the node */
246	if (cr_server.curClient == q->client)
247	cr_server.curClient = NULL;
248	if (cr_server.run_queue == q)
249	cr_server.run_queue = q->next;
250	q->prev->next = q->next;
251	q->next->prev = q->prev;
252	crFree(q);
253	}
254	break;
255	}
256	q = q->next;
257	} while (q != qStart);
258	}
259
260	crNetFreeConnection(client->conn);
261	client->conn = NULL;
262
263	if (cleanup)
264	{
265	crServerCleanupByPID(client->pid);
266	crFree(client);
267	}
268	else
269	{
270	CRClientNode pNode = (CRClientNode )crAlloc(sizeof(CRClientNode));
271	if (!pNode)
272	{
273	crWarning("Not enough memory, forcing client cleanup");
274	crServerCleanupClient(client);
275	crServerCleanupByPID(client->pid);
276	crFree(client);
277	return;
278	}
279	pNode->pClient = client;
280	pNode->prev = NULL;
281	pNode->next = cr_server.pCleanupClient;
282	cr_server.pCleanupClient = pNode;
283	}
284
285	if (!cr_server.numClients)
286	{
287	/* if no clients, the guest driver may be unloaded,
288	* and thus the visible regions situation might not be under control anymore,
289	* so cleanup the 3D framebuffer data here
290	* @todo: what really should happen is that guest driver on unload
291	* posts some request to host that would copy the current framebuffer 3D data to the 2D buffer
292	* (i.e. to the memory used by the standard IFramebuffer API) */
293	HCR_FRAMEBUFFER hFb;
294	for (hFb = CrPMgrFbGetFirstEnabled(); hFb; hFb = CrPMgrFbGetNextEnabled(hFb))
295	{
296	int rc = CrFbUpdateBegin(hFb);
297	if (RT_SUCCESS(rc))
298	{
299	CrFbRegionsClear(hFb);
300	CrFbUpdateEnd(hFb);
301	}
302	else
303	WARN(("CrFbUpdateBegin failed %d", rc));
304	}
305	}
306	}
307
308	/**
309	* Test if the given client is in the middle of a glBegin/End or
310	* glNewList/EndList pair.
311	* This is used to test if we can advance to the next client.
312	* \return GL_TRUE if so, GL_FALSE otherwise.
313	*/
314	GLboolean
315	crServerClientInBeginEnd(const CRClient *client)
316	{
317	if (client->currentCtxInfo
318	&& client->currentCtxInfo->pContext
319	&& (client->currentCtxInfo->pContext->lists.currentIndex != 0 \|\|
320	client->currentCtxInfo->pContext->current.inBeginEnd \|\|
321	client->currentCtxInfo->pContext->occlusion.currentQueryObject)) {
322	return GL_TRUE;
323	}
324	else {
325	return GL_FALSE;
326	}
327	}
328
329
330	/**
331	* Find the next client in the run queue that's not blocked and has a
332	* waiting message.
333	* Check if all clients are blocked (on barriers, semaphores), if so we've
334	* deadlocked!
335	* If no clients have a waiting message, call crNetRecv to get something
336	* if 'block' is true, else return NULL if 'block' if false.
337	*/
338	static RunQueue *
339	getNextClient(GLboolean block)
340	{
341	while (1)
342	{
343	if (cr_server.run_queue)
344	{
345	GLboolean all_blocked = GL_TRUE;
346	GLboolean done_something = GL_FALSE;
347	RunQueue *start = cr_server.run_queue;
348
349	/* check if this client's connection has gone away */
350	if (!cr_server.run_queue->client->conn
351	\|\| (cr_server.run_queue->client->conn->type == CR_NO_CONNECTION
352	&& crNetNumMessages(cr_server.run_queue->client->conn) == 0))
353	{
354	crServerDeleteClient( cr_server.run_queue->client );
355	start = cr_server.run_queue;
356	}
357
358	if (cr_server.run_queue == NULL) {
359	/* empty queue */
360	return NULL;
361	}
362
363	if (crServerClientInBeginEnd(cr_server.run_queue->client)) {
364	/* We _must_ service this client and no other.
365	* If we've got a message waiting on this client's connection we'll
366	* service it. Else, return NULL.
367	*/
368	if (crNetNumMessages(cr_server.run_queue->client->conn) > 0)
369	return cr_server.run_queue;
370	else
371	return NULL;
372	}
373
374	/* loop over entries in run queue, looking for next one that's ready */
375	while (!done_something \|\| cr_server.run_queue != start)
376	{
377	done_something = GL_TRUE;
378	if (!cr_server.run_queue->blocked)
379	{
380	all_blocked = GL_FALSE;
381	}
382	if (!cr_server.run_queue->blocked
383	&& cr_server.run_queue->client->conn
384	&& crNetNumMessages(cr_server.run_queue->client->conn) > 0)
385	{
386	/* OK, this client isn't blocked and has a queued message */
387	return cr_server.run_queue;
388	}
389	cr_server.run_queue = cr_server.run_queue->next;
390	}
391
392	if (all_blocked)
393	{
394	/* XXX crError is fatal? Should this be an info/warning msg? */
395	crError( "crserver: DEADLOCK! (numClients=%d, all blocked)",
396	cr_server.numClients );
397	if (cr_server.numClients < (int) cr_server.maxBarrierCount) {
398	crError("Waiting for more clients!!!");
399	while (cr_server.numClients < (int) cr_server.maxBarrierCount) {
400	crNetRecv();
401	}
402	}
403	}
404	}
405
406	if (!block)
407	return NULL;
408
409	/* no one had any work, get some! */
410	crNetRecv();
411
412	} /* while */
413
414	/* UNREACHED */
415	/* return NULL; */
416	}
417
418	typedef struct CR_SERVER_PENDING_MSG
419	{
420	RTLISTNODE Node;
421	uint32_t cbMsg;
422	CRMessage Msg;
423	} CR_SERVER_PENDING_MSG;
424
425	static int crServerPendMsg(CRConnection conn, const CRMessage msg, int cbMsg)
426	{
427	CR_SERVER_PENDING_MSG *pMsg;
428
429	if (!cbMsg)
430	{
431	WARN(("cbMsg is null!"));
432	return VERR_INVALID_PARAMETER;
433	}
434
435	pMsg = (CR_SERVER_PENDING_MSG*)RTMemAlloc(cbMsg + RT_OFFSETOF(CR_SERVER_PENDING_MSG, Msg));
436	if (!pMsg)
437	{
438	WARN(("RTMemAlloc failed"));
439	return VERR_NO_MEMORY;
440	}
441
442	pMsg->cbMsg = cbMsg;
443
444	memcpy(&pMsg->Msg, msg, cbMsg);
445
446	RTListAppend(&conn->PendingMsgList, &pMsg->Node);
447
448	return VINF_SUCCESS;
449	}
450
451	int crServerPendSaveState(PSSMHANDLE pSSM)
452	{
453	int i, rc;
454
455	for (i = 0; i < cr_server.numClients; i++)
456	{
457	CR_SERVER_PENDING_MSG *pIter;
458	CRClient *pClient = cr_server.clients[i];
459	CRConnection *pConn;
460	if (!pClient \|\| !pClient->conn)
461	{
462	WARN(("invalid client state"));
463	continue;
464	}
465
466	pConn = pClient->conn;
467
468	if (RTListIsEmpty(&pConn->PendingMsgList))
469	continue;
470
471	CRASSERT(pConn->u32ClientID);
472
473	rc = SSMR3PutU32(pSSM, pConn->u32ClientID);
474	AssertRCReturn(rc, rc);
475
476	RTListForEach(&pConn->PendingMsgList, pIter, CR_SERVER_PENDING_MSG, Node)
477	{
478	CRASSERT(pIter->cbMsg);
479
480	rc = SSMR3PutU32(pSSM, pIter->cbMsg);
481	AssertRCReturn(rc, rc);
482
483	rc = SSMR3PutMem(pSSM, &pIter->Msg, pIter->cbMsg);
484	AssertRCReturn(rc, rc);
485	}
486
487	rc = SSMR3PutU32(pSSM, 0);
488	AssertRCReturn(rc, rc);
489	}
490
491	rc = SSMR3PutU32(pSSM, 0);
492	AssertRCReturn(rc, rc);
493
494	return VINF_SUCCESS;
495	}
496
497	int crServerPendLoadState(PSSMHANDLE pSSM, uint32_t u32Version)
498	{
499	int rc;
500	uint32_t u32;
501	CRClient *pClient;
502
503	if (u32Version < SHCROGL_SSM_VERSION_WITH_PEND_CMD_INFO)
504	return VINF_SUCCESS;
505
506	rc = SSMR3GetU32(pSSM, &u32);
507	AssertRCReturn(rc, rc);
508
509	if (!u32)
510	return VINF_SUCCESS;
511
512	do {
513	rc = crVBoxServerClientGet(u32, &pClient);
514	AssertRCReturn(rc, rc);
515
516	for(;;)
517	{
518	CR_SERVER_PENDING_MSG *pMsg;
519
520	rc = SSMR3GetU32(pSSM, &u32);
521	AssertRCReturn(rc, rc);
522
523	if (!u32)
524	break;
525
526	pMsg = (CR_SERVER_PENDING_MSG*)RTMemAlloc(u32 + RT_OFFSETOF(CR_SERVER_PENDING_MSG, Msg));
527	if (!pMsg)
528	{
529	WARN(("RTMemAlloc failed"));
530	return VERR_NO_MEMORY;
531	}
532
533	pMsg->cbMsg = u32;
534	rc = SSMR3GetMem(pSSM, &pMsg->Msg, u32);
535	AssertRCReturn(rc, rc);
536
537	RTListAppend(&pClient->conn->PendingMsgList, &pMsg->Node);
538	}
539
540	rc = SSMR3GetU32(pSSM, &u32);
541	AssertRCReturn(rc, rc);
542	} while (u32);
543
544	rc = SSMR3GetU32(pSSM, &u32);
545	AssertRCReturn(rc, rc);
546
547	return VINF_SUCCESS;
548	}
549
550	static void crServerPendProcess(CRConnection *conn)
551	{
552	CR_SERVER_PENDING_MSG pIter, pNext;
553
554	cr_server.fProcessingPendedCommands = GL_TRUE;
555
556	RTListForEachSafe(&conn->PendingMsgList, pIter, pNext, CR_SERVER_PENDING_MSG, Node)
557	{
558	CRMessage *msg = &pIter->Msg;
559	const CRMessageOpcodes *msg_opcodes;
560	int opcodeBytes;
561	const char *data_ptr;
562
563	RTListNodeRemove(&pIter->Node);
564
565	CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
566
567	msg_opcodes = (const CRMessageOpcodes *) msg;
568	opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
569
570	data_ptr = (const char *) msg_opcodes + sizeof (CRMessageOpcodes) + opcodeBytes;
571
572	crUnpack(data_ptr, /* first command's operands */
573	data_ptr - 1, /* first command's opcode */
574	msg_opcodes->numOpcodes, /* how many opcodes */
575	&(cr_server.dispatch)); /* the CR dispatch table */
576
577	RTMemFree(pIter);
578	}
579
580	cr_server.fProcessingPendedCommands = GL_FALSE;
581	}
582
583	/**
584	* This function takes the given message (which should be a buffer of
585	* rendering commands) and executes it.
586	*/
587	static void
588	crServerDispatchMessage(CRConnection conn, CRMessage msg, int cbMsg)
589	{
590	const CRMessageOpcodes *msg_opcodes;
591	int opcodeBytes;
592	const char *data_ptr;
593	#ifdef VBOX_WITH_CRHGSMI
594	PCRVBOXHGSMI_CMDDATA pCmdData = NULL;
595	#endif
596	CR_UNPACK_BUFFER_TYPE enmType;
597	bool fUnpack = true;
598
599	if (msg->header.type == CR_MESSAGE_REDIR_PTR)
600	{
601	#ifdef VBOX_WITH_CRHGSMI
602	pCmdData = &msg->redirptr.CmdData;
603	#endif
604	msg = (CRMessage *) msg->redirptr.pMessage;
605	}
606
607	CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
608
609	msg_opcodes = (const CRMessageOpcodes *) msg;
610	opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
611
612	#ifdef VBOXCR_LOGFPS
613	CRASSERT(cr_server.curClient && cr_server.curClient->conn && cr_server.curClient->conn->id == msg->header.conn_id);
614	cr_server.curClient->conn->opcodes_count += msg_opcodes->numOpcodes;
615	#endif
616
617	data_ptr = (const char *) msg_opcodes + sizeof(CRMessageOpcodes) + opcodeBytes;
618
619	enmType = crUnpackGetBufferType(data_ptr - 1, /* first command's opcode */
620	msg_opcodes->numOpcodes /* how many opcodes */);
621	switch (enmType)
622	{
623	case CR_UNPACK_BUFFER_TYPE_GENERIC:
624	{
625	if (RTListIsEmpty(&conn->PendingMsgList))
626	break;
627
628	if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
629	{
630	fUnpack = false;
631	break;
632	}
633
634	WARN(("crServerPendMsg failed"));
635	crServerPendProcess(conn);
636	break;
637	}
638	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN:
639	{
640	if (RTListIsEmpty(&conn->PendingMsgList))
641	{
642	if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
643	{
644	Assert(!RTListIsEmpty(&conn->PendingMsgList));
645	fUnpack = false;
646	break;
647	}
648	else
649	WARN(("crServerPendMsg failed"));
650	}
651	else
652	WARN(("Pend List is NOT empty, drain the current list, and ignore this command"));
653
654	crServerPendProcess(conn);
655	break;
656	}
657	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_FLUSH: /* just flush for now */
658	{
659	CrPMgrClearRegionsGlobal(); /* clear regions to ensure we don't do MakeCurrent and friends */
660	crServerPendProcess(conn);
661	Assert(RTListIsEmpty(&conn->PendingMsgList));
662	break;
663	}
664	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END:
665	{
666	// CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
667	crServerPendProcess(conn);
668	Assert(RTListIsEmpty(&conn->PendingMsgList));
669	break;
670	}
671	default:
672	WARN(("unsupported buffer type"));
673	break;
674	}
675
676	if (fUnpack)
677	{
678	crUnpack(data_ptr, /* first command's operands */
679	data_ptr - 1, /* first command's opcode */
680	msg_opcodes->numOpcodes, /* how many opcodes */
681	&(cr_server.dispatch)); /* the CR dispatch table */
682	}
683
684	#ifdef VBOX_WITH_CRHGSMI
685	if (pCmdData)
686	{
687	int rc = VINF_SUCCESS;
688	CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(pCmdData);
689	if (CRVBOXHGSMI_CMDDATA_IS_SETWB(pCmdData))
690	{
691	uint32_t cbWriteback = pCmdData->cbWriteback;
692	rc = crVBoxServerInternalClientRead(conn->pClient, (uint8_t*)pCmdData->pWriteback, &cbWriteback);
693	Assert(rc == VINF_SUCCESS \|\| rc == VERR_BUFFER_OVERFLOW);
694	*pCmdData->pcbWriteback = cbWriteback;
695	}
696	VBOXCRHGSMI_CMD_CHECK_COMPLETE(pCmdData, rc);
697	}
698	#endif
699	}
700
701
702	typedef enum
703	{
704	CLIENT_GONE = 1, /* the client has disconnected */
705	CLIENT_NEXT = 2, /* we can advance to next client */
706	CLIENT_MORE = 3 /* we need to keep servicing current client */
707	} ClientStatus;
708
709
710	/**
711	* Process incoming/pending message for the given client (queue entry).
712	* \return CLIENT_GONE if this client has gone away/exited,
713	* CLIENT_NEXT if we can advance to the next client
714	* CLIENT_MORE if we have to process more messages for this client.
715	*/
716	static ClientStatus
717	crServerServiceClient(const RunQueue *qEntry)
718	{
719	CRMessage *msg;
720	CRConnection *conn;
721
722	/* set current client pointer */
723	cr_server.curClient = qEntry->client;
724
725	conn = cr_server.run_queue->client->conn;
726
727	/* service current client as long as we can */
728	while (conn && conn->type != CR_NO_CONNECTION &&
729	crNetNumMessages(conn) > 0) {
730	unsigned int len;
731
732	/*
733	crDebug("%d messages on %p",
734	crNetNumMessages(conn), (void *) conn);
735	*/
736
737	/* Don't use GetMessage, because we want to do our own crNetRecv() calls
738	* here ourself.
739	* Note that crNetPeekMessage() DOES remove the message from the queue
740	* if there is one.
741	*/
742	len = crNetPeekMessage( conn, &msg );
743	CRASSERT(len > 0);
744	if (msg->header.type != CR_MESSAGE_OPCODES
745	&& msg->header.type != CR_MESSAGE_REDIR_PTR) {
746	crError( "SPU %d sent me CRAP (type=0x%x)",
747	cr_server.curClient->spu_id, msg->header.type );
748	}
749
750	/* Do the context switch here. No sense in switching before we
751	* really have any work to process. This is a no-op if we're
752	* not really switching contexts.
753	*
754	* XXX This isn't entirely sound. The crStateMakeCurrent() call
755	* will compute the state difference and dispatch it using
756	* the head SPU's dispatch table.
757	*
758	* This is a problem if this is the first buffer coming in,
759	* and the head SPU hasn't had a chance to do a MakeCurrent()
760	* yet (likely because the MakeCurrent() command is in the
761	* buffer itself).
762	*
763	* At best, in this case, the functions are no-ops, and
764	* are essentially ignored by the SPU. In the typical
765	* case, things aren't too bad; if the SPU just calls
766	* crState*() functions to update local state, everything
767	* will work just fine.
768	*
769	* In the worst (but unusual) case where a nontrivial
770	* SPU is at the head of a crserver's SPU chain (say,
771	* in a multiple-tiered "tilesort" arrangement, as
772	* seen in the "multitilesort.conf" configuration), the
773	* SPU may rely on state set during the MakeCurrent() that
774	* may not be present yet, because no MakeCurrent() has
775	* yet been dispatched.
776	*
777	* This headache will have to be revisited in the future;
778	* for now, SPUs that could head a crserver's SPU chain
779	* will have to detect the case that their functions are
780	* being called outside of a MakeCurrent(), and will have
781	* to handle the situation gracefully. (This is currently
782	* the case with the "tilesort" SPU.)
783	*/
784
785	#if 0
786	crStateMakeCurrent( cr_server.curClient->currentCtx );
787	#else
788	/* Check if the current window is the one that the client wants to
789	* draw into. If not, dispatch a MakeCurrent to activate the proper
790	* window.
791	*/
792	if (cr_server.curClient) {
793	int clientWindow = cr_server.curClient->currentWindow;
794	int clientContext = cr_server.curClient->currentContextNumber;
795	CRContextInfo *clientCtxInfo = cr_server.curClient->currentCtxInfo;
796	if (clientCtxInfo != cr_server.currentCtxInfo
797	\|\| clientWindow != cr_server.currentWindow
798	\|\| cr_server.bForceMakeCurrentOnClientSwitch) {
799	crServerDispatchMakeCurrent(clientWindow, 0, clientContext);
800	/*
801	CRASSERT(cr_server.currentWindow == clientWindow);
802	*/
803	}
804	}
805	#endif
806
807	/* Force scissor, viewport and projection matrix update in
808	* crServerSetOutputBounds().
809	*/
810	cr_server.currentSerialNo = 0;
811
812	/* Commands get dispatched here */
813	crServerDispatchMessage( conn, msg, len );
814
815	crNetFree( conn, msg );
816
817	if (qEntry->blocked) {
818	/* Note/assert: we should not be inside a glBegin/End or glNewList/
819	* glEndList pair at this time!
820	*/
821	CRASSERT(0);
822	return CLIENT_NEXT;
823	}
824
825	} /* while */
826
827	/*
828	* Check if client/connection is gone
829	*/
830	if (!conn \|\| conn->type == CR_NO_CONNECTION) {
831	crDebug("Delete client %p at %d", cr_server.run_queue->client, __LINE__);
832	crServerDeleteClient( cr_server.run_queue->client );
833	return CLIENT_GONE;
834	}
835
836	/*
837	* Determine if we can advance to next client.
838	* If we're currently inside a glBegin/End primitive or building a display
839	* list we can't service another client until we're done with the
840	* primitive/list.
841	*/
842	if (crServerClientInBeginEnd(cr_server.curClient)) {
843	/* The next message has to come from the current client's connection. */
844	CRASSERT(!qEntry->blocked);
845	return CLIENT_MORE;
846	}
847	else {
848	/* get next client */
849	return CLIENT_NEXT;
850	}
851	}
852
853
854
855	/**
856	* Check if any of the clients need servicing.
857	* If so, service one client and return.
858	* Else, just return.
859	*/
860	void
861	crServerServiceClients(void)
862	{
863	RunQueue *q;
864
865	q = getNextClient(GL_FALSE); /* don't block */
866	while (q)
867	{
868	ClientStatus stat = crServerServiceClient(q);
869	if (stat == CLIENT_NEXT && cr_server.run_queue->next) {
870	/* advance to next client */
871	cr_server.run_queue = cr_server.run_queue->next;
872	}
873	q = getNextClient(GL_FALSE);
874	}
875	}
876
877
878
879
880	/**
881	* Main crserver loop. Service connections from all connected clients.
882	* XXX add a config option to specify whether the crserver
883	* should exit when there's no more clients.
884	*/
885	void
886	crServerSerializeRemoteStreams(void)
887	{
888	/MSG msg;/
889
890	while (cr_server.run_queue)
891	{
892	crServerServiceClients();
893	/*if (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
894	{
895	if (msg.message == WM_QUIT)
896	{
897	PostQuitMessage((int)msg.wParam);
898	break;
899	}
900	TranslateMessage( &msg );
901	DispatchMessage( &msg );
902	}*/
903	}
904	}
905
906
907	/**
908	* This will be called by the network layer when it's received a new message.
909	*/
910	int
911	crServerRecv( CRConnection conn, CRMessage msg, unsigned int len )
912	{
913	CRMessage *pRealMsg;
914	(void) len;
915
916	pRealMsg = (msg->header.type!=CR_MESSAGE_REDIR_PTR) ? msg : (CRMessage*) msg->redirptr.pMessage;
917
918	switch( pRealMsg->header.type )
919	{
920	/* Called when using multiple threads */
921	case CR_MESSAGE_NEWCLIENT:
922	crServerAddNewClient();
923	return 1; /* msg handled */
924	default:
925	/*crWarning( "Why is the crserver getting a message of type 0x%x?",
926	msg->header.type ); */
927	;
928	}
929	return 0; /* not handled */
930	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.c@ 53582

Download in other formats: