server_stream.c@ 52260

Last change on this file since 52260 was 52260, checked in by vboxsync, 11 years ago
crOpenGL: proper support of GetErr being called from display list, better error handling
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 26.3 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_END:
658	{
659	CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
660	crServerPendProcess(conn);
661	Assert(RTListIsEmpty(&conn->PendingMsgList));
662	break;
663	}
664	default:
665	WARN(("unsupported buffer type"));
666	break;
667	}
668
669	if (fUnpack)
670	{
671	crUnpack(data_ptr, /* first command's operands */
672	data_ptr - 1, /* first command's opcode */
673	msg_opcodes->numOpcodes, /* how many opcodes */
674	&(cr_server.dispatch)); /* the CR dispatch table */
675	}
676
677	#ifdef VBOX_WITH_CRHGSMI
678	if (pCmdData)
679	{
680	int rc = VINF_SUCCESS;
681	CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(pCmdData);
682	if (CRVBOXHGSMI_CMDDATA_IS_SETWB(pCmdData))
683	{
684	uint32_t cbWriteback = pCmdData->cbWriteback;
685	rc = crVBoxServerInternalClientRead(conn->pClient, (uint8_t*)pCmdData->pWriteback, &cbWriteback);
686	Assert(rc == VINF_SUCCESS \|\| rc == VERR_BUFFER_OVERFLOW);
687	*pCmdData->pcbWriteback = cbWriteback;
688	}
689	VBOXCRHGSMI_CMD_CHECK_COMPLETE(pCmdData, rc);
690	}
691	#endif
692	}
693
694
695	typedef enum
696	{
697	CLIENT_GONE = 1, /* the client has disconnected */
698	CLIENT_NEXT = 2, /* we can advance to next client */
699	CLIENT_MORE = 3 /* we need to keep servicing current client */
700	} ClientStatus;
701
702
703	/**
704	* Process incoming/pending message for the given client (queue entry).
705	* \return CLIENT_GONE if this client has gone away/exited,
706	* CLIENT_NEXT if we can advance to the next client
707	* CLIENT_MORE if we have to process more messages for this client.
708	*/
709	static ClientStatus
710	crServerServiceClient(const RunQueue *qEntry)
711	{
712	CRMessage *msg;
713	CRConnection *conn;
714
715	/* set current client pointer */
716	cr_server.curClient = qEntry->client;
717
718	conn = cr_server.run_queue->client->conn;
719
720	/* service current client as long as we can */
721	while (conn && conn->type != CR_NO_CONNECTION &&
722	crNetNumMessages(conn) > 0) {
723	unsigned int len;
724
725	/*
726	crDebug("%d messages on %p",
727	crNetNumMessages(conn), (void *) conn);
728	*/
729
730	/* Don't use GetMessage, because we want to do our own crNetRecv() calls
731	* here ourself.
732	* Note that crNetPeekMessage() DOES remove the message from the queue
733	* if there is one.
734	*/
735	len = crNetPeekMessage( conn, &msg );
736	CRASSERT(len > 0);
737	if (msg->header.type != CR_MESSAGE_OPCODES
738	&& msg->header.type != CR_MESSAGE_REDIR_PTR) {
739	crError( "SPU %d sent me CRAP (type=0x%x)",
740	cr_server.curClient->spu_id, msg->header.type );
741	}
742
743	/* Do the context switch here. No sense in switching before we
744	* really have any work to process. This is a no-op if we're
745	* not really switching contexts.
746	*
747	* XXX This isn't entirely sound. The crStateMakeCurrent() call
748	* will compute the state difference and dispatch it using
749	* the head SPU's dispatch table.
750	*
751	* This is a problem if this is the first buffer coming in,
752	* and the head SPU hasn't had a chance to do a MakeCurrent()
753	* yet (likely because the MakeCurrent() command is in the
754	* buffer itself).
755	*
756	* At best, in this case, the functions are no-ops, and
757	* are essentially ignored by the SPU. In the typical
758	* case, things aren't too bad; if the SPU just calls
759	* crState*() functions to update local state, everything
760	* will work just fine.
761	*
762	* In the worst (but unusual) case where a nontrivial
763	* SPU is at the head of a crserver's SPU chain (say,
764	* in a multiple-tiered "tilesort" arrangement, as
765	* seen in the "multitilesort.conf" configuration), the
766	* SPU may rely on state set during the MakeCurrent() that
767	* may not be present yet, because no MakeCurrent() has
768	* yet been dispatched.
769	*
770	* This headache will have to be revisited in the future;
771	* for now, SPUs that could head a crserver's SPU chain
772	* will have to detect the case that their functions are
773	* being called outside of a MakeCurrent(), and will have
774	* to handle the situation gracefully. (This is currently
775	* the case with the "tilesort" SPU.)
776	*/
777
778	#if 0
779	crStateMakeCurrent( cr_server.curClient->currentCtx );
780	#else
781	/* Check if the current window is the one that the client wants to
782	* draw into. If not, dispatch a MakeCurrent to activate the proper
783	* window.
784	*/
785	if (cr_server.curClient) {
786	int clientWindow = cr_server.curClient->currentWindow;
787	int clientContext = cr_server.curClient->currentContextNumber;
788	CRContextInfo *clientCtxInfo = cr_server.curClient->currentCtxInfo;
789	if (clientCtxInfo != cr_server.currentCtxInfo
790	\|\| clientWindow != cr_server.currentWindow
791	\|\| cr_server.bForceMakeCurrentOnClientSwitch) {
792	crServerDispatchMakeCurrent(clientWindow, 0, clientContext);
793	/*
794	CRASSERT(cr_server.currentWindow == clientWindow);
795	*/
796	}
797	}
798	#endif
799
800	/* Force scissor, viewport and projection matrix update in
801	* crServerSetOutputBounds().
802	*/
803	cr_server.currentSerialNo = 0;
804
805	/* Commands get dispatched here */
806	crServerDispatchMessage( conn, msg, len );
807
808	crNetFree( conn, msg );
809
810	if (qEntry->blocked) {
811	/* Note/assert: we should not be inside a glBegin/End or glNewList/
812	* glEndList pair at this time!
813	*/
814	CRASSERT(0);
815	return CLIENT_NEXT;
816	}
817
818	} /* while */
819
820	/*
821	* Check if client/connection is gone
822	*/
823	if (!conn \|\| conn->type == CR_NO_CONNECTION) {
824	crDebug("Delete client %p at %d", cr_server.run_queue->client, __LINE__);
825	crServerDeleteClient( cr_server.run_queue->client );
826	return CLIENT_GONE;
827	}
828
829	/*
830	* Determine if we can advance to next client.
831	* If we're currently inside a glBegin/End primitive or building a display
832	* list we can't service another client until we're done with the
833	* primitive/list.
834	*/
835	if (crServerClientInBeginEnd(cr_server.curClient)) {
836	/* The next message has to come from the current client's connection. */
837	CRASSERT(!qEntry->blocked);
838	return CLIENT_MORE;
839	}
840	else {
841	/* get next client */
842	return CLIENT_NEXT;
843	}
844	}
845
846
847
848	/**
849	* Check if any of the clients need servicing.
850	* If so, service one client and return.
851	* Else, just return.
852	*/
853	void
854	crServerServiceClients(void)
855	{
856	RunQueue *q;
857
858	q = getNextClient(GL_FALSE); /* don't block */
859	while (q)
860	{
861	ClientStatus stat = crServerServiceClient(q);
862	if (stat == CLIENT_NEXT && cr_server.run_queue->next) {
863	/* advance to next client */
864	cr_server.run_queue = cr_server.run_queue->next;
865	}
866	q = getNextClient(GL_FALSE);
867	}
868	}
869
870
871
872
873	/**
874	* Main crserver loop. Service connections from all connected clients.
875	* XXX add a config option to specify whether the crserver
876	* should exit when there's no more clients.
877	*/
878	void
879	crServerSerializeRemoteStreams(void)
880	{
881	/MSG msg;/
882
883	while (cr_server.run_queue)
884	{
885	crServerServiceClients();
886	/*if (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
887	{
888	if (msg.message == WM_QUIT)
889	{
890	PostQuitMessage((int)msg.wParam);
891	break;
892	}
893	TranslateMessage( &msg );
894	DispatchMessage( &msg );
895	}*/
896	}
897	}
898
899
900	/**
901	* This will be called by the network layer when it's received a new message.
902	*/
903	int
904	crServerRecv( CRConnection conn, CRMessage msg, unsigned int len )
905	{
906	CRMessage *pRealMsg;
907	(void) len;
908
909	pRealMsg = (msg->header.type!=CR_MESSAGE_REDIR_PTR) ? msg : (CRMessage*) msg->redirptr.pMessage;
910
911	switch( pRealMsg->header.type )
912	{
913	/* Called when using multiple threads */
914	case CR_MESSAGE_NEWCLIENT:
915	crServerAddNewClient();
916	return 1; /* msg handled */
917	default:
918	/*crWarning( "Why is the crserver getting a message of type 0x%x?",
919	msg->header.type ); */
920	;
921	}
922	return 0; /* not handled */
923	}

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

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

Download in other formats: