server_stream.c@ 76771

Last change on this file since 76771 was 73097, checked in by vboxsync, 7 years ago
*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 27.0 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_UOFFSETOF(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_UOFFSETOF(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, data_ptr_end;
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	data_ptr_end = (const char *)msg_opcodes + pIter->cbMsg;
572
573	crUnpack(data_ptr, /* first command's operands */
574	data_ptr_end, /* first byte after command's operands*/
575	data_ptr - 1, /* first command's opcode */
576	msg_opcodes->numOpcodes, /* how many opcodes */
577	&(cr_server.dispatch)); /* the CR dispatch table */
578
579	RTMemFree(pIter);
580	}
581
582	cr_server.fProcessingPendedCommands = GL_FALSE;
583	}
584
585	/**
586	* This function takes the given message (which should be a buffer of
587	* rendering commands) and executes it.
588	*/
589	static void
590	crServerDispatchMessage(CRConnection conn, CRMessage msg, int cbMsg)
591	{
592	const CRMessageOpcodes *msg_opcodes;
593	int opcodeBytes;
594	const char data_ptr, data_ptr_end;
595	#ifdef VBOX_WITH_CRHGSMI
596	PCRVBOXHGSMI_CMDDATA pCmdData = NULL;
597	#endif
598	CR_UNPACK_BUFFER_TYPE enmType;
599	bool fUnpack = true;
600
601	if (msg->header.type == CR_MESSAGE_REDIR_PTR)
602	{
603	#ifdef VBOX_WITH_CRHGSMI
604	pCmdData = &msg->redirptr.CmdData;
605	#endif
606	msg = (CRMessage *) msg->redirptr.pMessage;
607	}
608
609	CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
610
611	msg_opcodes = (const CRMessageOpcodes *) msg;
612	opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
613
614	#ifdef VBOXCR_LOGFPS
615	CRASSERT(cr_server.curClient && cr_server.curClient->conn && cr_server.curClient->conn->id == msg->header.conn_id);
616	cr_server.curClient->conn->opcodes_count += msg_opcodes->numOpcodes;
617	#endif
618
619	data_ptr = (const char *) msg_opcodes + sizeof(CRMessageOpcodes) + opcodeBytes;
620	data_ptr_end = (const char *)msg_opcodes + cbMsg; // Pointer to the first byte after message data
621
622	enmType = crUnpackGetBufferType(data_ptr - 1, /* first command's opcode */
623	msg_opcodes->numOpcodes /* how many opcodes */);
624	switch (enmType)
625	{
626	case CR_UNPACK_BUFFER_TYPE_GENERIC:
627	{
628	if (RTListIsEmpty(&conn->PendingMsgList))
629	break;
630
631	if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
632	{
633	fUnpack = false;
634	break;
635	}
636
637	WARN(("crServerPendMsg failed"));
638	crServerPendProcess(conn);
639	break;
640	}
641	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN:
642	{
643	if (RTListIsEmpty(&conn->PendingMsgList))
644	{
645	if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
646	{
647	Assert(!RTListIsEmpty(&conn->PendingMsgList));
648	fUnpack = false;
649	break;
650	}
651	else
652	WARN(("crServerPendMsg failed"));
653	}
654	else
655	WARN(("Pend List is NOT empty, drain the current list, and ignore this command"));
656
657	crServerPendProcess(conn);
658	break;
659	}
660	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_FLUSH: /* just flush for now */
661	{
662	CrPMgrClearRegionsGlobal(); /* clear regions to ensure we don't do MakeCurrent and friends */
663	crServerPendProcess(conn);
664	Assert(RTListIsEmpty(&conn->PendingMsgList));
665	break;
666	}
667	case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END:
668	{
669	// CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
670	crServerPendProcess(conn);
671	Assert(RTListIsEmpty(&conn->PendingMsgList));
672	break;
673	}
674	default:
675	WARN(("unsupported buffer type"));
676	break;
677	}
678
679	if (fUnpack)
680	{
681	crUnpack(data_ptr, /* first command's operands */
682	data_ptr_end, /* first byte after command's operands*/
683	data_ptr - 1, /* first command's opcode */
684	msg_opcodes->numOpcodes, /* how many opcodes */
685	&(cr_server.dispatch)); /* the CR dispatch table */
686	}
687
688	#ifdef VBOX_WITH_CRHGSMI
689	if (pCmdData)
690	{
691	int rc = VINF_SUCCESS;
692	CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(pCmdData);
693	if (CRVBOXHGSMI_CMDDATA_IS_SETWB(pCmdData))
694	{
695	uint32_t cbWriteback = pCmdData->cbWriteback;
696	rc = crVBoxServerInternalClientRead(conn->pClient, (uint8_t*)pCmdData->pWriteback, &cbWriteback);
697	Assert(rc == VINF_SUCCESS \|\| rc == VERR_BUFFER_OVERFLOW);
698	*pCmdData->pcbWriteback = cbWriteback;
699	}
700	VBOXCRHGSMI_CMD_CHECK_COMPLETE(pCmdData, rc);
701	}
702	#endif
703	}
704
705
706	typedef enum
707	{
708	CLIENT_GONE = 1, /* the client has disconnected */
709	CLIENT_NEXT = 2, /* we can advance to next client */
710	CLIENT_MORE = 3 /* we need to keep servicing current client */
711	} ClientStatus;
712
713
714	/**
715	* Process incoming/pending message for the given client (queue entry).
716	* \return CLIENT_GONE if this client has gone away/exited,
717	* CLIENT_NEXT if we can advance to the next client
718	* CLIENT_MORE if we have to process more messages for this client.
719	*/
720	static ClientStatus
721	crServerServiceClient(const RunQueue *qEntry)
722	{
723	CRMessage *msg;
724	CRConnection *conn;
725
726	/* set current client pointer */
727	cr_server.curClient = qEntry->client;
728
729	conn = cr_server.run_queue->client->conn;
730
731	/* service current client as long as we can */
732	while (conn && conn->type != CR_NO_CONNECTION &&
733	crNetNumMessages(conn) > 0) {
734	unsigned int len;
735
736	/*
737	crDebug("%d messages on %p",
738	crNetNumMessages(conn), (void *) conn);
739	*/
740
741	/* Don't use GetMessage, because we want to do our own crNetRecv() calls
742	* here ourself.
743	* Note that crNetPeekMessage() DOES remove the message from the queue
744	* if there is one.
745	*/
746	len = crNetPeekMessage( conn, &msg );
747	CRASSERT(len > 0);
748	if (msg->header.type != CR_MESSAGE_OPCODES
749	&& msg->header.type != CR_MESSAGE_REDIR_PTR) {
750	crError( "SPU %d sent me CRAP (type=0x%x)",
751	cr_server.curClient->spu_id, msg->header.type );
752	}
753
754	/* Do the context switch here. No sense in switching before we
755	* really have any work to process. This is a no-op if we're
756	* not really switching contexts.
757	*
758	* XXX This isn't entirely sound. The crStateMakeCurrent() call
759	* will compute the state difference and dispatch it using
760	* the head SPU's dispatch table.
761	*
762	* This is a problem if this is the first buffer coming in,
763	* and the head SPU hasn't had a chance to do a MakeCurrent()
764	* yet (likely because the MakeCurrent() command is in the
765	* buffer itself).
766	*
767	* At best, in this case, the functions are no-ops, and
768	* are essentially ignored by the SPU. In the typical
769	* case, things aren't too bad; if the SPU just calls
770	* crState*() functions to update local state, everything
771	* will work just fine.
772	*
773	* In the worst (but unusual) case where a nontrivial
774	* SPU is at the head of a crserver's SPU chain (say,
775	* in a multiple-tiered "tilesort" arrangement, as
776	* seen in the "multitilesort.conf" configuration), the
777	* SPU may rely on state set during the MakeCurrent() that
778	* may not be present yet, because no MakeCurrent() has
779	* yet been dispatched.
780	*
781	* This headache will have to be revisited in the future;
782	* for now, SPUs that could head a crserver's SPU chain
783	* will have to detect the case that their functions are
784	* being called outside of a MakeCurrent(), and will have
785	* to handle the situation gracefully. (This is currently
786	* the case with the "tilesort" SPU.)
787	*/
788
789	#if 0
790	crStateMakeCurrent( cr_server.curClient->currentCtx );
791	#else
792	/* Check if the current window is the one that the client wants to
793	* draw into. If not, dispatch a MakeCurrent to activate the proper
794	* window.
795	*/
796	if (cr_server.curClient) {
797	int clientWindow = cr_server.curClient->currentWindow;
798	int clientContext = cr_server.curClient->currentContextNumber;
799	CRContextInfo *clientCtxInfo = cr_server.curClient->currentCtxInfo;
800	if (clientCtxInfo != cr_server.currentCtxInfo
801	\|\| clientWindow != cr_server.currentWindow
802	\|\| cr_server.bForceMakeCurrentOnClientSwitch) {
803	crServerDispatchMakeCurrent(clientWindow, 0, clientContext);
804	/*
805	CRASSERT(cr_server.currentWindow == clientWindow);
806	*/
807	}
808	}
809	#endif
810
811	/* Force scissor, viewport and projection matrix update in
812	* crServerSetOutputBounds().
813	*/
814	cr_server.currentSerialNo = 0;
815
816	/* Commands get dispatched here */
817	crServerDispatchMessage( conn, msg, len );
818
819	crNetFree( conn, msg );
820
821	if (qEntry->blocked) {
822	/* Note/assert: we should not be inside a glBegin/End or glNewList/
823	* glEndList pair at this time!
824	*/
825	CRASSERT(0);
826	return CLIENT_NEXT;
827	}
828
829	} /* while */
830
831	/*
832	* Check if client/connection is gone
833	*/
834	if (!conn \|\| conn->type == CR_NO_CONNECTION) {
835	crDebug("Delete client %p at %d", cr_server.run_queue->client, __LINE__);
836	crServerDeleteClient( cr_server.run_queue->client );
837	return CLIENT_GONE;
838	}
839
840	/*
841	* Determine if we can advance to next client.
842	* If we're currently inside a glBegin/End primitive or building a display
843	* list we can't service another client until we're done with the
844	* primitive/list.
845	*/
846	if (crServerClientInBeginEnd(cr_server.curClient)) {
847	/* The next message has to come from the current client's connection. */
848	CRASSERT(!qEntry->blocked);
849	return CLIENT_MORE;
850	}
851	else {
852	/* get next client */
853	return CLIENT_NEXT;
854	}
855	}
856
857
858
859	/**
860	* Check if any of the clients need servicing.
861	* If so, service one client and return.
862	* Else, just return.
863	*/
864	void
865	crServerServiceClients(void)
866	{
867	RunQueue *q;
868
869	q = getNextClient(GL_FALSE); /* don't block */
870	while (q)
871	{
872	ClientStatus stat = crServerServiceClient(q);
873	if (stat == CLIENT_NEXT && cr_server.run_queue->next) {
874	/* advance to next client */
875	cr_server.run_queue = cr_server.run_queue->next;
876	}
877	q = getNextClient(GL_FALSE);
878	}
879	}
880
881
882
883
884	/**
885	* Main crserver loop. Service connections from all connected clients.
886	* XXX add a config option to specify whether the crserver
887	* should exit when there's no more clients.
888	*/
889	void
890	crServerSerializeRemoteStreams(void)
891	{
892	/MSG msg;/
893
894	while (cr_server.run_queue)
895	{
896	crServerServiceClients();
897	/*if (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
898	{
899	if (msg.message == WM_QUIT)
900	{
901	PostQuitMessage((int)msg.wParam);
902	break;
903	}
904	TranslateMessage( &msg );
905	DispatchMessage( &msg );
906	}*/
907	}
908	}
909
910
911	/**
912	* This will be called by the network layer when it's received a new message.
913	*/
914	int
915	crServerRecv( CRConnection conn, CRMessage msg, unsigned int len )
916	{
917	CRMessage *pRealMsg;
918	(void) len;
919
920	pRealMsg = (msg->header.type!=CR_MESSAGE_REDIR_PTR) ? msg : (CRMessage*) msg->redirptr.pMessage;
921
922	switch( pRealMsg->header.type )
923	{
924	/* Called when using multiple threads */
925	case CR_MESSAGE_NEWCLIENT:
926	crServerAddNewClient();
927	return 1; /* msg handled */
928	default:
929	/*crWarning( "Why is the crserver getting a message of type 0x%x?",
930	msg->header.type ); */
931	;
932	}
933	return 0; /* not handled */
934	}

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

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

Download in other formats: