VirtualBox

source: vbox/trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c @ 69989

Revision 69989, 70.7 KB checked in by vboxsync, 5 weeks ago (diff)

Additions/common/OpenGL: fix regressions from r117617/public r68472.
bugref:9060: vboxvideo: hanging login screen starting Ubuntu 17.10 guest with 3D
r117617/public r68472 and the follow-up switched from using duplicate code in
the X11 libGL code to access the guest driver and HGCM to using the common
code. It contained at least two problems: it failed to initialise the
runtime library before calling into the Guest library and it changed error
checking semantics slightly, causing us to fail to handle a too-small-buffer
error and sending GNOME Shell into an endless loop. This change fixes that
and also adds todo comments to other places where the error handling should
be cleaned up, but which I do not want to change and test just now.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* $Id$ */
2/** @file
3 * VBox HGCM connection
4 */
5
6/*
7 * Copyright (C) 2008-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifdef RT_OS_WINDOWS
19# include <iprt/win/windows.h>
20# include <ddraw.h>
21#else
22# include <sys/ioctl.h>
23# include <errno.h>
24# include <fcntl.h>
25# include <string.h>
26# include <unistd.h>
27#endif
28
29#include "cr_error.h"
30#include "cr_net.h"
31#include "cr_bufpool.h"
32#include "cr_mem.h"
33#include "cr_string.h"
34#include "cr_endian.h"
35#include "cr_threads.h"
36#include "net_internals.h"
37#include "cr_process.h"
38
39#include <iprt/initterm.h>
40#include <iprt/thread.h>
41
42#include <VBox/VBoxGuestLib.h>
43#include <VBox/HostServices/VBoxCrOpenGLSvc.h>
44
45#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
46#include <VBoxCrHgsmi.h>
47#endif
48
49/** @todo move define somewhere else, and make sure it's less than VBGLR0_MAX_HGCM_KERNEL_PARM*/
50/*If we fail to pass data in one chunk, send it in chunks of this size instead*/
51#define CR_HGCM_SPLIT_BUFFER_SIZE (8*_1M)
52
53#ifndef MIN
54# define MIN(a, b) ((a) < (b) ? (a) : (b))
55#endif
56
57#ifdef DEBUG_misha
58#ifdef CRASSERT
59# undef CRASSERT
60#endif
61#define CRASSERT Assert
62#endif
63/*#define IN_GUEST
64#if defined(IN_GUEST)
65#define VBOX_WITH_CRHGSMIPROFILE
66#endif */
67#ifdef VBOX_WITH_CRHGSMIPROFILE
68#include <iprt/time.h>
69#include <stdio.h>
70
71typedef struct VBOXCRHGSMIPROFILE
72{
73    uint64_t cStartTime;
74    uint64_t cStepsTime;
75    uint64_t cSteps;
76} VBOXCRHGSMIPROFILE, *PVBOXCRHGSMIPROFILE;
77
78#define VBOXCRHGSMIPROFILE_GET_TIME_NANO() RTTimeNanoTS()
79#define VBOXCRHGSMIPROFILE_GET_TIME_MILLI() RTTimeMilliTS()
80
81/* 10 sec */
82#define VBOXCRHGSMIPROFILE_LOG_STEP_TIME (10000000000.)
83
84DECLINLINE(void) vboxCrHgsmiProfileStart(PVBOXCRHGSMIPROFILE pProfile)
85{
86    pProfile->cStepsTime = 0;
87    pProfile->cSteps = 0;
88    pProfile->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
89}
90
91DECLINLINE(void) vboxCrHgsmiProfileStep(PVBOXCRHGSMIPROFILE pProfile, uint64_t cStepTime)
92{
93    pProfile->cStepsTime += cStepTime;
94    ++pProfile->cSteps;
95}
96
97typedef struct VBOXCRHGSMIPROFILE_SCOPE
98{
99    uint64_t cStartTime;
100/*    bool bDisable;*/
101} VBOXCRHGSMIPROFILE_SCOPE, *PVBOXCRHGSMIPROFILE_SCOPE;
102
103static VBOXCRHGSMIPROFILE g_VBoxProfile;
104
105static void vboxCrHgsmiLog(char * szString, ...)
106{
107    char szBuffer[4096] = {0};
108     va_list pArgList;
109     va_start(pArgList, szString);
110     _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
111     va_end(pArgList);
112
113#ifdef VBOX_WITH_CRHGSMI
114     VBoxCrHgsmiLog(szBuffer);
115#else
116     OutputDebugString(szBuffer);
117#endif
118}
119
120DECLINLINE(void) vboxCrHgsmiProfileLog(PVBOXCRHGSMIPROFILE pProfile, uint64_t cTime)
121{
122    uint64_t profileTime = cTime - pProfile->cStartTime;
123    double percent = ((double)100.0) * pProfile->cStepsTime / profileTime;
124    double cps = ((double)1000000000.) * pProfile->cSteps / profileTime;
125    vboxCrHgsmiLog("hgcm: cps: %.1f, host %.1f%%\n", cps, percent);
126}
127
128DECLINLINE(void) vboxCrHgsmiProfileScopeEnter(PVBOXCRHGSMIPROFILE_SCOPE pScope)
129{
130/*    pScope->bDisable = false; */
131    pScope->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
132}
133
134DECLINLINE(void) vboxCrHgsmiProfileScopeExit(PVBOXCRHGSMIPROFILE_SCOPE pScope)
135{
136/*    if (!pScope->bDisable) */
137    {
138        uint64_t cTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
139        vboxCrHgsmiProfileStep(&g_VBoxProfile, cTime - pScope->cStartTime);
140        if (VBOXCRHGSMIPROFILE_LOG_STEP_TIME < cTime - g_VBoxProfile.cStartTime)
141        {
142            vboxCrHgsmiProfileLog(&g_VBoxProfile, cTime);
143            vboxCrHgsmiProfileStart(&g_VBoxProfile);
144        }
145    }
146}
147
148
149#define VBOXCRHGSMIPROFILE_INIT() vboxCrHgsmiProfileStart(&g_VBoxProfile)
150#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
151
152#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() \
153        VBOXCRHGSMIPROFILE_SCOPE __vboxCrHgsmiProfileScope; \
154        vboxCrHgsmiProfileScopeEnter(&__vboxCrHgsmiProfileScope);
155
156#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() \
157        vboxCrHgsmiProfileScopeExit(&__vboxCrHgsmiProfileScope); \
158
159
160#else
161#define VBOXCRHGSMIPROFILE_INIT() do {} while (0)
162#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
163#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() do {} while (0)
164#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() do {} while (0)
165#endif
166
167typedef struct {
168    int                  initialized;
169    int                  num_conns;
170    CRConnection         **conns;
171    CRBufferPool         *bufpool;
172#ifdef CHROMIUM_THREADSAFE
173    CRmutex              mutex;
174    CRmutex              recvmutex;
175#endif
176    CRNetReceiveFuncList *recv_list;
177    CRNetCloseFuncList   *close_list;
178#ifdef RT_OS_WINDOWS
179    LPDIRECTDRAW         pDirectDraw;
180#endif
181#ifdef IN_GUEST
182    uint32_t             u32HostCaps;
183    bool                 fHostCapsInitialized;
184#endif
185#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
186    bool bHgsmiOn;
187#endif
188} CRVBOXHGCMDATA;
189
190static CRVBOXHGCMDATA g_crvboxhgcm = {0,};
191
192typedef enum {
193    CR_VBOXHGCM_USERALLOCATED,
194    CR_VBOXHGCM_MEMORY,
195    CR_VBOXHGCM_MEMORY_BIG
196#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
197    ,CR_VBOXHGCM_UHGSMI_BUFFER
198#endif
199} CRVBOXHGCMBUFFERKIND;
200
201#define CR_VBOXHGCM_BUFFER_MAGIC 0xABCDE321
202
203typedef struct CRVBOXHGCMBUFFER {
204    uint32_t             magic;
205    CRVBOXHGCMBUFFERKIND kind;
206    union
207    {
208        struct
209        {
210            uint32_t             len;
211            uint32_t             allocated;
212        };
213
214#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
215        PVBOXUHGSMI_BUFFER pBuffer;
216#endif
217    };
218} CRVBOXHGCMBUFFER;
219
220#ifndef RT_OS_WINDOWS
221    #define TRUE true
222    #define FALSE false
223    #define INVALID_HANDLE_VALUE (-1)
224#endif
225
226
227#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
228
229/* add sizeof header + page align */
230#define CRVBOXHGSMI_PAGE_ALIGN(_s) (((_s)  + 0xfff) & ~0xfff)
231#define CRVBOXHGSMI_BUF_HDR_SIZE() (sizeof (CRVBOXHGCMBUFFER))
232#define CRVBOXHGSMI_BUF_SIZE(_s) CRVBOXHGSMI_PAGE_ALIGN((_s) + CRVBOXHGSMI_BUF_HDR_SIZE())
233#define CRVBOXHGSMI_BUF_LOCK_SIZE(_s) ((_s) + CRVBOXHGSMI_BUF_HDR_SIZE())
234#define CRVBOXHGSMI_BUF_DATA(_p) ((void*)(((CRVBOXHGCMBUFFER*)(_p)) + 1))
235#define CRVBOXHGSMI_BUF_HDR(_p) (((CRVBOXHGCMBUFFER*)(_p)) - 1)
236#define CRVBOXHGSMI_BUF_OFFSET(_st2, _st1) ((uint32_t)(((uint8_t*)(_st2)) - ((uint8_t*)(_st1))))
237
238static int _crVBoxHGSMIClientInit(PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI pHgsmi)
239{
240    int rc;
241    VBOXUHGSMI_BUFFER_TYPE_FLAGS Flags = {0};
242    pClient->pHgsmi = pHgsmi;
243    Flags.fCommand = 1;
244    rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1), Flags, &pClient->pCmdBuffer);
245    if (RT_SUCCESS(rc))
246    {
247        Flags.Value = 0;
248        rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1), Flags, &pClient->pHGBuffer);
249        if (RT_SUCCESS(rc))
250        {
251            pClient->pvHGBuffer = NULL;
252            pClient->bufpool = crBufferPoolInit(16);
253            return VINF_SUCCESS;
254        }
255        else
256            crWarning("_crVBoxHGSMIClientInit: pfnBufferCreate failed to allocate host->guest buffer");
257
258        pClient->pCmdBuffer->pfnDestroy(pClient->pCmdBuffer);
259    }
260    else
261        crWarning("_crVBoxHGSMIClientInit: pfnBufferCreate failed to allocate cmd buffer");
262
263    pClient->pHgsmi = NULL;
264    return rc;
265}
266
267void _crVBoxHGSMIBufferFree(void *data)
268{
269    PVBOXUHGSMI_BUFFER pBuffer = (PVBOXUHGSMI_BUFFER)data;
270    pBuffer->pfnDestroy(pBuffer);
271}
272
273static int _crVBoxHGSMIClientTerm(PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI *ppHgsmi)
274{
275    if (pClient->bufpool)
276        crBufferPoolCallbackFree(pClient->bufpool, _crVBoxHGSMIBufferFree);
277    pClient->bufpool = NULL;
278
279    if (pClient->pHGBuffer)
280    {
281        pClient->pHGBuffer->pfnDestroy(pClient->pHGBuffer);
282        pClient->pHGBuffer = NULL;
283    }
284
285    if (pClient->pCmdBuffer)
286    {
287        pClient->pCmdBuffer->pfnDestroy(pClient->pCmdBuffer);
288        pClient->pCmdBuffer = NULL;
289    }
290
291    if (ppHgsmi)
292    {
293        *ppHgsmi = pClient->pHgsmi;
294    }
295    pClient->pHgsmi = NULL;
296
297    return VINF_SUCCESS;
298}
299
300
301#ifdef VBOX_CRHGSMI_WITH_D3DDEV
302
303static DECLCALLBACK(HVBOXCRHGSMI_CLIENT) _crVBoxHGSMIClientCreate(PVBOXUHGSMI pHgsmi)
304{
305    PCRVBOXHGSMI_CLIENT pClient = crAlloc(sizeof (CRVBOXHGSMI_CLIENT));
306
307    if (pClient)
308    {
309        int rc = _crVBoxHGSMIClientInit(pClient, pHgsmi);
310        if (RT_SUCCESS(rc))
311            return (HVBOXCRHGSMI_CLIENT)pClient;
312        else
313            crWarning("_crVBoxHGSMIClientCreate: _crVBoxHGSMIClientInit failed rc %d", rc);
314
315        crFree(pCLient);
316    }
317
318    return NULL;
319}
320
321static DECLCALLBACK(void) _crVBoxHGSMIClientDestroy(HVBOXCRHGSMI_CLIENT hClient)
322{
323    PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)hClient;
324    _crVBoxHGSMIClientTerm(pClient, NULL);
325    crFree(pClient);
326}
327#endif
328
329DECLINLINE(PCRVBOXHGSMI_CLIENT) _crVBoxHGSMIClientGet(CRConnection *conn)
330{
331#ifdef VBOX_CRHGSMI_WITH_D3DDEV
332    PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)VBoxCrHgsmiQueryClient();
333    CRASSERT(pClient);
334    return pClient;
335#else
336    if (conn->HgsmiClient.pHgsmi)
337        return &conn->HgsmiClient;
338    {
339        PVBOXUHGSMI pHgsmi = conn->pExternalHgsmi ? conn->pExternalHgsmi : VBoxCrHgsmiCreate();
340        if (pHgsmi)
341        {
342            int rc = _crVBoxHGSMIClientInit(&conn->HgsmiClient, pHgsmi);
343            if (RT_SUCCESS(rc))
344            {
345                CRASSERT(conn->HgsmiClient.pHgsmi);
346                return &conn->HgsmiClient;
347            }
348            else
349                crWarning("_crVBoxHGSMIClientGet: _crVBoxHGSMIClientInit failed rc %d", rc);
350            if (!conn->pExternalHgsmi)
351                VBoxCrHgsmiDestroy(pHgsmi);
352        }
353        else
354        {
355            crWarning("VBoxCrHgsmiCreate failed");
356        }
357    }
358    return NULL;
359#endif
360}
361
362static PVBOXUHGSMI_BUFFER _crVBoxHGSMIBufAlloc(PCRVBOXHGSMI_CLIENT pClient, uint32_t cbSize)
363{
364    PVBOXUHGSMI_BUFFER buf;
365    int rc;
366
367    buf = (PVBOXUHGSMI_BUFFER ) crBufferPoolPop(pClient->bufpool, cbSize);
368
369    if (!buf)
370    {
371        VBOXUHGSMI_BUFFER_TYPE_FLAGS Flags = {0};
372        crDebug("Buffer pool %p was empty; allocating new %d byte buffer.",
373                        (void *) pClient->bufpool,
374                        cbSize);
375        rc = pClient->pHgsmi->pfnBufferCreate(pClient->pHgsmi, cbSize, Flags, &buf);
376        if (RT_FAILURE(rc))
377            crWarning("_crVBoxHGSMIBufAlloc: Failed to Create a buffer of size(%d), rc(%d)\n", cbSize, rc);
378    }
379    return buf;
380}
381
382static PVBOXUHGSMI_BUFFER _crVBoxHGSMIBufFromHdr(CRVBOXHGCMBUFFER *pHdr)
383{
384    PVBOXUHGSMI_BUFFER pBuf;
385    int rc;
386    CRASSERT(pHdr->magic == CR_VBOXHGCM_BUFFER_MAGIC);
387    CRASSERT(pHdr->kind == CR_VBOXHGCM_UHGSMI_BUFFER);
388    pBuf = pHdr->pBuffer;
389    rc = pBuf->pfnUnlock(pBuf);
390    if (RT_FAILURE(rc))
391    {
392        crWarning("_crVBoxHGSMIBufFromHdr: pfnUnlock failed rc %d", rc);
393        return NULL;
394    }
395    return pBuf;
396}
397
398static void _crVBoxHGSMIBufFree(PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI_BUFFER pBuf)
399{
400    crBufferPoolPush(pClient->bufpool, pBuf, pBuf->cbBuffer);
401}
402
403static CRVBOXHGSMIHDR *_crVBoxHGSMICmdBufferLock(PCRVBOXHGSMI_CLIENT pClient, uint32_t cbBuffer)
404{
405    /* in theory it is OK to use one cmd buffer for asynch cmd submission
406     * because bDiscard flag should result in allocating a new memory backend if the
407     * allocation is still in use.
408     * However, NOTE: since one and the same semaphore synch event is used for completion notification,
409     * for the notification mechanism working as expected
410     * 1. host must complete commands in the same order as it receives them
411     * (to avoid situation when guest receives notification for another command completion)
412     * 2. guest must eventually wait for command completion unless he specified bDoNotSignalCompletion
413     * 3. guest must wait for command completion in the same order as it submits them
414     * in case we can not satisfy any of the above, we should introduce multiple command buffers */
415    CRVBOXHGSMIHDR * pHdr;
416    VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
417    int rc;
418    fFlags.Value = 0;
419    fFlags.bDiscard = 1;
420    rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, cbBuffer, fFlags, (void**)&pHdr);
421    if (RT_SUCCESS(rc))
422        return pHdr;
423    else
424        crWarning("_crVBoxHGSMICmdBufferLock: pfnLock failed rc %d", rc);
425
426    crWarning("Failed to Lock the command buffer of size(%d), rc(%d)\n", cbBuffer, rc);
427    return NULL;
428}
429
430static CRVBOXHGSMIHDR *_crVBoxHGSMICmdBufferLockRo(PCRVBOXHGSMI_CLIENT pClient, uint32_t cbBuffer)
431{
432    /* in theory it is OK to use one cmd buffer for asynch cmd submission
433     * because bDiscard flag should result in allocating a new memory backend if the
434     * allocation is still in use.
435     * However, NOTE: since one and the same semaphore synch event is used for completion notification,
436     * for the notification mechanism working as expected
437     * 1. host must complete commands in the same order as it receives them
438     * (to avoid situation when guest receives notification for another command completion)
439     * 2. guest must eventually wait for command completion unless he specified bDoNotSignalCompletion
440     * 3. guest must wait for command completion in the same order as it submits them
441     * in case we can not satisfy any of the above, we should introduce multiple command buffers */
442    CRVBOXHGSMIHDR * pHdr = NULL;
443    VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
444    int rc;
445    fFlags.Value = 0;
446    fFlags.bReadOnly = 1;
447    rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, cbBuffer, fFlags, (void**)&pHdr);
448    if (RT_FAILURE(rc))
449        crWarning("Failed to Lock the command buffer of size(%d), rc(%d)\n", cbBuffer, rc);
450    return pHdr;
451}
452
453static void _crVBoxHGSMICmdBufferUnlock(PCRVBOXHGSMI_CLIENT pClient)
454{
455    int rc = pClient->pCmdBuffer->pfnUnlock(pClient->pCmdBuffer);
456    if (RT_FAILURE(rc))
457        crError("Failed to Unlock the command buffer rc(%d)\n", rc);
458}
459
460static int32_t _crVBoxHGSMICmdBufferGetRc(PCRVBOXHGSMI_CLIENT pClient)
461{
462    CRVBOXHGSMIHDR * pHdr;
463    VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
464    int rc;
465
466    fFlags.Value = 0;
467    fFlags.bReadOnly = 1;
468    rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, sizeof (*pHdr), fFlags, (void**)&pHdr);
469    if (RT_FAILURE(rc))
470    {
471        crWarning("Failed to Lock the command buffer of size(%d), rc(%d)\n", sizeof (*pHdr), rc);
472        return rc;
473    }
474
475    rc = pHdr->result;
476    AssertRC(rc);
477    pClient->pCmdBuffer->pfnUnlock(pClient->pCmdBuffer);
478
479    return rc;
480}
481
482DECLINLINE(PVBOXUHGSMI_BUFFER) _crVBoxHGSMIRecvBufGet(PCRVBOXHGSMI_CLIENT pClient)
483{
484    if (pClient->pvHGBuffer)
485    {
486        int rc = pClient->pHGBuffer->pfnUnlock(pClient->pHGBuffer);
487        if (RT_FAILURE(rc))
488        {
489            return NULL;
490        }
491        pClient->pvHGBuffer = NULL;
492    }
493    return pClient->pHGBuffer;
494}
495
496DECLINLINE(void*) _crVBoxHGSMIRecvBufData(PCRVBOXHGSMI_CLIENT pClient, uint32_t cbBuffer)
497{
498    VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
499    int rc;
500    CRASSERT(!pClient->pvHGBuffer);
501    fFlags.Value = 0;
502    rc = pClient->pHGBuffer->pfnLock(pClient->pHGBuffer, 0, cbBuffer, fFlags, &pClient->pvHGBuffer);
503    if (RT_SUCCESS(rc))
504        return pClient->pvHGBuffer;
505    else
506        crWarning("_crVBoxHGSMIRecvBufData: pfnLock failed rc %d", rc);
507
508    return NULL;
509}
510
511DECLINLINE(void) _crVBoxHGSMIFillCmd(VBOXUHGSMI_BUFFER_SUBMIT *pSubm, PCRVBOXHGSMI_CLIENT pClient, uint32_t cbData)
512{
513    pSubm->pBuf = pClient->pCmdBuffer;
514    pSubm->offData = 0;
515    pSubm->cbData = cbData;
516    pSubm->fFlags.Value = 0;
517    pSubm->fFlags.bDoNotRetire = 1;
518# if 0
519    pSubm->fFlags.bDoNotSignalCompletion = 1; /* <- we do not need that actually since
520                                               * in case we want completion,
521                                               * we will block in _crVBoxHGSMICmdBufferGetRc (when locking the buffer)
522                                               * which is needed for getting the result */
523# endif
524}
525#endif
526
527/* Some forward declarations */
528static void _crVBoxHGCMReceiveMessage(CRConnection *conn);
529
530#ifndef IN_GUEST
531static bool _crVBoxHGCMReadBytes(CRConnection *conn, void *buf, uint32_t len)
532{
533    CRASSERT(conn && buf);
534
535    if (!conn->pBuffer || (conn->cbBuffer<len))
536        return FALSE;
537
538    crMemcpy(buf, conn->pBuffer, len);
539
540    conn->cbBuffer -= len;
541    conn->pBuffer = conn->cbBuffer>0 ? (uint8_t*)conn->pBuffer+len : NULL;
542
543    return TRUE;
544}
545#endif
546
547#ifndef IN_GUEST
548/** @todo get rid of it*/
549static bool _crVBoxHGCMWriteBytes(CRConnection *conn, const void *buf, uint32_t len)
550{
551    CRASSERT(conn && buf);
552
553    /* make sure there's host buffer and it's clear */
554    CRASSERT(conn->pHostBuffer && !conn->cbHostBuffer);
555
556    if (conn->cbHostBufferAllocated < len)
557    {
558        crDebug("Host buffer too small %d out of requested %d bytes, reallocating", conn->cbHostBufferAllocated, len);
559        crFree(conn->pHostBuffer);
560        conn->pHostBuffer = crAlloc(len);
561        if (!conn->pHostBuffer)
562        {
563            conn->cbHostBufferAllocated = 0;
564            crError("OUT_OF_MEMORY trying to allocate %d bytes", len);
565            return FALSE;
566        }
567        conn->cbHostBufferAllocated = len;
568    }
569
570    crMemcpy(conn->pHostBuffer, buf, len);
571    conn->cbHostBuffer = len;
572
573    return TRUE;
574}
575#endif
576
577/**
578 * Send an HGCM request
579 *
580 * @return VBox status code
581 * @param   pvData      Data pointer
582 * @param   cbData      Data size
583 */
584static int crVBoxHGCMCall(CRConnection *conn, PVBGLIOCHGCMCALL pData, unsigned cbData)
585{
586#ifdef IN_GUEST
587    int rc;
588# ifndef VBOX_WITH_CRHGSMI
589    RT_NOREF(conn);
590# else
591    PCRVBOXHGSMI_CLIENT pClient = g_crvboxhgcm.bHgsmiOn ? _crVBoxHGSMIClientGet(conn) : NULL;
592    if (pClient)
593        rc = VBoxCrHgsmiCtlConCall(pClient->pHgsmi, pData, cbData);
594    else
595# endif
596    {
597        rc = VbglR3HGCMCall(pData, cbData);
598        if (RT_SUCCESS(rc))
599        { /* likely */ }
600        else
601        {
602            crWarning("vboxCall failed with VBox status code %Rrc\n", rc);
603# ifndef RT_OS_WINDOWS
604            if (rc == VERR_INTERRUPTED)
605            {
606                /* Not sure why we're doing the sleep stuff here.  The original coder didn't
607                   bother to mention why he thought it necessary.  :-( */
608                RTMSINTERVAL msSleep;
609                int i;
610                for (i = 0, msSleep = 50; i < 6; i++, msSleep = msSleep * 2)
611                {
612                    RTThreadSleep(msSleep);
613                    rc = VbglR3HGCMCall(pData, cbData);
614                    if (rc != VERR_INTERRUPTED)
615                    {
616                        if (RT_SUCCESS(rc))
617                            crWarning("vboxCall retry(%i) succeeded", i + 1);
618                        else
619                            crWarning("vboxCall retry(%i) failed with VBox status code %Rrc", i + 1, rc);
620                        break;
621                    }
622                }
623            }
624#  endif
625        }
626    }
627    return rc;
628
629#else  /* IN_GUEST */
630    RT_NOREF(conn, pData, cbData);
631    crError("crVBoxHGCMCall called on host side!");
632    CRASSERT(FALSE);
633    return VERR_NOT_SUPPORTED;
634#endif /* IN_GUEST */
635}
636
637static void *_crVBoxHGCMAlloc(CRConnection *conn)
638{
639    CRVBOXHGCMBUFFER *buf;
640
641#ifdef CHROMIUM_THREADSAFE
642    crLockMutex(&g_crvboxhgcm.mutex);
643#endif
644
645    buf = (CRVBOXHGCMBUFFER *) crBufferPoolPop(g_crvboxhgcm.bufpool, conn->buffer_size);
646
647    if (!buf)
648    {
649        crDebug("Buffer pool %p was empty; allocating new %d byte buffer.",
650                        (void *) g_crvboxhgcm.bufpool,
651                        (unsigned int)sizeof(CRVBOXHGCMBUFFER) + conn->buffer_size);
652
653        /* We're either on host side, or we failed to allocate DDRAW buffer */
654        if (!buf)
655        {
656            crDebug("Using system malloc\n");
657            buf = (CRVBOXHGCMBUFFER *) crAlloc( sizeof(CRVBOXHGCMBUFFER) + conn->buffer_size );
658            CRASSERT(buf);
659            buf->magic = CR_VBOXHGCM_BUFFER_MAGIC;
660            buf->kind  = CR_VBOXHGCM_MEMORY;
661            buf->allocated = conn->buffer_size;
662        }
663    }
664
665#ifdef CHROMIUM_THREADSAFE
666    crUnlockMutex(&g_crvboxhgcm.mutex);
667#endif
668
669    return (void *)( buf + 1 );
670
671}
672
673static void *crVBoxHGCMAlloc(CRConnection *conn)
674{
675    void *pvBuff;
676    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
677#ifdef CHROMIUM_THREADSAFE
678    crLockMutex(&g_crvboxhgcm.mutex);
679#endif
680    pvBuff = _crVBoxHGCMAlloc(conn);
681#ifdef CHROMIUM_THREADSAFE
682    crUnlockMutex(&g_crvboxhgcm.mutex);
683#endif
684    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
685    return pvBuff;
686}
687
688static void _crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
689{
690    int rc;
691    int32_t callRes;
692
693#ifdef IN_GUEST
694    if (conn->u32InjectClientID)
695    {
696        CRVBOXHGCMINJECT parms;
697
698        VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_INJECT, SHCRGL_CPARMS_INJECT);
699
700        parms.u32ClientID.type       = VMMDevHGCMParmType_32bit;
701        parms.u32ClientID.u.value32  = conn->u32InjectClientID;
702
703        parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
704        parms.pBuffer.u.Pointer.size         = len;
705        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
706
707        rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
708        callRes = parms.hdr.Hdr.rc; /** @todo now rc == parms.hdr.Hdr.rc */
709    }
710    else
711#endif
712    {
713        CRVBOXHGCMWRITE parms;
714
715        VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_WRITE, SHCRGL_CPARMS_WRITE);
716
717        parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
718        parms.pBuffer.u.Pointer.size         = len;
719        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
720
721        rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
722        callRes = parms.hdr.Hdr.rc; /** @todo now rc == parms.hdr.Hdr.rc */
723    }
724
725    if (RT_FAILURE(rc) || RT_FAILURE(callRes))
726    {
727        crWarning("SHCRGL_GUEST_FN_WRITE failed with %x %x\n", rc, callRes);
728    }
729}
730
731static void crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
732{
733    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
734#ifdef CHROMIUM_THREADSAFE
735    crLockMutex(&g_crvboxhgcm.mutex);
736#endif
737    _crVBoxHGCMWriteExact(conn, buf, len);
738#ifdef CHROMIUM_THREADSAFE
739    crUnlockMutex(&g_crvboxhgcm.mutex);
740#endif
741    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
742}
743
744static void crVBoxHGCMReadExact( CRConnection *conn, const void *buf, unsigned int len )
745{
746    CRVBOXHGCMREAD parms;
747    int rc;
748    RT_NOREF(buf, len);
749
750    VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_READ, SHCRGL_CPARMS_READ);
751
752    CRASSERT(!conn->pBuffer); /* make sure there's no data to process */
753    parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_Out;
754    parms.pBuffer.u.Pointer.size         = conn->cbHostBufferAllocated;
755    parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) conn->pHostBuffer;
756
757    parms.cbBuffer.type      = VMMDevHGCMParmType_32bit;
758    parms.cbBuffer.u.value32 = 0;
759
760    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
761
762    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.Hdr.rc) /** @todo now rc == parms.hdr.Hdr.rc */)
763    {
764        crWarning("SHCRGL_GUEST_FN_READ failed with %x %x\n", rc, parms.hdr.Hdr.rc);
765        return;
766    }
767
768    if (parms.cbBuffer.u.value32)
769    {
770        /*conn->pBuffer  = (uint8_t*) parms.pBuffer.u.Pointer.u.linearAddr; */
771        conn->pBuffer  = conn->pHostBuffer;
772        conn->cbBuffer = parms.cbBuffer.u.value32;
773    }
774
775    if (conn->cbBuffer)
776        _crVBoxHGCMReceiveMessage(conn);
777
778}
779
780/* Same as crVBoxHGCMWriteExact, but combined with read of writeback data.
781 * This halves the number of HGCM calls we do,
782 * most likely crVBoxHGCMPollHost shouldn't be called at all now.
783 */
784static void
785crVBoxHGCMWriteReadExact(CRConnection *conn, const void *buf, unsigned int len, CRVBOXHGCMBUFFERKIND bufferKind)
786{
787    CRVBOXHGCMWRITEREAD parms;
788    int rc;
789
790    VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_WRITE_READ, SHCRGL_CPARMS_WRITE_READ);
791
792    parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_In;
793    parms.pBuffer.u.Pointer.size         = len;
794    parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
795
796    CRASSERT(!conn->pBuffer); /*make sure there's no data to process*/
797    parms.pWriteback.type                   = VMMDevHGCMParmType_LinAddr_Out;
798    parms.pWriteback.u.Pointer.size         = conn->cbHostBufferAllocated;
799    parms.pWriteback.u.Pointer.u.linearAddr = (uintptr_t) conn->pHostBuffer;
800
801    parms.cbWriteback.type      = VMMDevHGCMParmType_32bit;
802    parms.cbWriteback.u.value32 = 0;
803
804    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
805
806#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
807    if (VERR_OUT_OF_RANGE==rc && CR_VBOXHGCM_USERALLOCATED==bufferKind)
808    {
809        /*Buffer is too big, so send it in split chunks*/
810        CRVBOXHGCMWRITEBUFFER wbParms;
811
812        VBGL_HGCM_HDR_INIT(&wbParms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_WRITE_BUFFER, SHCRGL_CPARMS_WRITE_BUFFER);
813
814        wbParms.iBufferID.type = VMMDevHGCMParmType_32bit;
815        wbParms.iBufferID.u.value32 = 0;
816
817        wbParms.cbBufferSize.type = VMMDevHGCMParmType_32bit;
818        wbParms.cbBufferSize.u.value32 = len;
819
820        wbParms.ui32Offset.type = VMMDevHGCMParmType_32bit;
821        wbParms.ui32Offset.u.value32 = 0;
822
823        wbParms.pBuffer.type = VMMDevHGCMParmType_LinAddr_In;
824        wbParms.pBuffer.u.Pointer.size         = MIN(CR_HGCM_SPLIT_BUFFER_SIZE, len);
825        wbParms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
826
827        if (len<CR_HGCM_SPLIT_BUFFER_SIZE)
828        {
829            crError("VERR_OUT_OF_RANGE in crVBoxHGCMWriteReadExact for %u bytes write", len);
830            return;
831        }
832
833        while (wbParms.pBuffer.u.Pointer.size)
834        {
835            crDebug("SHCRGL_GUEST_FN_WRITE_BUFFER, offset=%u, size=%u", wbParms.ui32Offset.u.value32, wbParms.pBuffer.u.Pointer.size);
836
837            rc = crVBoxHGCMCall(conn, &wbParms.hdr, sizeof(wbParms));
838            if (RT_FAILURE(rc) || RT_FAILURE(wbParms.hdr.Hdr.rc) /** @todo now rc == wbParms.hdr.Hdr.rc */)
839            {
840                crError("SHCRGL_GUEST_FN_WRITE_BUFFER (%i) failed with %x %x\n", wbParms.pBuffer.u.Pointer.size, rc, wbParms.hdr.Hdr.rc);
841                return;
842            }
843
844            wbParms.ui32Offset.u.value32 += wbParms.pBuffer.u.Pointer.size;
845            wbParms.pBuffer.u.Pointer.u.linearAddr += (uintptr_t) wbParms.pBuffer.u.Pointer.size;
846            wbParms.pBuffer.u.Pointer.size = MIN(CR_HGCM_SPLIT_BUFFER_SIZE, len-wbParms.ui32Offset.u.value32);
847        }
848
849        /*now issue GUEST_FN_WRITE_READ_BUFFERED referencing the buffer we'd made*/
850        {
851            CRVBOXHGCMWRITEREADBUFFERED wrbParms;
852
853            VBGL_HGCM_HDR_INIT(&wrbParms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_WRITE_READ_BUFFERED, SHCRGL_CPARMS_WRITE_READ_BUFFERED);
854
855            crMemcpy(&wrbParms.iBufferID, &wbParms.iBufferID, sizeof(HGCMFunctionParameter));
856            crMemcpy(&wrbParms.pWriteback, &parms.pWriteback, sizeof(HGCMFunctionParameter));
857            crMemcpy(&wrbParms.cbWriteback, &parms.cbWriteback, sizeof(HGCMFunctionParameter));
858
859            rc = crVBoxHGCMCall(conn, &wrbParms.hdr, sizeof(wrbParms));
860
861            /*bit of hack to reuse code below*/
862            parms.hdr.Hdr.rc = wrbParms.hdr.Hdr.rc;
863            crMemcpy(&parms.cbWriteback, &wrbParms.cbWriteback, sizeof(HGCMFunctionParameter));
864            crMemcpy(&parms.pWriteback, &wrbParms.pWriteback, sizeof(HGCMFunctionParameter));
865        }
866    }
867#endif
868
869    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.Hdr.rc) /** @todo now rc == parms.hdr.Hdr.rc */)
870    {
871
872        if ((VERR_BUFFER_OVERFLOW == parms.hdr.Hdr.rc) /* && RT_SUCCESS(rc) */)
873        {
874            /* reallocate buffer and retry */
875
876            CRASSERT(parms.cbWriteback.u.value32>conn->cbHostBufferAllocated);
877
878            crDebug("Reallocating host buffer from %d to %d bytes", conn->cbHostBufferAllocated, parms.cbWriteback.u.value32);
879
880            crFree(conn->pHostBuffer);
881            conn->cbHostBufferAllocated = parms.cbWriteback.u.value32;
882            conn->pHostBuffer = crAlloc(conn->cbHostBufferAllocated);
883
884            crVBoxHGCMReadExact(conn, buf, len);
885
886            return;
887        }
888        else
889        {
890            crWarning("SHCRGL_GUEST_FN_WRITE_READ (%i) failed with %x %x\n", len, rc, parms.hdr.Hdr.rc);
891            return;
892        }
893    }
894
895    if (parms.cbWriteback.u.value32)
896    {
897        /*conn->pBuffer  = (uint8_t*) parms.pWriteback.u.Pointer.u.linearAddr;*/
898        conn->pBuffer  = conn->pHostBuffer;
899        conn->cbBuffer = parms.cbWriteback.u.value32;
900    }
901
902    if (conn->cbBuffer)
903        _crVBoxHGCMReceiveMessage(conn);
904}
905
906static void crVBoxHGCMSend(CRConnection *conn, void **bufp,
907                           const void *start, unsigned int len)
908{
909    CRVBOXHGCMBUFFER *hgcm_buffer;
910    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
911
912#ifdef CHROMIUM_THREADSAFE
913    crLockMutex(&g_crvboxhgcm.mutex);
914#endif
915
916    if (!bufp) /* We're sending a user-allocated buffer. */
917    {
918#ifndef IN_GUEST
919            /** @todo remove temp buffer allocation in unpacker*/
920            /* we're at the host side, so just store data until guest polls us */
921            _crVBoxHGCMWriteBytes(conn, start, len);
922#else
923            CRASSERT(!conn->u32InjectClientID);
924            crDebug("SHCRGL: sending userbuf with %d bytes\n", len);
925            crVBoxHGCMWriteReadExact(conn, start, len, CR_VBOXHGCM_USERALLOCATED);
926#endif
927#ifdef CHROMIUM_THREADSAFE
928            crUnlockMutex(&g_crvboxhgcm.mutex);
929#endif
930            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
931        return;
932    }
933
934    /* The region [start .. start + len + 1] lies within a buffer that
935     * was allocated with crVBoxHGCMAlloc() and can be put into the free
936     * buffer pool when we're done sending it.
937     */
938
939    hgcm_buffer = (CRVBOXHGCMBUFFER *)(*bufp) - 1;
940    CRASSERT(hgcm_buffer->magic == CR_VBOXHGCM_BUFFER_MAGIC);
941
942    /* Length would be passed as part of HGCM pointer description
943     * No need to prepend it to the buffer
944     */
945#ifdef IN_GUEST
946    if (conn->u32InjectClientID)
947    {
948        _crVBoxHGCMWriteExact(conn, start, len);
949    }
950    else
951#endif
952    crVBoxHGCMWriteReadExact(conn, start, len, hgcm_buffer->kind);
953
954    /* Reclaim this pointer for reuse */
955#ifdef CHROMIUM_THREADSAFE
956    crLockMutex(&g_crvboxhgcm.mutex);
957#endif
958    crBufferPoolPush(g_crvboxhgcm.bufpool, hgcm_buffer, hgcm_buffer->allocated);
959#ifdef CHROMIUM_THREADSAFE
960    crUnlockMutex(&g_crvboxhgcm.mutex);
961#endif
962
963    /* Since the buffer's now in the 'free' buffer pool, the caller can't
964     * use it any more.  Setting bufp to NULL will make sure the caller
965     * doesn't try to re-use the buffer.
966     */
967    *bufp = NULL;
968
969#ifdef CHROMIUM_THREADSAFE
970    crUnlockMutex(&g_crvboxhgcm.mutex);
971#endif
972
973    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
974}
975
976static void crVBoxHGCMPollHost(CRConnection *conn)
977{
978    CRVBOXHGCMREAD parms;
979    int rc;
980
981    CRASSERT(!conn->pBuffer);
982
983    VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_READ, SHCRGL_CPARMS_READ);
984
985    parms.pBuffer.type                   = VMMDevHGCMParmType_LinAddr_Out;
986    parms.pBuffer.u.Pointer.size         = conn->cbHostBufferAllocated;
987    parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) conn->pHostBuffer;
988
989    parms.cbBuffer.type      = VMMDevHGCMParmType_32bit;
990    parms.cbBuffer.u.value32 = 0;
991
992    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
993
994    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.Hdr.rc) /** @todo now rc == parms.hdr.Hdr.rc */)
995    {
996        crDebug("SHCRGL_GUEST_FN_READ failed with %x %x\n", rc, parms.hdr.Hdr.rc);
997        return;
998    }
999
1000    if (parms.cbBuffer.u.value32)
1001    {
1002        conn->pBuffer = (uint8_t*) parms.pBuffer.u.Pointer.u.linearAddr;
1003        conn->cbBuffer = parms.cbBuffer.u.value32;
1004    }
1005}
1006
1007static void crVBoxHGCMSingleRecv(CRConnection *conn, void *buf, unsigned int len)
1008{
1009    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1010#ifdef CHROMIUM_THREADSAFE
1011    crLockMutex(&g_crvboxhgcm.mutex);
1012#endif
1013    crVBoxHGCMReadExact(conn, buf, len);
1014#ifdef CHROMIUM_THREADSAFE
1015    crUnlockMutex(&g_crvboxhgcm.mutex);
1016#endif
1017    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1018}
1019
1020static void _crVBoxHGCMFree(CRConnection *conn, void *buf)
1021{
1022    CRVBOXHGCMBUFFER *hgcm_buffer = (CRVBOXHGCMBUFFER *) buf - 1;
1023
1024    CRASSERT(hgcm_buffer->magic == CR_VBOXHGCM_BUFFER_MAGIC);
1025
1026    /** @todo wrong len for redir buffers*/
1027    conn->recv_credits += hgcm_buffer->len;
1028
1029    switch (hgcm_buffer->kind)
1030    {
1031        case CR_VBOXHGCM_MEMORY:
1032#ifdef CHROMIUM_THREADSAFE
1033            crLockMutex(&g_crvboxhgcm.mutex);
1034#endif
1035            if (g_crvboxhgcm.bufpool) {
1036                /** @todo o'rly? */
1037                /* pool may have been deallocated just a bit earlier in response
1038                 * to a SIGPIPE (Broken Pipe) signal.
1039                 */
1040                crBufferPoolPush(g_crvboxhgcm.bufpool, hgcm_buffer, hgcm_buffer->allocated);
1041            }
1042#ifdef CHROMIUM_THREADSAFE
1043            crUnlockMutex(&g_crvboxhgcm.mutex);
1044#endif
1045            break;
1046
1047        case CR_VBOXHGCM_MEMORY_BIG:
1048            crFree( hgcm_buffer );
1049            break;
1050
1051        default:
1052            crError( "Weird buffer kind trying to free in crVBoxHGCMFree: %d", hgcm_buffer->kind );
1053    }
1054}
1055
1056static void crVBoxHGCMFree(CRConnection *conn, void *buf)
1057{
1058    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1059#ifdef CHROMIUM_THREADSAFE
1060    crLockMutex(&g_crvboxhgcm.mutex);
1061#endif
1062    _crVBoxHGCMFree(conn, buf);
1063#ifdef CHROMIUM_THREADSAFE
1064    crUnlockMutex(&g_crvboxhgcm.mutex);
1065#endif
1066    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1067}
1068
1069static void _crVBoxHGCMReceiveMessage(CRConnection *conn)
1070{
1071    uint32_t len;
1072    CRVBOXHGCMBUFFER *hgcm_buffer;
1073    CRMessage *msg;
1074    CRMessageType cached_type;
1075
1076    len = conn->cbBuffer;
1077    CRASSERT(len > 0);
1078    CRASSERT(conn->pBuffer);
1079
1080#ifndef IN_GUEST
1081    if (conn->allow_redir_ptr)
1082    {
1083#endif
1084        CRASSERT(conn->buffer_size >= sizeof(CRMessageRedirPtr));
1085
1086        hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
1087        hgcm_buffer->len = sizeof(CRMessageRedirPtr);
1088
1089        msg = (CRMessage *) (hgcm_buffer + 1);
1090
1091        msg->header.type = CR_MESSAGE_REDIR_PTR;
1092        msg->redirptr.pMessage = (CRMessageHeader*) (conn->pBuffer);
1093        msg->header.conn_id = msg->redirptr.pMessage->conn_id;
1094
1095#if defined(VBOX_WITH_CRHGSMI) && !defined(IN_GUEST)
1096        msg->redirptr.CmdData = conn->CmdData;
1097        CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(&msg->redirptr.CmdData);
1098        CRVBOXHGSMI_CMDDATA_CLEANUP(&conn->CmdData);
1099#endif
1100
1101        cached_type = msg->redirptr.pMessage->type;
1102
1103        conn->cbBuffer = 0;
1104        conn->pBuffer  = NULL;
1105#ifndef IN_GUEST
1106    }
1107    else
1108    {
1109        /* we should NEVER have redir_ptr disabled with HGSMI command now */
1110        CRASSERT(!conn->CmdData.pvCmd);
1111        if ( len <= conn->buffer_size )
1112        {
1113            /* put in pre-allocated buffer */
1114            hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
1115        }
1116        else
1117        {
1118            /* allocate new buffer,
1119             * not using pool here as it's most likely one time transfer of huge texture
1120             */
1121            hgcm_buffer            = (CRVBOXHGCMBUFFER *) crAlloc( sizeof(CRVBOXHGCMBUFFER) + len );
1122            hgcm_buffer->magic     = CR_VBOXHGCM_BUFFER_MAGIC;
1123            hgcm_buffer->kind      = CR_VBOXHGCM_MEMORY_BIG;
1124            hgcm_buffer->allocated = sizeof(CRVBOXHGCMBUFFER) + len;
1125        }
1126
1127        hgcm_buffer->len = len;
1128        _crVBoxHGCMReadBytes(conn, hgcm_buffer + 1, len);
1129
1130        msg = (CRMessage *) (hgcm_buffer + 1);
1131        cached_type = msg->header.type;
1132    }
1133#endif /* !IN_GUEST*/
1134
1135    conn->recv_credits     -= len;
1136    conn->total_bytes_recv += len;
1137    conn->recv_count++;
1138
1139    crNetDispatchMessage( g_crvboxhgcm.recv_list, conn, msg, len );
1140
1141    /* CR_MESSAGE_OPCODES is freed in crserverlib/server_stream.c with crNetFree.
1142     * OOB messages are the programmer's problem.  -- Humper 12/17/01
1143     */
1144    if (cached_type != CR_MESSAGE_OPCODES
1145        && cached_type != CR_MESSAGE_OOB
1146        && cached_type != CR_MESSAGE_GATHER)
1147    {
1148        _crVBoxHGCMFree(conn, msg);
1149    }
1150}
1151
1152static void crVBoxHGCMReceiveMessage(CRConnection *conn)
1153{
1154    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1155#ifdef CHROMIUM_THREADSAFE
1156    crLockMutex(&g_crvboxhgcm.mutex);
1157#endif
1158    _crVBoxHGCMReceiveMessage(conn);
1159#ifdef CHROMIUM_THREADSAFE
1160    crUnlockMutex(&g_crvboxhgcm.mutex);
1161#endif
1162    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1163}
1164
1165
1166/*
1167 * Called on host side only, to "accept" client connection
1168 */
1169static void crVBoxHGCMAccept( CRConnection *conn, const char *hostname, unsigned short port )
1170{
1171    RT_NOREF(hostname, port);
1172    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1173    CRASSERT(conn && conn->pHostBuffer);
1174#ifdef IN_GUEST
1175    CRASSERT(FALSE);
1176#endif
1177    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1178}
1179
1180static int crVBoxHGCMSetVersion(CRConnection *conn, unsigned int vMajor, unsigned int vMinor)
1181{
1182    CRVBOXHGCMSETVERSION parms;
1183    int rc;
1184    RT_NOREF(vMajor, vMinor);
1185
1186    VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_SET_VERSION, SHCRGL_CPARMS_SET_VERSION);
1187
1188    parms.vMajor.type      = VMMDevHGCMParmType_32bit;
1189    parms.vMajor.u.value32 = CR_PROTOCOL_VERSION_MAJOR;
1190    parms.vMinor.type      = VMMDevHGCMParmType_32bit;
1191    parms.vMinor.u.value32 = CR_PROTOCOL_VERSION_MINOR;
1192
1193    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
1194
1195    if (RT_SUCCESS(rc))
1196    {
1197        rc =  parms.hdr.Hdr.rc; /** @todo now rc == parms.hdr.Hdr.rc */
1198        if (RT_SUCCESS(rc))
1199        {
1200            conn->vMajor = CR_PROTOCOL_VERSION_MAJOR;
1201            conn->vMinor = CR_PROTOCOL_VERSION_MINOR;
1202
1203            return VINF_SUCCESS;
1204        }
1205        else
1206            WARN(("Host doesn't accept our version %d.%d. Make sure you have appropriate additions installed!",
1207                  parms.vMajor.u.value32, parms.vMinor.u.value32));
1208    }
1209    else
1210        WARN(("crVBoxHGCMCall failed %d", rc));
1211
1212    return rc;
1213}
1214
1215static int crVBoxHGCMGetHostCapsLegacy(CRConnection *conn, uint32_t *pu32HostCaps)
1216{
1217    CRVBOXHGCMGETCAPS caps;
1218    int rc;
1219
1220    VBGL_HGCM_HDR_INIT(&caps.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_GET_CAPS_LEGACY, SHCRGL_CPARMS_GET_CAPS_LEGACY);
1221
1222    caps.Caps.type       = VMMDevHGCMParmType_32bit;
1223    caps.Caps.u.value32  = 0;
1224
1225    rc = crVBoxHGCMCall(conn, &caps.hdr, sizeof(caps));
1226
1227    if (RT_SUCCESS(rc))
1228    {
1229        rc = caps.hdr.Hdr.rc;
1230        if (RT_SUCCESS(rc))
1231        {
1232            *pu32HostCaps = caps.Caps.u.value32;
1233            return VINF_SUCCESS;
1234        }
1235        else
1236            WARN(("SHCRGL_GUEST_FN_GET_CAPS failed %d", rc));
1237        return FALSE;
1238    }
1239    else
1240        WARN(("crVBoxHGCMCall failed %d", rc));
1241
1242    *pu32HostCaps = 0;
1243
1244    return rc;
1245}
1246
1247static int crVBoxHGCMSetPID(CRConnection *conn, unsigned long long pid)
1248{
1249    CRVBOXHGCMSETPID parms;
1250    int rc;
1251
1252    VBGL_HGCM_HDR_INIT(&parms.hdr, conn->u32ClientID, SHCRGL_GUEST_FN_SET_PID, SHCRGL_CPARMS_SET_PID);
1253
1254    parms.u64PID.type      = VMMDevHGCMParmType_64bit;
1255    parms.u64PID.u.value64 = pid;
1256
1257    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
1258
1259    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.Hdr.rc) /** @todo now rc == parms.hdr.Hdr.rc */)
1260    {
1261        crWarning("SHCRGL_GUEST_FN_SET_PID failed!");
1262        return FALSE;
1263    }
1264
1265    return TRUE;
1266}
1267
1268/**
1269 * The function that actually connects.  This should only be called by clients,
1270 * guests in vbox case.
1271 * Servers go through crVBoxHGCMAccept;
1272 */
1273static int crVBoxHGCMDoConnect( CRConnection *conn )
1274{
1275#ifdef IN_GUEST
1276    int rc;
1277    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1278    RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE);
1279    rc = VbglR3InitUser();
1280    if (RT_SUCCESS(rc))
1281    {
1282        uint32_t idClient;
1283        rc = VbglR3HGCMConnect("VBoxSharedCrOpenGL", &idClient);
1284        if (RT_SUCCESS(rc))
1285        {
1286            conn->u32ClientID = idClient;
1287            crDebug("HGCM connect was successful: client id =0x%x\n", conn->u32ClientID);
1288
1289            rc = crVBoxHGCMSetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
1290            if (RT_FAILURE(rc))
1291            {
1292                WARN(("crVBoxHGCMSetVersion failed %d", rc));
1293                return FALSE;
1294            }
1295#ifdef RT_OS_WINDOWS
1296            rc = crVBoxHGCMSetPID(conn, GetCurrentProcessId());
1297#else
1298            rc = crVBoxHGCMSetPID(conn, crGetPID());
1299#endif
1300            if (RT_FAILURE(rc))
1301            {
1302                WARN(("crVBoxHGCMSetPID failed %Rrc", rc));
1303                return FALSE;
1304            }
1305
1306            if (!g_crvboxhgcm.fHostCapsInitialized)
1307            {
1308                rc = crVBoxHGCMGetHostCapsLegacy(conn, &g_crvboxhgcm.u32HostCaps);
1309                if (RT_FAILURE(rc))
1310                {
1311                    WARN(("VBoxCrHgsmiCtlConGetHostCaps failed %Rrc", rc));
1312                    g_crvboxhgcm.u32HostCaps = 0;
1313                }
1314
1315                /* host may not support it, ignore any failures */
1316                g_crvboxhgcm.fHostCapsInitialized = true;
1317            }
1318
1319            if (g_crvboxhgcm.u32HostCaps & CR_VBOX_CAP_HOST_CAPS_NOT_SUFFICIENT)
1320            {
1321                crDebug("HGCM connect: insufficient host capabilities\n");
1322                g_crvboxhgcm.u32HostCaps = 0;
1323                return FALSE;
1324            }
1325
1326            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1327            return TRUE;
1328        }
1329
1330        crDebug("HGCM connect failed: %Rrc\n", rc);
1331        VbglR3Term();
1332    }
1333    else
1334        crDebug("Failed to initialize VbglR3 library: %Rrc\n", rc);
1335
1336    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1337    return FALSE;
1338
1339#else  /* !IN_GUEST */
1340    crError("crVBoxHGCMDoConnect called on host side!");
1341    CRASSERT(FALSE);
1342    return FALSE;
1343#endif /* !IN_GUEST */
1344}
1345
1346static bool _crVBoxCommonDoDisconnectLocked( CRConnection *conn )
1347{
1348    int i;
1349    if (conn->pHostBuffer)
1350    {
1351        crFree(conn->pHostBuffer);
1352        conn->pHostBuffer = NULL;
1353        conn->cbHostBuffer = 0;
1354        conn->cbHostBufferAllocated = 0;
1355    }
1356
1357    conn->pBuffer = NULL;
1358    conn->cbBuffer = 0;
1359
1360    if (conn->type == CR_VBOXHGCM)
1361    {
1362        --g_crvboxhgcm.num_conns;
1363
1364        if (conn->index < g_crvboxhgcm.num_conns)
1365        {
1366            g_crvboxhgcm.conns[conn->index] = g_crvboxhgcm.conns[g_crvboxhgcm.num_conns];
1367            g_crvboxhgcm.conns[conn->index]->index = conn->index;
1368        }
1369        else g_crvboxhgcm.conns[conn->index] = NULL;
1370
1371        conn->type = CR_NO_CONNECTION;
1372    }
1373
1374    for (i = 0; i < g_crvboxhgcm.num_conns; i++)
1375        if (g_crvboxhgcm.conns[i] && g_crvboxhgcm.conns[i]->type != CR_NO_CONNECTION)
1376            return true;
1377    return false;
1378}
1379
1380/** @todo same, replace DeviceIoControl with vbglR3DoIOCtl */
1381static void crVBoxHGCMDoDisconnect( CRConnection *conn )
1382{
1383    bool fHasActiveCons = false;
1384
1385    if (!g_crvboxhgcm.initialized) return;
1386
1387#ifdef CHROMIUM_THREADSAFE
1388    crLockMutex(&g_crvboxhgcm.mutex);
1389#endif
1390
1391    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1392
1393    fHasActiveCons = _crVBoxCommonDoDisconnectLocked(conn);
1394
1395#ifndef IN_GUEST
1396#else /* IN_GUEST */
1397    if (conn->u32ClientID)
1398    {
1399        int rc = VbglR3HGCMDisconnect(conn->u32ClientID);
1400        if (RT_FAILURE(rc))
1401            crDebug("Disconnect failed with %Rrc\n", rc);
1402        conn->u32ClientID = 0;
1403
1404        VbglR3Term();
1405    }
1406#endif /* IN_GUEST */
1407
1408    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1409
1410#ifdef CHROMIUM_THREADSAFE
1411    crUnlockMutex(&g_crvboxhgcm.mutex);
1412#endif
1413}
1414
1415static void crVBoxHGCMInstantReclaim(CRConnection *conn, CRMessage *mess)
1416{
1417    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1418#ifdef CHROMIUM_THREADSAFE
1419    crLockMutex(&g_crvboxhgcm.mutex);
1420#endif
1421    _crVBoxHGCMFree(conn, mess);
1422    CRASSERT(FALSE);
1423#ifdef CHROMIUM_THREADSAFE
1424    crUnlockMutex(&g_crvboxhgcm.mutex);
1425#endif
1426    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1427}
1428
1429static void crVBoxHGCMHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
1430{
1431    RT_NOREF(conn, msg, len);
1432    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1433    CRASSERT(FALSE);
1434    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1435}
1436
1437#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
1438
1439bool _crVBoxHGSMIInit()
1440{
1441#ifndef VBOX_CRHGSMI_WITH_D3DDEV
1442    static
1443#endif
1444    int bHasHGSMI = -1;
1445
1446    if (bHasHGSMI < 0)
1447    {
1448        int rc;
1449        rc = VBoxCrHgsmiInit();
1450        if (RT_SUCCESS(rc))
1451            bHasHGSMI = 1;
1452        else
1453            bHasHGSMI = 0;
1454
1455        crDebug("CrHgsmi is %s", bHasHGSMI ? "ENABLED" : "DISABLED");
1456    }
1457
1458    CRASSERT(bHasHGSMI >= 0);
1459
1460    return bHasHGSMI;
1461}
1462
1463void _crVBoxHGSMITearDown()
1464{
1465    VBoxCrHgsmiTerm();
1466}
1467
1468static void *_crVBoxHGSMIDoAlloc(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient)
1469{
1470    PVBOXUHGSMI_BUFFER buf;
1471    CRVBOXHGCMBUFFER *pData = NULL;
1472    uint32_t cbSize = conn->buffer_size;
1473    int rc;
1474
1475    buf = _crVBoxHGSMIBufAlloc(pClient, CRVBOXHGSMI_BUF_SIZE(cbSize));
1476    if (buf)
1477    {
1478        VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
1479        buf->pvUserData = pClient;
1480        fFlags.Value = 0;
1481        fFlags.bDiscard = 1;
1482        rc = buf->pfnLock(buf, 0, CRVBOXHGSMI_BUF_LOCK_SIZE(cbSize), fFlags, (void**)&pData);
1483        if (RT_SUCCESS(rc))
1484        {
1485            pData->magic = CR_VBOXHGCM_BUFFER_MAGIC;
1486            pData->kind = CR_VBOXHGCM_UHGSMI_BUFFER;
1487            pData->pBuffer = buf;
1488        }
1489        else
1490        {
1491            crWarning("Failed to Lock the buffer, rc(%d)\n", rc);
1492        }
1493        return CRVBOXHGSMI_BUF_DATA(pData);
1494    }
1495    else
1496    {
1497        crWarning("_crVBoxHGSMIBufAlloc failed to allocate buffer of size (%d)", CRVBOXHGSMI_BUF_SIZE(cbSize));
1498    }
1499
1500    /* fall back */
1501    return _crVBoxHGCMAlloc(conn);
1502}
1503
1504static void _crVBoxHGSMIFree(CRConnection *conn, void *buf)
1505{
1506    CRVBOXHGCMBUFFER *hgcm_buffer = (CRVBOXHGCMBUFFER *) buf - 1;
1507
1508    CRASSERT(hgcm_buffer->magic == CR_VBOXHGCM_BUFFER_MAGIC);
1509
1510    if (hgcm_buffer->kind == CR_VBOXHGCM_UHGSMI_BUFFER)
1511    {
1512        PVBOXUHGSMI_BUFFER pBuf = _crVBoxHGSMIBufFromHdr(hgcm_buffer);
1513        PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
1514        _crVBoxHGSMIBufFree(pClient, pBuf);
1515    }
1516    else
1517    {
1518        _crVBoxHGCMFree(conn, buf);
1519    }
1520}
1521
1522static void *crVBoxHGSMIAlloc(CRConnection *conn)
1523{
1524    PCRVBOXHGSMI_CLIENT pClient;
1525    void *pvBuf;
1526
1527    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1528
1529#ifdef CHROMIUM_THREADSAFE
1530    crLockMutex(&g_crvboxhgcm.mutex);
1531#endif
1532
1533    pClient = _crVBoxHGSMIClientGet(conn);
1534    if (pClient)
1535    {
1536        pvBuf = _crVBoxHGSMIDoAlloc(conn, pClient);
1537        CRASSERT(pvBuf);
1538    }
1539    else
1540    {
1541        pvBuf = _crVBoxHGCMAlloc(conn);
1542    }
1543
1544#ifdef CHROMIUM_THREADSAFE
1545    crUnlockMutex(&g_crvboxhgcm.mutex);
1546#endif
1547
1548    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1549
1550    return pvBuf;
1551}
1552
1553static void crVBoxHGSMIFree(CRConnection *conn, void *buf)
1554{
1555    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1556#ifdef CHROMIUM_THREADSAFE
1557    crLockMutex(&g_crvboxhgcm.mutex);
1558#endif
1559    _crVBoxHGSMIFree(conn, buf);
1560#ifdef CHROMIUM_THREADSAFE
1561    crUnlockMutex(&g_crvboxhgcm.mutex);
1562#endif
1563    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1564}
1565
1566static void _crVBoxHGSMIPollHost(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient)
1567{
1568    CRVBOXHGSMIREAD *parms = (CRVBOXHGSMIREAD *)_crVBoxHGSMICmdBufferLock(pClient, sizeof (*parms));
1569    int rc;
1570    VBOXUHGSMI_BUFFER_SUBMIT aSubmit[2];
1571    PVBOXUHGSMI_BUFFER pRecvBuffer;
1572    uint32_t cbBuffer;
1573
1574    CRASSERT(parms);
1575
1576    parms->hdr.result      = VERR_WRONG_ORDER;
1577    parms->hdr.u32ClientID = conn->u32ClientID;
1578    parms->hdr.u32Function = SHCRGL_GUEST_FN_READ;
1579/*    parms->hdr.u32Reserved = 0;*/
1580
1581    CRASSERT(!conn->pBuffer); /* make sure there's no data to process */
1582    parms->iBuffer = 1;
1583    parms->cbBuffer = 0;
1584
1585    _crVBoxHGSMICmdBufferUnlock(pClient);
1586
1587    pRecvBuffer = _crVBoxHGSMIRecvBufGet(pClient);
1588    CRASSERT(pRecvBuffer);
1589    if (!pRecvBuffer)
1590        return;
1591
1592    _crVBoxHGSMIFillCmd(&aSubmit[0], pClient, sizeof (*parms));
1593
1594    aSubmit[1].pBuf = pRecvBuffer;
1595    aSubmit[1].offData = 0;
1596    aSubmit[1].cbData = pRecvBuffer->cbBuffer;
1597    aSubmit[1].fFlags.Value = 0;
1598    aSubmit[1].fFlags.bHostWriteOnly = 1;
1599
1600    rc = pClient->pHgsmi->pfnBufferSubmit(pClient->pHgsmi, aSubmit, 2);
1601    if (RT_FAILURE(rc))
1602    {
1603        crError("pfnBufferSubmit failed with %d \n", rc);
1604        return;
1605    }
1606
1607    parms = (CRVBOXHGSMIREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
1608    CRASSERT(parms);
1609    if (!parms)
1610    {
1611        crWarning("_crVBoxHGSMICmdBufferLockRo failed\n");
1612        return;
1613    }
1614
1615    if (RT_SUCCESS(parms->hdr.result))
1616        cbBuffer = parms->cbBuffer;
1617    else
1618        cbBuffer = 0;
1619
1620    _crVBoxHGSMICmdBufferUnlock(pClient);
1621
1622    if (cbBuffer)
1623    {
1624        void *pvData = _crVBoxHGSMIRecvBufData(pClient, cbBuffer);
1625        CRASSERT(pvData);
1626        if (pvData)
1627        {
1628            conn->pBuffer  = pvData;
1629            conn->cbBuffer = cbBuffer;
1630        }
1631    }
1632}
1633
1634static void _crVBoxHGSMIReadExact(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient)
1635{
1636    _crVBoxHGSMIPollHost(conn, pClient);
1637
1638    if (conn->cbBuffer)
1639        _crVBoxHGCMReceiveMessage(conn);
1640}
1641
1642/* Same as crVBoxHGCMWriteExact, but combined with read of writeback data.
1643 * This halves the number of HGCM calls we do,
1644 * most likely crVBoxHGCMPollHost shouldn't be called at all now.
1645 */
1646static void
1647_crVBoxHGSMIWriteReadExact(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient, void *buf, uint32_t offBuffer, unsigned int len, bool bIsBuffer)
1648{
1649    CRVBOXHGSMIWRITEREAD *parms = (CRVBOXHGSMIWRITEREAD*)_crVBoxHGSMICmdBufferLock(pClient, sizeof (*parms));
1650    int rc;
1651    VBOXUHGSMI_BUFFER_SUBMIT aSubmit[3];
1652    PVBOXUHGSMI_BUFFER pBuf = NULL;
1653    VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
1654/*    uint32_t cbBuffer;*/
1655
1656    parms->hdr.result      = VERR_WRONG_ORDER;
1657    parms->hdr.u32ClientID = conn->u32ClientID;
1658    parms->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
1659/*    parms->hdr.u32Reserved = 0;*/
1660
1661    parms->iBuffer = 1;
1662
1663    CRASSERT(!conn->pBuffer); /* make sure there's no data to process */
1664    parms->iWriteback = 2;
1665    parms->cbWriteback = 0;
1666
1667    _crVBoxHGSMICmdBufferUnlock(pClient);
1668
1669    if (!bIsBuffer)
1670    {
1671        void *pvBuf;
1672        pBuf = _crVBoxHGSMIBufAlloc(pClient, len);
1673
1674        if (!pBuf)
1675        {
1676            /* fallback */
1677            crVBoxHGCMWriteReadExact(conn, buf, len, CR_VBOXHGCM_USERALLOCATED);
1678            return;
1679        }
1680
1681        CRASSERT(!offBuffer);
1682
1683        offBuffer = 0;
1684        fFlags.Value = 0;
1685        fFlags.bDiscard = 1;
1686        fFlags.bWriteOnly = 1;
1687        rc = pBuf->pfnLock(pBuf, 0, len, fFlags, &pvBuf);
1688        if (RT_SUCCESS(rc))
1689        {
1690            memcpy(pvBuf, buf, len);
1691            rc = pBuf->pfnUnlock(pBuf);
1692            CRASSERT(RT_SUCCESS(rc));
1693        }
1694        else
1695        {
1696            crWarning("_crVBoxHGSMIWriteReadExact: pfnUnlock failed rc %d", rc);
1697            _crVBoxHGSMIBufFree(pClient, pBuf);
1698            /* fallback */
1699            crVBoxHGCMWriteReadExact(conn, buf, len, CR_VBOXHGCM_USERALLOCATED);
1700            return;
1701        }
1702    }
1703    else
1704    {
1705        pBuf = (PVBOXUHGSMI_BUFFER)buf;
1706    }
1707
1708    do
1709    {
1710        PVBOXUHGSMI_BUFFER pRecvBuffer = _crVBoxHGSMIRecvBufGet(pClient);
1711        CRASSERT(pRecvBuffer);
1712        if (!pRecvBuffer)
1713        {
1714            break;
1715        }
1716
1717        _crVBoxHGSMIFillCmd(&aSubmit[0], pClient, sizeof (*parms));
1718
1719        aSubmit[1].pBuf = pBuf;
1720        aSubmit[1].offData = offBuffer;
1721        aSubmit[1].cbData = len;
1722        aSubmit[1].fFlags.Value = 0;
1723        aSubmit[1].fFlags.bHostReadOnly = 1;
1724
1725        aSubmit[2].pBuf = pRecvBuffer;
1726        aSubmit[2].offData = 0;
1727        aSubmit[2].cbData = pRecvBuffer->cbBuffer;
1728        aSubmit[2].fFlags.Value = 0;
1729
1730        rc = pClient->pHgsmi->pfnBufferSubmit(pClient->pHgsmi, aSubmit, 3);
1731        if (RT_FAILURE(rc))
1732        {
1733            crError("pfnBufferSubmit failed with %d \n", rc);
1734            break;
1735        }
1736
1737        parms = (CRVBOXHGSMIWRITEREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
1738        CRASSERT(parms);
1739        if (parms)
1740        {
1741            uint32_t cbWriteback = parms->cbWriteback;
1742            rc = parms->hdr.result;
1743#ifdef DEBUG_misha
1744            /* catch it here to test the buffer */
1745            Assert(RT_SUCCESS(parms->hdr.Hdr.rc) || parms->hdr.Hdr.rc == VERR_BUFFER_OVERFLOW);
1746#endif
1747            _crVBoxHGSMICmdBufferUnlock(pClient);
1748#ifdef DEBUG
1749            parms = NULL;
1750#endif
1751            if (RT_SUCCESS(rc))
1752            {
1753                if (cbWriteback)
1754                {
1755                    void *pvData = _crVBoxHGSMIRecvBufData(pClient, cbWriteback);
1756                    CRASSERT(pvData);
1757                    if (pvData)
1758                    {
1759                        conn->pBuffer  = pvData;
1760                        conn->cbBuffer = cbWriteback;
1761                        _crVBoxHGCMReceiveMessage(conn);
1762                    }
1763                }
1764            }
1765            else if (VERR_BUFFER_OVERFLOW == rc)
1766            {
1767                VBOXUHGSMI_BUFFER_TYPE_FLAGS Flags = {0};
1768                PVBOXUHGSMI_BUFFER pNewBuf;
1769                CRASSERT(!pClient->pvHGBuffer);
1770                CRASSERT(cbWriteback>pClient->pHGBuffer->cbBuffer);
1771                crDebug("Reallocating host buffer from %d to %d bytes", conn->cbHostBufferAllocated, cbWriteback);
1772
1773                rc = pClient->pHgsmi->pfnBufferCreate(pClient->pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(cbWriteback), Flags, &pNewBuf);
1774                if (RT_SUCCESS(rc))
1775                {
1776                    rc = pClient->pHGBuffer->pfnDestroy(pClient->pHGBuffer);
1777                    CRASSERT(RT_SUCCESS(rc));
1778
1779                    pClient->pHGBuffer = pNewBuf;
1780
1781                    _crVBoxHGSMIReadExact(conn, pClient/*, cbWriteback*/);
1782                }
1783                else
1784                {
1785                    crWarning("_crVBoxHGSMIWriteReadExact: pfnBufferCreate(%d) failed!", CRVBOXHGSMI_PAGE_ALIGN(cbWriteback));
1786                    if (conn->cbHostBufferAllocated < cbWriteback)
1787                    {
1788                        crFree(conn->pHostBuffer);
1789                        conn->cbHostBufferAllocated = cbWriteback;
1790                        conn->pHostBuffer = crAlloc(conn->cbHostBufferAllocated);
1791                    }
1792                    crVBoxHGCMReadExact(conn, NULL, cbWriteback);
1793                }
1794            }
1795            else
1796            {
1797                crWarning("SHCRGL_GUEST_FN_WRITE_READ (%i) failed with %x \n", len, rc);
1798            }
1799        }
1800        else
1801        {
1802            crWarning("_crVBoxHGSMICmdBufferLockRo failed\n");
1803            break;
1804        }
1805    } while (0);
1806
1807    if (!bIsBuffer)
1808        _crVBoxHGSMIBufFree(pClient, pBuf);
1809
1810    return;
1811}
1812
1813static void _crVBoxHGSMIWriteExact(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI_BUFFER pBuf, uint32_t offStart, unsigned int len)
1814{
1815    int rc;
1816    int32_t callRes = VINF_SUCCESS; /* Shut up MSC. */
1817    VBOXUHGSMI_BUFFER_SUBMIT aSubmit[2];
1818
1819#ifdef IN_GUEST
1820    if (conn->u32InjectClientID)
1821    {
1822        CRVBOXHGSMIINJECT *parms = (CRVBOXHGSMIINJECT *)_crVBoxHGSMICmdBufferLock(pClient, sizeof (*parms));
1823        CRASSERT(parms);
1824        if (!parms)
1825        {
1826            return;
1827        }
1828
1829        parms->hdr.result      = VERR_WRONG_ORDER;
1830        parms->hdr.u32ClientID = conn->u32ClientID;
1831        parms->hdr.u32Function = SHCRGL_GUEST_FN_INJECT;
1832/*        parms->hdr.u32Reserved = 0;*/
1833
1834        parms->u32ClientID = conn->u32InjectClientID;
1835
1836        parms->iBuffer = 1;
1837        _crVBoxHGSMICmdBufferUnlock(pClient);
1838
1839        _crVBoxHGSMIFillCmd(&aSubmit[0], pClient, sizeof (*parms));
1840
1841        aSubmit[1].pBuf = pBuf;
1842        aSubmit[1].offData = offStart;
1843        aSubmit[1].cbData = len;
1844        aSubmit[1].fFlags.Value = 0;
1845        aSubmit[1].fFlags.bHostReadOnly = 1;
1846
1847        rc = pClient->pHgsmi->pfnBufferSubmit(pClient->pHgsmi, aSubmit, 2);
1848        if (RT_SUCCESS(rc))
1849        {
1850            callRes = _crVBoxHGSMICmdBufferGetRc(pClient);
1851        }
1852        else
1853        {
1854            /* we can not recover at this point, report error & exit */
1855            crError("pfnBufferSubmit failed with %d \n", rc);
1856        }
1857    }
1858    else
1859#endif
1860    {
1861        CRVBOXHGSMIWRITE * parms = (CRVBOXHGSMIWRITE *)_crVBoxHGSMICmdBufferLock(pClient, sizeof (*parms));;
1862
1863        parms->hdr.result      = VERR_WRONG_ORDER;
1864        parms->hdr.u32ClientID = conn->u32ClientID;
1865        parms->hdr.u32Function = SHCRGL_GUEST_FN_WRITE;
1866/*        parms->hdr.u32Reserved = 0; */
1867
1868        parms->iBuffer = 1;
1869        _crVBoxHGSMICmdBufferUnlock(pClient);
1870
1871        _crVBoxHGSMIFillCmd(&aSubmit[0], pClient, sizeof (*parms));
1872
1873        aSubmit[1].pBuf = pBuf;
1874        aSubmit[1].offData = offStart;
1875        aSubmit[1].cbData = len;
1876        aSubmit[1].fFlags.Value = 0;
1877        aSubmit[1].fFlags.bHostReadOnly = 1;
1878
1879        rc = pClient->pHgsmi->pfnBufferSubmit(pClient->pHgsmi, aSubmit, 2);
1880        if (RT_SUCCESS(rc))
1881        {
1882            callRes = _crVBoxHGSMICmdBufferGetRc(pClient);
1883        }
1884        else
1885        {
1886            /* we can not recover at this point, report error & exit */
1887            crError("Failed to submit CrHhgsmi buffer");
1888        }
1889    }
1890
1891    if (RT_FAILURE(rc) || RT_FAILURE(callRes))
1892    {
1893        crWarning("SHCRGL_GUEST_FN_WRITE failed with %x %x\n", rc, callRes);
1894    }
1895}
1896
1897static void crVBoxHGSMISend(CRConnection *conn, void **bufp,
1898                           const void *start, unsigned int len)
1899{
1900    PCRVBOXHGSMI_CLIENT pClient;
1901    PVBOXUHGSMI_BUFFER pBuf;
1902    CRVBOXHGCMBUFFER *hgcm_buffer;
1903
1904    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
1905
1906#ifdef CHROMIUM_THREADSAFE
1907    crLockMutex(&g_crvboxhgcm.mutex);
1908#endif
1909
1910    if (!bufp) /* We're sending a user-allocated buffer. */
1911    {
1912        pClient = _crVBoxHGSMIClientGet(conn);
1913        if (pClient)
1914        {
1915#ifndef IN_GUEST
1916                /** @todo remove temp buffer allocation in unpacker */
1917                /* we're at the host side, so just store data until guest polls us */
1918                _crVBoxHGCMWriteBytes(conn, start, len);
1919#else
1920            CRASSERT(!conn->u32InjectClientID);
1921            crDebug("SHCRGL: sending userbuf with %d bytes\n", len);
1922            _crVBoxHGSMIWriteReadExact(conn, pClient, (void*)start, 0, len, false);
1923#endif
1924#ifdef CHROMIUM_THREADSAFE
1925            crUnlockMutex(&g_crvboxhgcm.mutex);
1926#endif
1927            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1928            return;
1929        }
1930
1931        /* fallback */
1932        crVBoxHGCMSend(conn, bufp, start, len);
1933#ifdef CHROMIUM_THREADSAFE
1934        crUnlockMutex(&g_crvboxhgcm.mutex);
1935#endif
1936        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1937        return;
1938    }
1939
1940    hgcm_buffer = (CRVBOXHGCMBUFFER *) *bufp - 1;
1941    CRASSERT(hgcm_buffer->magic == CR_VBOXHGCM_BUFFER_MAGIC);
1942    if (hgcm_buffer->magic != CR_VBOXHGCM_BUFFER_MAGIC)
1943    {
1944        crError("HGCM buffer magic mismatch");
1945    }
1946
1947
1948    if (hgcm_buffer->kind != CR_VBOXHGCM_UHGSMI_BUFFER)
1949    {
1950        /* fallback */
1951        crVBoxHGCMSend(conn, bufp, start, len);
1952#ifdef CHROMIUM_THREADSAFE
1953        crUnlockMutex(&g_crvboxhgcm.mutex);
1954#endif
1955        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1956        return;
1957    }
1958
1959    /* The region [start .. start + len + 1] lies within a buffer that
1960     * was allocated with crVBoxHGCMAlloc() and can be put into the free
1961     * buffer pool when we're done sending it.
1962     */
1963
1964    pBuf = _crVBoxHGSMIBufFromHdr(hgcm_buffer);
1965    CRASSERT(pBuf);
1966    if (!pBuf)
1967    {
1968        crVBoxHGCMSend(conn, bufp, start, len);
1969#ifdef CHROMIUM_THREADSAFE
1970        crUnlockMutex(&g_crvboxhgcm.mutex);
1971#endif
1972        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
1973        return;
1974    }
1975
1976    pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
1977    if (pClient != &conn->HgsmiClient)
1978    {
1979        crError("HGSMI client mismatch");
1980    }
1981
1982    /* Length would be passed as part of HGCM pointer description
1983     * No need to prepend it to the buffer
1984     */
1985#ifdef IN_GUEST
1986    if (conn->u32InjectClientID)
1987    {
1988        _crVBoxHGSMIWriteExact(conn, pClient, pBuf, CRVBOXHGSMI_BUF_OFFSET(start, *bufp) + CRVBOXHGSMI_BUF_HDR_SIZE(), len);
1989    }
1990    else
1991#endif
1992    {
1993        _crVBoxHGSMIWriteReadExact(conn, pClient, pBuf, CRVBOXHGSMI_BUF_OFFSET(start, *bufp) + CRVBOXHGSMI_BUF_HDR_SIZE(), len, true);
1994    }
1995
1996    /* Reclaim this pointer for reuse */
1997    _crVBoxHGSMIBufFree(pClient, pBuf);
1998    /* Since the buffer's now in the 'free' buffer pool, the caller can't
1999     * use it any more.  Setting bufp to NULL will make sure the caller
2000     * doesn't try to re-use the buffer.
2001     */
2002    *bufp = NULL;
2003
2004#ifdef CHROMIUM_THREADSAFE
2005    crUnlockMutex(&g_crvboxhgcm.mutex);
2006#endif
2007
2008    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2009}
2010
2011static void crVBoxHGSMIWriteExact(CRConnection *conn, const void *buf, unsigned int len)
2012{
2013    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2014
2015    CRASSERT(0);
2016
2017    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2018}
2019
2020static void crVBoxHGSMISingleRecv(CRConnection *conn, void *buf, unsigned int len)
2021{
2022    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2023
2024    CRASSERT(0);
2025
2026    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2027}
2028
2029static void crVBoxHGSMIReceiveMessage(CRConnection *conn)
2030{
2031    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2032
2033#ifdef CHROMIUM_THREADSAFE
2034    crLockMutex(&g_crvboxhgcm.mutex);
2035#endif
2036
2037    CRASSERT(0);
2038
2039    _crVBoxHGCMReceiveMessage(conn);
2040
2041#ifdef CHROMIUM_THREADSAFE
2042    crUnlockMutex(&g_crvboxhgcm.mutex);
2043#endif
2044
2045    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2046}
2047
2048/*
2049 * Called on host side only, to "accept" client connection
2050 */
2051static void crVBoxHGSMIAccept( CRConnection *conn, const char *hostname, unsigned short port )
2052{
2053    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2054    CRASSERT(0);
2055
2056    CRASSERT(conn && conn->pHostBuffer);
2057#ifdef IN_GUEST
2058    CRASSERT(FALSE);
2059#endif
2060    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2061}
2062
2063static int crVBoxHGSMIDoConnect( CRConnection *conn )
2064{
2065    PCRVBOXHGSMI_CLIENT pClient;
2066    int rc = VINF_SUCCESS;
2067
2068#ifdef CHROMIUM_THREADSAFE
2069    crLockMutex(&g_crvboxhgcm.mutex);
2070#endif
2071
2072    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2073
2074    pClient = _crVBoxHGSMIClientGet(conn);
2075    if (pClient)
2076    {
2077        rc = VBoxCrHgsmiCtlConGetClientID(pClient->pHgsmi, &conn->u32ClientID);
2078        if (RT_FAILURE(rc))
2079        {
2080            WARN(("VBoxCrHgsmiCtlConGetClientID failed %d", rc));
2081        }
2082        if (!g_crvboxhgcm.fHostCapsInitialized)
2083        {
2084            rc = VBoxCrHgsmiCtlConGetHostCaps(pClient->pHgsmi, &g_crvboxhgcm.u32HostCaps);
2085            if (RT_SUCCESS(rc))
2086            {
2087                g_crvboxhgcm.fHostCapsInitialized = true;
2088            }
2089            else
2090            {
2091                WARN(("VBoxCrHgsmiCtlConGetHostCaps failed %d", rc));
2092                g_crvboxhgcm.u32HostCaps = 0;
2093            }
2094        }
2095    }
2096    else
2097    {
2098        WARN(("_crVBoxHGSMIClientGet failed %d", rc));
2099        rc = VERR_GENERAL_FAILURE;
2100    }
2101
2102    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2103
2104#ifdef CHROMIUM_THREADSAFE
2105    crUnlockMutex(&g_crvboxhgcm.mutex);
2106#endif
2107    return RT_SUCCESS(rc);
2108}
2109
2110static void crVBoxHGSMIDoDisconnect( CRConnection *conn )
2111{
2112    bool fHasActiveCons = false;
2113
2114    if (!g_crvboxhgcm.initialized) return;
2115
2116    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2117
2118#ifdef CHROMIUM_THREADSAFE
2119    crLockMutex(&g_crvboxhgcm.mutex);
2120#endif
2121
2122    fHasActiveCons = _crVBoxCommonDoDisconnectLocked(conn);
2123
2124#ifndef VBOX_CRHGSMI_WITH_D3DDEV
2125    if (conn->HgsmiClient.pHgsmi)
2126    {
2127        PVBOXUHGSMI pHgsmi;
2128        _crVBoxHGSMIClientTerm(&conn->HgsmiClient, &pHgsmi);
2129        CRASSERT(pHgsmi);
2130        if (!conn->pExternalHgsmi)
2131            VBoxCrHgsmiDestroy(pHgsmi);
2132    }
2133#else
2134# error "port me!"
2135#endif
2136
2137    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2138
2139#ifdef CHROMIUM_THREADSAFE
2140    crUnlockMutex(&g_crvboxhgcm.mutex);
2141#endif
2142}
2143
2144static void crVBoxHGSMIInstantReclaim(CRConnection *conn, CRMessage *mess)
2145{
2146    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2147#ifdef CHROMIUM_THREADSAFE
2148    crLockMutex(&g_crvboxhgcm.mutex);
2149#endif
2150    CRASSERT(0);
2151
2152    _crVBoxHGSMIFree(conn, mess);
2153
2154#ifdef CHROMIUM_THREADSAFE
2155    crUnlockMutex(&g_crvboxhgcm.mutex);
2156#endif
2157    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2158}
2159
2160static void crVBoxHGSMIHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
2161{
2162    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2163    CRASSERT(0);
2164
2165    CRASSERT(FALSE);
2166    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2167}
2168#endif
2169
2170void crVBoxHGCMInit(CRNetReceiveFuncList *rfl, CRNetCloseFuncList *cfl, unsigned int mtu)
2171{
2172    (void) mtu;
2173
2174    g_crvboxhgcm.recv_list = rfl;
2175    g_crvboxhgcm.close_list = cfl;
2176    if (g_crvboxhgcm.initialized)
2177    {
2178        return;
2179    }
2180
2181    VBOXCRHGSMIPROFILE_INIT();
2182
2183    g_crvboxhgcm.initialized = 1;
2184
2185#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2186    g_crvboxhgcm.bHgsmiOn = _crVBoxHGSMIInit();
2187#endif
2188
2189    g_crvboxhgcm.num_conns = 0;
2190    g_crvboxhgcm.conns     = NULL;
2191
2192    /* Can't open VBox guest driver here, because it gets called for host side as well */
2193    /** @todo as we have 2 dll versions, can do it now.*/
2194
2195#ifdef RT_OS_WINDOWS
2196    g_crvboxhgcm.pDirectDraw = NULL;
2197#endif
2198
2199#ifdef CHROMIUM_THREADSAFE
2200    crInitMutex(&g_crvboxhgcm.mutex);
2201    crInitMutex(&g_crvboxhgcm.recvmutex);
2202#endif
2203    g_crvboxhgcm.bufpool = crBufferPoolInit(16);
2204
2205#ifdef IN_GUEST
2206    g_crvboxhgcm.fHostCapsInitialized = false;
2207    g_crvboxhgcm.u32HostCaps = 0;
2208#endif
2209}
2210
2211/* Callback function used to free buffer pool entries */
2212static void crVBoxHGCMBufferFree(void *data)
2213{
2214    CRVBOXHGCMBUFFER *hgcm_buffer = (CRVBOXHGCMBUFFER *) data;
2215
2216    CRASSERT(hgcm_buffer->magic == CR_VBOXHGCM_BUFFER_MAGIC);
2217
2218    switch (hgcm_buffer->kind)
2219    {
2220        case CR_VBOXHGCM_MEMORY:
2221            crDebug("crVBoxHGCMBufferFree: CR_VBOXHGCM_MEMORY: %p", hgcm_buffer);
2222            crFree( hgcm_buffer );
2223            break;
2224        case CR_VBOXHGCM_MEMORY_BIG:
2225            crDebug("crVBoxHGCMBufferFree: CR_VBOXHGCM_MEMORY_BIG: %p", hgcm_buffer);
2226            crFree( hgcm_buffer );
2227            break;
2228
2229        default:
2230            crError( "Weird buffer kind trying to free in crVBoxHGCMBufferFree: %d", hgcm_buffer->kind );
2231    }
2232}
2233
2234void crVBoxHGCMTearDown(void)
2235{
2236    int32_t i, cCons;
2237
2238    if (!g_crvboxhgcm.initialized) return;
2239
2240#ifdef CHROMIUM_THREADSAFE
2241    crLockMutex(&g_crvboxhgcm.mutex);
2242#endif
2243
2244    /* Connection count would be changed in calls to crNetDisconnect, so we have to store original value.
2245     * Walking array backwards is not a good idea as it could cause some issues if we'd disconnect clients not in the
2246     * order of their connection.
2247     */
2248    cCons = g_crvboxhgcm.num_conns;
2249    for (i=0; i<cCons; i++)
2250    {
2251        /* Note that [0] is intended, as the connections array would be shifted in each call to crNetDisconnect */
2252        crNetDisconnect(g_crvboxhgcm.conns[0]);
2253    }
2254    CRASSERT(0==g_crvboxhgcm.num_conns);
2255
2256    g_crvboxhgcm.initialized = 0;
2257
2258    if (g_crvboxhgcm.bufpool)
2259        crBufferPoolCallbackFree(g_crvboxhgcm.bufpool, crVBoxHGCMBufferFree);
2260    g_crvboxhgcm.bufpool = NULL;
2261
2262#ifdef CHROMIUM_THREADSAFE
2263    crUnlockMutex(&g_crvboxhgcm.mutex);
2264    crFreeMutex(&g_crvboxhgcm.mutex);
2265    crFreeMutex(&g_crvboxhgcm.recvmutex);
2266#endif
2267
2268    crFree(g_crvboxhgcm.conns);
2269    g_crvboxhgcm.conns = NULL;
2270
2271#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2272    if (g_crvboxhgcm.bHgsmiOn)
2273    {
2274        _crVBoxHGSMITearDown();
2275    }
2276#endif
2277
2278#ifdef RT_OS_WINDOWS
2279    if (g_crvboxhgcm.pDirectDraw)
2280    {
2281        IDirectDraw_Release(g_crvboxhgcm.pDirectDraw);
2282        g_crvboxhgcm.pDirectDraw = NULL;
2283        crDebug("DirectDraw released\n");
2284    }
2285#endif
2286}
2287
2288void crVBoxHGCMConnection(CRConnection *conn
2289#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2290        , struct VBOXUHGSMI *pHgsmi
2291#endif
2292        )
2293{
2294    int i, found = 0;
2295    int n_bytes;
2296
2297    CRASSERT(g_crvboxhgcm.initialized);
2298
2299#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2300    if (g_crvboxhgcm.bHgsmiOn)
2301    {
2302        conn->type = CR_VBOXHGCM;
2303        conn->Alloc = crVBoxHGSMIAlloc;
2304        conn->Send = crVBoxHGSMISend;
2305        conn->SendExact = crVBoxHGSMIWriteExact;
2306        conn->Recv = crVBoxHGSMISingleRecv;
2307        conn->RecvMsg = crVBoxHGSMIReceiveMessage;
2308        conn->Free = crVBoxHGSMIFree;
2309        conn->Accept = crVBoxHGSMIAccept;
2310        conn->Connect = crVBoxHGSMIDoConnect;
2311        conn->Disconnect = crVBoxHGSMIDoDisconnect;
2312        conn->InstantReclaim = crVBoxHGSMIInstantReclaim;
2313        conn->HandleNewMessage = crVBoxHGSMIHandleNewMessage;
2314        conn->pExternalHgsmi = pHgsmi;
2315    }
2316    else
2317#endif
2318    {
2319        conn->type = CR_VBOXHGCM;
2320        conn->Alloc = crVBoxHGCMAlloc;
2321        conn->Send = crVBoxHGCMSend;
2322        conn->SendExact = crVBoxHGCMWriteExact;
2323        conn->Recv = crVBoxHGCMSingleRecv;
2324        conn->RecvMsg = crVBoxHGCMReceiveMessage;
2325        conn->Free = crVBoxHGCMFree;
2326        conn->Accept = crVBoxHGCMAccept;
2327        conn->Connect = crVBoxHGCMDoConnect;
2328        conn->Disconnect = crVBoxHGCMDoDisconnect;
2329        conn->InstantReclaim = crVBoxHGCMInstantReclaim;
2330        conn->HandleNewMessage = crVBoxHGCMHandleNewMessage;
2331    }
2332    conn->sizeof_buffer_header = sizeof(CRVBOXHGCMBUFFER);
2333    conn->actual_network = 1;
2334
2335    conn->krecv_buf_size = 0;
2336
2337    conn->pBuffer = NULL;
2338    conn->cbBuffer = 0;
2339    conn->allow_redir_ptr = 1;
2340
2341    /** @todo remove this crap at all later */
2342    conn->cbHostBufferAllocated = 2*1024;
2343    conn->pHostBuffer = (uint8_t*) crAlloc(conn->cbHostBufferAllocated);
2344    CRASSERT(conn->pHostBuffer);
2345    conn->cbHostBuffer = 0;
2346
2347#if !defined(IN_GUEST)
2348    RTListInit(&conn->PendingMsgList);
2349#endif
2350
2351#ifdef CHROMIUM_THREADSAFE
2352    crLockMutex(&g_crvboxhgcm.mutex);
2353#endif
2354    /* Find a free slot */
2355    for (i = 0; i < g_crvboxhgcm.num_conns; i++) {
2356        if (g_crvboxhgcm.conns[i] == NULL) {
2357            conn->index = i;
2358            g_crvboxhgcm.conns[i] = conn;
2359            found = 1;
2360            break;
2361        }
2362    }
2363
2364    /* Realloc connection stack if we couldn't find a free slot */
2365    if (found == 0) {
2366        n_bytes = ( g_crvboxhgcm.num_conns + 1 ) * sizeof(*g_crvboxhgcm.conns);
2367        crRealloc( (void **) &g_crvboxhgcm.conns, n_bytes );
2368        conn->index = g_crvboxhgcm.num_conns;
2369        g_crvboxhgcm.conns[g_crvboxhgcm.num_conns++] = conn;
2370    }
2371#ifdef CHROMIUM_THREADSAFE
2372    crUnlockMutex(&g_crvboxhgcm.mutex);
2373#endif
2374}
2375
2376#if defined(IN_GUEST)
2377static void _crVBoxHGCMPerformPollHost(CRConnection *conn)
2378{
2379    if (conn->type == CR_NO_CONNECTION )
2380        return;
2381
2382    if (!conn->pBuffer)
2383    {
2384#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2385        PCRVBOXHGSMI_CLIENT pClient;
2386        if (g_crvboxhgcm.bHgsmiOn && !!(pClient = _crVBoxHGSMIClientGet(conn)))
2387        {
2388            _crVBoxHGSMIPollHost(conn, pClient);
2389        }
2390        else
2391#endif
2392        {
2393            crVBoxHGCMPollHost(conn);
2394        }
2395    }
2396}
2397#endif
2398
2399static void _crVBoxHGCMPerformReceiveMessage(CRConnection *conn)
2400{
2401    if ( conn->type == CR_NO_CONNECTION )
2402        return;
2403
2404    if (conn->cbBuffer>0)
2405    {
2406        _crVBoxHGCMReceiveMessage(conn);
2407    }
2408}
2409
2410#ifdef IN_GUEST
2411uint32_t crVBoxHGCMHostCapsGet(void)
2412{
2413    Assert(g_crvboxhgcm.fHostCapsInitialized);
2414    return g_crvboxhgcm.u32HostCaps;
2415}
2416#endif
2417
2418int crVBoxHGCMRecv(
2419#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2420        CRConnection *conn
2421#else
2422        void
2423#endif
2424        )
2425{
2426    int32_t i;
2427
2428    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
2429
2430#ifdef CHROMIUM_THREADSAFE
2431    crLockMutex(&g_crvboxhgcm.mutex);
2432#endif
2433
2434#ifdef IN_GUEST
2435# if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
2436    if (conn && g_crvboxhgcm.bHgsmiOn)
2437    {
2438        _crVBoxHGCMPerformPollHost(conn);
2439        _crVBoxHGCMPerformReceiveMessage(conn);
2440        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2441        return 0;
2442    }
2443# endif
2444    /* we're on guest side, poll host if it got something for us */
2445    for (i=0; i<g_crvboxhgcm.num_conns; i++)
2446    {
2447        CRConnection *conn = g_crvboxhgcm.conns[i];
2448
2449        if ( !conn  )
2450            continue;
2451
2452        _crVBoxHGCMPerformPollHost(conn);
2453    }
2454#endif
2455
2456    for (i=0; i<g_crvboxhgcm.num_conns; i++)
2457    {
2458        CRConnection *conn = g_crvboxhgcm.conns[i];
2459
2460        if ( !conn )
2461            continue;
2462
2463        _crVBoxHGCMPerformReceiveMessage(conn);
2464    }
2465
2466#ifdef CHROMIUM_THREADSAFE
2467    crUnlockMutex(&g_crvboxhgcm.mutex);
2468#endif
2469
2470    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
2471
2472    return 0;
2473}
2474
2475CRConnection** crVBoxHGCMDump( int *num )
2476{
2477    *num = g_crvboxhgcm.num_conns;
2478
2479    return g_crvboxhgcm.conns;
2480}
Note: See TracBrowser for help on using the repository browser.

www.oracle.com
Contact – Privacy policy – Terms of Use