VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/HGCM.cpp@ 63360

Last change on this file since 63360 was 62485, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 72.5 KB
Line 
1/* $Id: HGCM.cpp 62485 2016-07-22 18:36:43Z vboxsync $ */
2/** @file
3 *
4 * HGCM (Host-Guest Communication Manager)
5 */
6
7/*
8 * Copyright (C) 2006-2016 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#define LOG_GROUP_MAIN_OVERRIDE LOG_GROUP_HGCM
20#include "Logging.h"
21
22#include "HGCM.h"
23#include "HGCMThread.h"
24
25#include <VBox/err.h>
26#include <VBox/hgcmsvc.h>
27#include <VBox/vmm/ssm.h>
28#include <VBox/sup.h>
29
30#include <iprt/alloc.h>
31#include <iprt/alloca.h>
32#include <iprt/avl.h>
33#include <iprt/critsect.h>
34#include <iprt/asm.h>
35#include <iprt/ldr.h>
36#include <iprt/param.h>
37#include <iprt/path.h>
38#include <iprt/string.h>
39#include <iprt/semaphore.h>
40#include <iprt/thread.h>
41
42#include <VBox/VMMDev.h>
43
44/**
45 * A service gets one thread, which synchronously delivers messages to
46 * the service. This is good for serialization.
47 *
48 * Some services may want to process messages asynchronously, and will want
49 * a next message to be delivered, while a previous message is still being
50 * processed.
51 *
52 * The dedicated service thread delivers a next message when service
53 * returns after fetching a previous one. The service will call a message
54 * completion callback when message is actually processed. So returning
55 * from the service call means only that the service is processing message.
56 *
57 * 'Message processed' condition is indicated by service, which call the
58 * callback, even if the callback is called synchronously in the dedicated
59 * thread.
60 *
61 * This message completion callback is only valid for Call requests.
62 * Connect and Disconnect are processed synchronously by the service.
63 */
64
65
66/* The maximum allowed size of a service name in bytes. */
67#define VBOX_HGCM_SVC_NAME_MAX_BYTES 1024
68
69struct _HGCMSVCEXTHANDLEDATA
70{
71 char *pszServiceName;
72 /* The service name follows. */
73};
74
75/** Internal helper service object. HGCM code would use it to
76 * hold information about services and communicate with services.
77 * The HGCMService is an (in future) abstract class that implements
78 * common functionality. There will be derived classes for specific
79 * service types.
80 */
81
82class HGCMService
83{
84 private:
85 VBOXHGCMSVCHELPERS m_svcHelpers;
86
87 static HGCMService *sm_pSvcListHead;
88 static HGCMService *sm_pSvcListTail;
89
90 static int sm_cServices;
91
92 HGCMTHREADHANDLE m_thread;
93 friend DECLCALLBACK(void) hgcmServiceThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser);
94
95 uint32_t volatile m_u32RefCnt;
96
97 HGCMService *m_pSvcNext;
98 HGCMService *m_pSvcPrev;
99
100 char *m_pszSvcName;
101 char *m_pszSvcLibrary;
102
103 RTLDRMOD m_hLdrMod;
104 PFNVBOXHGCMSVCLOAD m_pfnLoad;
105
106 VBOXHGCMSVCFNTABLE m_fntable;
107
108 int m_cClients;
109 int m_cClientsAllocated;
110
111 uint32_t *m_paClientIds;
112
113#ifdef VBOX_WITH_CRHGSMI
114 uint32_t m_cHandleAcquires;
115#endif
116
117 HGCMSVCEXTHANDLE m_hExtension;
118
119 int loadServiceDLL(void);
120 void unloadServiceDLL(void);
121
122 /*
123 * Main HGCM thread methods.
124 */
125 int instanceCreate(const char *pszServiceLibrary, const char *pszServiceName);
126 void instanceDestroy(void);
127
128 int saveClientState(uint32_t u32ClientId, PSSMHANDLE pSSM);
129 int loadClientState(uint32_t u32ClientId, PSSMHANDLE pSSM);
130
131 HGCMService();
132 ~HGCMService() {};
133
134 static DECLCALLBACK(void) svcHlpCallComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc);
135 static DECLCALLBACK(void) svcHlpDisconnectClient(void *pvInstance, uint32_t u32ClientId);
136
137 public:
138
139 /*
140 * Main HGCM thread methods.
141 */
142 static int LoadService(const char *pszServiceLibrary, const char *pszServiceName);
143 void UnloadService(void);
144
145 static void UnloadAll(void);
146
147 static int ResolveService(HGCMService **ppsvc, const char *pszServiceName);
148 void ReferenceService(void);
149 void ReleaseService(void);
150
151 static void Reset(void);
152
153 static int SaveState(PSSMHANDLE pSSM);
154 static int LoadState(PSSMHANDLE pSSM);
155
156 int CreateAndConnectClient(uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn);
157 int DisconnectClient(uint32_t u32ClientId, bool fFromService);
158
159 int HostCall(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms);
160
161#ifdef VBOX_WITH_CRHGSMI
162 int HandleAcquired();
163 int HandleReleased();
164 int HostFastCallAsync(uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
165 void *pvCompletion);
166#endif
167
168 uint32_t SizeOfClient(void) { return m_fntable.cbClient; };
169
170 int RegisterExtension(HGCMSVCEXTHANDLE handle, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
171 void UnregisterExtension(HGCMSVCEXTHANDLE handle);
172
173 /*
174 * The service thread methods.
175 */
176
177 int GuestCall(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId,
178 uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM aParms[]);
179};
180
181
182class HGCMClient: public HGCMObject
183{
184 public:
185 HGCMClient() : HGCMObject(HGCMOBJ_CLIENT), pService(NULL),
186 pvData(NULL) {};
187 ~HGCMClient();
188
189 int Init(HGCMService *pSvc);
190
191 /** Service that the client is connected to. */
192 HGCMService *pService;
193
194 /** Client specific data. */
195 void *pvData;
196};
197
198HGCMClient::~HGCMClient()
199{
200 if (pService->SizeOfClient() > 0)
201 RTMemFree(pvData);
202}
203
204int HGCMClient::Init(HGCMService *pSvc)
205{
206 pService = pSvc;
207
208 if (pService->SizeOfClient() > 0)
209 {
210 pvData = RTMemAllocZ(pService->SizeOfClient());
211
212 if (!pvData)
213 {
214 return VERR_NO_MEMORY;
215 }
216 }
217
218 return VINF_SUCCESS;
219}
220
221
222#define HGCM_CLIENT_DATA(pService, pClient)(pClient->pvData)
223
224
225
226HGCMService *HGCMService::sm_pSvcListHead = NULL;
227HGCMService *HGCMService::sm_pSvcListTail = NULL;
228int HGCMService::sm_cServices = 0;
229
230HGCMService::HGCMService()
231 :
232 m_thread (0),
233 m_u32RefCnt (0),
234 m_pSvcNext (NULL),
235 m_pSvcPrev (NULL),
236 m_pszSvcName (NULL),
237 m_pszSvcLibrary (NULL),
238 m_hLdrMod (NIL_RTLDRMOD),
239 m_pfnLoad (NULL),
240 m_cClients (0),
241 m_cClientsAllocated (0),
242 m_paClientIds (NULL),
243#ifdef VBOX_WITH_CRHGSMI
244 m_cHandleAcquires (0),
245#endif
246 m_hExtension (NULL)
247{
248 RT_ZERO(m_fntable);
249}
250
251
252static bool g_fResetting = false;
253static bool g_fSaveState = false;
254
255
256/** Helper function to load a local service DLL.
257 *
258 * @return VBox code
259 */
260int HGCMService::loadServiceDLL(void)
261{
262 LogFlowFunc(("m_pszSvcLibrary = %s\n", m_pszSvcLibrary));
263
264 if (m_pszSvcLibrary == NULL)
265 {
266 return VERR_INVALID_PARAMETER;
267 }
268
269 RTERRINFOSTATIC ErrInfo;
270 RTErrInfoInitStatic(&ErrInfo);
271
272 int rc;
273
274 if (RTPathHasPath(m_pszSvcLibrary))
275 rc = SUPR3HardenedLdrLoadPlugIn(m_pszSvcLibrary, &m_hLdrMod, &ErrInfo.Core);
276 else
277 rc = SUPR3HardenedLdrLoadAppPriv(m_pszSvcLibrary, &m_hLdrMod, RTLDRLOAD_FLAGS_LOCAL, &ErrInfo.Core);
278
279 if (RT_SUCCESS(rc))
280 {
281 LogFlowFunc(("successfully loaded the library.\n"));
282
283 m_pfnLoad = NULL;
284
285 rc = RTLdrGetSymbol(m_hLdrMod, VBOX_HGCM_SVCLOAD_NAME, (void**)&m_pfnLoad);
286
287 if (RT_FAILURE(rc) || !m_pfnLoad)
288 {
289 Log(("HGCMService::loadServiceDLL: Error resolving the service entry point %s, rc = %d, m_pfnLoad = %p\n",
290 VBOX_HGCM_SVCLOAD_NAME, rc, m_pfnLoad));
291
292 if (RT_SUCCESS(rc))
293 {
294 /* m_pfnLoad was NULL */
295 rc = VERR_SYMBOL_NOT_FOUND;
296 }
297 }
298
299 if (RT_SUCCESS(rc))
300 {
301 RT_ZERO(m_fntable);
302
303 m_fntable.cbSize = sizeof(m_fntable);
304 m_fntable.u32Version = VBOX_HGCM_SVC_VERSION;
305 m_fntable.pHelpers = &m_svcHelpers;
306
307 rc = m_pfnLoad(&m_fntable);
308
309 LogFlowFunc(("m_pfnLoad rc = %Rrc\n", rc));
310
311 if (RT_SUCCESS(rc))
312 {
313 if ( m_fntable.pfnUnload == NULL
314 || m_fntable.pfnConnect == NULL
315 || m_fntable.pfnDisconnect == NULL
316 || m_fntable.pfnCall == NULL
317 )
318 {
319 Log(("HGCMService::loadServiceDLL: at least one of function pointers is NULL\n"));
320
321 rc = VERR_INVALID_PARAMETER;
322
323 if (m_fntable.pfnUnload)
324 {
325 m_fntable.pfnUnload(m_fntable.pvService);
326 }
327 }
328 }
329 }
330 }
331 else
332 {
333 LogRel(("HGCM: Failed to load the service library: [%s], rc = %Rrc - %s. The service will be not available.\n",
334 m_pszSvcLibrary, rc, ErrInfo.Core.pszMsg));
335 m_hLdrMod = NIL_RTLDRMOD;
336 }
337
338 if (RT_FAILURE(rc))
339 {
340 unloadServiceDLL();
341 }
342
343 return rc;
344}
345
346/** Helper function to free a local service DLL.
347 *
348 * @return VBox code
349 */
350void HGCMService::unloadServiceDLL(void)
351{
352 if (m_hLdrMod)
353 {
354 RTLdrClose(m_hLdrMod);
355 }
356
357 RT_ZERO(m_fntable);
358 m_pfnLoad = NULL;
359 m_hLdrMod = NIL_RTLDRMOD;
360}
361
362/*
363 * Messages processed by service threads. These threads only call the service entry points.
364 */
365
366#define SVC_MSG_LOAD (0) /* Load the service library and call VBOX_HGCM_SVCLOAD_NAME entry point. */
367#define SVC_MSG_UNLOAD (1) /* call pfnUnload and unload the service library. */
368#define SVC_MSG_CONNECT (2) /* pfnConnect */
369#define SVC_MSG_DISCONNECT (3) /* pfnDisconnect */
370#define SVC_MSG_GUESTCALL (4) /* pfnGuestCall */
371#define SVC_MSG_HOSTCALL (5) /* pfnHostCall */
372#define SVC_MSG_LOADSTATE (6) /* pfnLoadState. */
373#define SVC_MSG_SAVESTATE (7) /* pfnSaveState. */
374#define SVC_MSG_QUIT (8) /* Terminate the thread. */
375#define SVC_MSG_REGEXT (9) /* pfnRegisterExtension */
376#define SVC_MSG_UNREGEXT (10) /* pfnRegisterExtension */
377#ifdef VBOX_WITH_CRHGSMI
378# define SVC_MSG_HOSTFASTCALLASYNC (21) /* pfnHostCall */
379#endif
380
381class HGCMMsgSvcLoad: public HGCMMsgCore
382{
383};
384
385class HGCMMsgSvcUnload: public HGCMMsgCore
386{
387};
388
389class HGCMMsgSvcConnect: public HGCMMsgCore
390{
391 public:
392 /* client identifier */
393 uint32_t u32ClientId;
394};
395
396class HGCMMsgSvcDisconnect: public HGCMMsgCore
397{
398 public:
399 /* client identifier */
400 uint32_t u32ClientId;
401};
402
403class HGCMMsgHeader: public HGCMMsgCore
404{
405 public:
406 HGCMMsgHeader() : pCmd(NULL), pHGCMPort(NULL) {};
407
408 /* Command pointer/identifier. */
409 PVBOXHGCMCMD pCmd;
410
411 /* Port to be informed on message completion. */
412 PPDMIHGCMPORT pHGCMPort;
413};
414
415
416class HGCMMsgCall: public HGCMMsgHeader
417{
418 public:
419 /* client identifier */
420 uint32_t u32ClientId;
421
422 /* function number */
423 uint32_t u32Function;
424
425 /* number of parameters */
426 uint32_t cParms;
427
428 VBOXHGCMSVCPARM *paParms;
429};
430
431class HGCMMsgLoadSaveStateClient: public HGCMMsgCore
432{
433 public:
434 uint32_t u32ClientId;
435 PSSMHANDLE pSSM;
436};
437
438class HGCMMsgHostCallSvc: public HGCMMsgCore
439{
440 public:
441 /* function number */
442 uint32_t u32Function;
443
444 /* number of parameters */
445 uint32_t cParms;
446
447 VBOXHGCMSVCPARM *paParms;
448};
449
450class HGCMMsgSvcRegisterExtension: public HGCMMsgCore
451{
452 public:
453 /* Handle of the extension to be registered. */
454 HGCMSVCEXTHANDLE handle;
455 /* The extension entry point. */
456 PFNHGCMSVCEXT pfnExtension;
457 /* The extension pointer. */
458 void *pvExtension;
459};
460
461class HGCMMsgSvcUnregisterExtension: public HGCMMsgCore
462{
463 public:
464 /* Handle of the registered extension. */
465 HGCMSVCEXTHANDLE handle;
466};
467
468#ifdef VBOX_WITH_CRHGSMI
469class HGCMMsgHostFastCallAsyncSvc: public HGCMMsgCore
470{
471 public:
472 /* function number */
473 uint32_t u32Function;
474 /* parameter */
475 VBOXHGCMSVCPARM Param;
476 /* completion info */
477 PHGCMHOSTFASTCALLCB pfnCompletion;
478 void *pvCompletion;
479};
480#endif
481
482static HGCMMsgCore *hgcmMessageAllocSvc(uint32_t u32MsgId)
483{
484 switch (u32MsgId)
485 {
486#ifdef VBOX_WITH_CRHGSMI
487 case SVC_MSG_HOSTFASTCALLASYNC: return new HGCMMsgHostFastCallAsyncSvc();
488#endif
489 case SVC_MSG_LOAD: return new HGCMMsgSvcLoad();
490 case SVC_MSG_UNLOAD: return new HGCMMsgSvcUnload();
491 case SVC_MSG_CONNECT: return new HGCMMsgSvcConnect();
492 case SVC_MSG_DISCONNECT: return new HGCMMsgSvcDisconnect();
493 case SVC_MSG_HOSTCALL: return new HGCMMsgHostCallSvc();
494 case SVC_MSG_GUESTCALL: return new HGCMMsgCall();
495 case SVC_MSG_LOADSTATE:
496 case SVC_MSG_SAVESTATE: return new HGCMMsgLoadSaveStateClient();
497 case SVC_MSG_REGEXT: return new HGCMMsgSvcRegisterExtension();
498 case SVC_MSG_UNREGEXT: return new HGCMMsgSvcUnregisterExtension();
499 default:
500 AssertReleaseMsgFailed(("Msg id = %08X\n", u32MsgId));
501 }
502
503 return NULL;
504}
505
506/*
507 * The service thread. Loads the service library and calls the service entry points.
508 */
509DECLCALLBACK(void) hgcmServiceThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser)
510{
511 HGCMService *pSvc = (HGCMService *)pvUser;
512 AssertRelease(pSvc != NULL);
513
514 bool fQuit = false;
515
516 while (!fQuit)
517 {
518 HGCMMsgCore *pMsgCore;
519 int rc = hgcmMsgGet(ThreadHandle, &pMsgCore);
520
521 if (RT_FAILURE(rc))
522 {
523 /* The error means some serious unrecoverable problem in the hgcmMsg/hgcmThread layer. */
524 AssertMsgFailed(("%Rrc\n", rc));
525 break;
526 }
527
528 /* Cache required information to avoid unnecessary pMsgCore access. */
529 uint32_t u32MsgId = pMsgCore->MsgId();
530
531 switch (u32MsgId)
532 {
533#ifdef VBOX_WITH_CRHGSMI
534 case SVC_MSG_HOSTFASTCALLASYNC:
535 {
536 HGCMMsgHostFastCallAsyncSvc *pMsg = (HGCMMsgHostFastCallAsyncSvc *)pMsgCore;
537
538 LogFlowFunc(("SVC_MSG_HOSTFASTCALLASYNC u32Function = %d, pParm = %p\n", pMsg->u32Function, &pMsg->Param));
539
540 rc = pSvc->m_fntable.pfnHostCall(pSvc->m_fntable.pvService, pMsg->u32Function, 1, &pMsg->Param);
541 } break;
542#endif
543 case SVC_MSG_LOAD:
544 {
545 LogFlowFunc(("SVC_MSG_LOAD\n"));
546 rc = pSvc->loadServiceDLL();
547 } break;
548
549 case SVC_MSG_UNLOAD:
550 {
551 LogFlowFunc(("SVC_MSG_UNLOAD\n"));
552 if (pSvc->m_fntable.pfnUnload)
553 {
554 pSvc->m_fntable.pfnUnload(pSvc->m_fntable.pvService);
555 }
556
557 pSvc->unloadServiceDLL();
558 fQuit = true;
559 } break;
560
561 case SVC_MSG_CONNECT:
562 {
563 HGCMMsgSvcConnect *pMsg = (HGCMMsgSvcConnect *)pMsgCore;
564
565 LogFlowFunc(("SVC_MSG_CONNECT u32ClientId = %d\n", pMsg->u32ClientId));
566
567 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
568
569 if (pClient)
570 {
571 rc = pSvc->m_fntable.pfnConnect(pSvc->m_fntable.pvService, pMsg->u32ClientId,
572 HGCM_CLIENT_DATA(pSvc, pClient));
573
574 hgcmObjDereference(pClient);
575 }
576 else
577 {
578 rc = VERR_HGCM_INVALID_CLIENT_ID;
579 }
580 } break;
581
582 case SVC_MSG_DISCONNECT:
583 {
584 HGCMMsgSvcDisconnect *pMsg = (HGCMMsgSvcDisconnect *)pMsgCore;
585
586 LogFlowFunc(("SVC_MSG_DISCONNECT u32ClientId = %d\n", pMsg->u32ClientId));
587
588 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
589
590 if (pClient)
591 {
592 rc = pSvc->m_fntable.pfnDisconnect(pSvc->m_fntable.pvService, pMsg->u32ClientId,
593 HGCM_CLIENT_DATA(pSvc, pClient));
594
595 hgcmObjDereference(pClient);
596 }
597 else
598 {
599 rc = VERR_HGCM_INVALID_CLIENT_ID;
600 }
601 } break;
602
603 case SVC_MSG_GUESTCALL:
604 {
605 HGCMMsgCall *pMsg = (HGCMMsgCall *)pMsgCore;
606
607 LogFlowFunc(("SVC_MSG_GUESTCALL u32ClientId = %d, u32Function = %d, cParms = %d, paParms = %p\n",
608 pMsg->u32ClientId, pMsg->u32Function, pMsg->cParms, pMsg->paParms));
609
610 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
611
612 if (pClient)
613 {
614 pSvc->m_fntable.pfnCall(pSvc->m_fntable.pvService, (VBOXHGCMCALLHANDLE)pMsg, pMsg->u32ClientId,
615 HGCM_CLIENT_DATA(pSvc, pClient), pMsg->u32Function,
616 pMsg->cParms, pMsg->paParms);
617
618 hgcmObjDereference(pClient);
619 }
620 else
621 {
622 rc = VERR_HGCM_INVALID_CLIENT_ID;
623 }
624 } break;
625
626 case SVC_MSG_HOSTCALL:
627 {
628 HGCMMsgHostCallSvc *pMsg = (HGCMMsgHostCallSvc *)pMsgCore;
629
630 LogFlowFunc(("SVC_MSG_HOSTCALL u32Function = %d, cParms = %d, paParms = %p\n",
631 pMsg->u32Function, pMsg->cParms, pMsg->paParms));
632
633 rc = pSvc->m_fntable.pfnHostCall(pSvc->m_fntable.pvService, pMsg->u32Function, pMsg->cParms, pMsg->paParms);
634 } break;
635
636 case SVC_MSG_LOADSTATE:
637 {
638 HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)pMsgCore;
639
640 LogFlowFunc(("SVC_MSG_LOADSTATE\n"));
641
642 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
643
644 if (pClient)
645 {
646 if (pSvc->m_fntable.pfnLoadState)
647 {
648 rc = pSvc->m_fntable.pfnLoadState(pSvc->m_fntable.pvService, pMsg->u32ClientId,
649 HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
650 }
651
652 hgcmObjDereference(pClient);
653 }
654 else
655 {
656 rc = VERR_HGCM_INVALID_CLIENT_ID;
657 }
658 } break;
659
660 case SVC_MSG_SAVESTATE:
661 {
662 HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)pMsgCore;
663
664 LogFlowFunc(("SVC_MSG_SAVESTATE\n"));
665
666 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
667
668 rc = VINF_SUCCESS;
669
670 if (pClient)
671 {
672 if (pSvc->m_fntable.pfnSaveState)
673 {
674 g_fSaveState = true;
675 rc = pSvc->m_fntable.pfnSaveState(pSvc->m_fntable.pvService, pMsg->u32ClientId,
676 HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
677 g_fSaveState = false;
678 }
679
680 hgcmObjDereference(pClient);
681 }
682 else
683 {
684 rc = VERR_HGCM_INVALID_CLIENT_ID;
685 }
686 } break;
687
688 case SVC_MSG_REGEXT:
689 {
690 HGCMMsgSvcRegisterExtension *pMsg = (HGCMMsgSvcRegisterExtension *)pMsgCore;
691
692 LogFlowFunc(("SVC_MSG_REGEXT handle = %p, pfn = %p\n", pMsg->handle, pMsg->pfnExtension));
693
694 if (pSvc->m_hExtension)
695 {
696 rc = VERR_NOT_SUPPORTED;
697 }
698 else
699 {
700 if (pSvc->m_fntable.pfnRegisterExtension)
701 {
702 rc = pSvc->m_fntable.pfnRegisterExtension(pSvc->m_fntable.pvService, pMsg->pfnExtension,
703 pMsg->pvExtension);
704 }
705 else
706 {
707 rc = VERR_NOT_SUPPORTED;
708 }
709
710 if (RT_SUCCESS(rc))
711 {
712 pSvc->m_hExtension = pMsg->handle;
713 }
714 }
715 } break;
716
717 case SVC_MSG_UNREGEXT:
718 {
719 HGCMMsgSvcUnregisterExtension *pMsg = (HGCMMsgSvcUnregisterExtension *)pMsgCore;
720
721 LogFlowFunc(("SVC_MSG_UNREGEXT handle = %p\n", pMsg->handle));
722
723 if (pSvc->m_hExtension != pMsg->handle)
724 {
725 rc = VERR_NOT_SUPPORTED;
726 }
727 else
728 {
729 if (pSvc->m_fntable.pfnRegisterExtension)
730 {
731 rc = pSvc->m_fntable.pfnRegisterExtension(pSvc->m_fntable.pvService, NULL, NULL);
732 }
733 else
734 {
735 rc = VERR_NOT_SUPPORTED;
736 }
737
738 pSvc->m_hExtension = NULL;
739 }
740 } break;
741
742 default:
743 {
744 AssertMsgFailed(("hgcmServiceThread::Unsupported message number %08X\n", u32MsgId));
745 rc = VERR_NOT_SUPPORTED;
746 } break;
747 }
748
749 if (u32MsgId != SVC_MSG_GUESTCALL)
750 {
751 /* For SVC_MSG_GUESTCALL the service calls the completion helper.
752 * Other messages have to be completed here.
753 */
754 hgcmMsgComplete (pMsgCore, rc);
755 }
756 }
757}
758
759/* static */ DECLCALLBACK(void) HGCMService::svcHlpCallComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc)
760{
761 HGCMMsgCore *pMsgCore = (HGCMMsgCore *)callHandle;
762
763 if (pMsgCore->MsgId () == SVC_MSG_GUESTCALL)
764 {
765 /* Only call the completion for these messages. The helper
766 * is called by the service, and the service does not get
767 * any other messages.
768 */
769 hgcmMsgComplete(pMsgCore, rc);
770 }
771 else
772 {
773 AssertFailed();
774 }
775}
776
777/* static */ DECLCALLBACK(void) HGCMService::svcHlpDisconnectClient(void *pvInstance, uint32_t u32ClientId)
778{
779 HGCMService *pService = static_cast <HGCMService *> (pvInstance);
780
781 if (pService)
782 {
783 pService->DisconnectClient(u32ClientId, true);
784 }
785}
786
787static DECLCALLBACK(void) hgcmMsgCompletionCallback(int32_t result, HGCMMsgCore *pMsgCore)
788{
789 /* Call the VMMDev port interface to issue IRQ notification. */
790 HGCMMsgHeader *pMsgHdr = (HGCMMsgHeader *)pMsgCore;
791
792 LogFlow(("MAIN::hgcmMsgCompletionCallback: message %p\n", pMsgCore));
793
794 if (pMsgHdr->pHGCMPort && !g_fResetting)
795 {
796 pMsgHdr->pHGCMPort->pfnCompleted(pMsgHdr->pHGCMPort, g_fSaveState? VINF_HGCM_SAVE_STATE: result, pMsgHdr->pCmd);
797 }
798}
799
800/*
801 * The main HGCM methods of the service.
802 */
803
804int HGCMService::instanceCreate(const char *pszServiceLibrary, const char *pszServiceName)
805{
806 LogFlowFunc(("name %s, lib %s\n", pszServiceName, pszServiceLibrary));
807
808 /* The maximum length of the thread name, allowed by the RT is 15. */
809 char szThreadName[16];
810 if (!strncmp(pszServiceName, RT_STR_TUPLE("VBoxShared")))
811 RTStrPrintf(szThreadName, sizeof(szThreadName), "Sh%s", pszServiceName + 10);
812 else if (!strncmp(pszServiceName, RT_STR_TUPLE("VBox")))
813 RTStrCopy(szThreadName, sizeof(szThreadName), pszServiceName + 4);
814 else
815 RTStrCopy(szThreadName, sizeof(szThreadName), pszServiceName);
816
817 int rc = hgcmThreadCreate(&m_thread, szThreadName, hgcmServiceThread, this);
818
819 if (RT_SUCCESS(rc))
820 {
821 m_pszSvcName = RTStrDup(pszServiceName);
822 m_pszSvcLibrary = RTStrDup(pszServiceLibrary);
823
824 if (!m_pszSvcName || !m_pszSvcLibrary)
825 {
826 RTStrFree(m_pszSvcLibrary);
827 m_pszSvcLibrary = NULL;
828
829 RTStrFree(m_pszSvcName);
830 m_pszSvcName = NULL;
831
832 rc = VERR_NO_MEMORY;
833 }
834 else
835 {
836 /* Initialize service helpers table. */
837 m_svcHelpers.pfnCallComplete = svcHlpCallComplete;
838 m_svcHelpers.pvInstance = this;
839 m_svcHelpers.pfnDisconnectClient = svcHlpDisconnectClient;
840
841 /* Execute the load request on the service thread. */
842 HGCMMSGHANDLE hMsg;
843 rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_LOAD, hgcmMessageAllocSvc);
844
845 if (RT_SUCCESS(rc))
846 {
847 rc = hgcmMsgSend(hMsg);
848 }
849 }
850 }
851
852 if (RT_FAILURE(rc))
853 {
854 instanceDestroy();
855 }
856
857 LogFlowFunc(("rc = %Rrc\n", rc));
858 return rc;
859}
860
861void HGCMService::instanceDestroy(void)
862{
863 LogFlowFunc(("%s\n", m_pszSvcName));
864
865 HGCMMSGHANDLE hMsg;
866 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_UNLOAD, hgcmMessageAllocSvc);
867
868 if (RT_SUCCESS(rc))
869 {
870 rc = hgcmMsgSend(hMsg);
871
872 if (RT_SUCCESS(rc))
873 {
874 hgcmThreadWait(m_thread);
875 }
876 }
877
878 RTStrFree(m_pszSvcLibrary);
879 m_pszSvcLibrary = NULL;
880
881 RTStrFree(m_pszSvcName);
882 m_pszSvcName = NULL;
883}
884
885int HGCMService::saveClientState(uint32_t u32ClientId, PSSMHANDLE pSSM)
886{
887 LogFlowFunc(("%s\n", m_pszSvcName));
888
889 HGCMMSGHANDLE hMsg;
890 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_SAVESTATE, hgcmMessageAllocSvc);
891
892 if (RT_SUCCESS(rc))
893 {
894 HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
895 AssertRelease(pMsg);
896
897 pMsg->u32ClientId = u32ClientId;
898 pMsg->pSSM = pSSM;
899
900 hgcmObjDereference(pMsg);
901
902 rc = hgcmMsgSend(hMsg);
903 }
904
905 LogFlowFunc(("rc = %Rrc\n", rc));
906 return rc;
907}
908
909int HGCMService::loadClientState(uint32_t u32ClientId, PSSMHANDLE pSSM)
910{
911 LogFlowFunc(("%s\n", m_pszSvcName));
912
913 HGCMMSGHANDLE hMsg;
914 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_LOADSTATE, hgcmMessageAllocSvc);
915
916 if (RT_SUCCESS(rc))
917 {
918 HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
919
920 AssertRelease(pMsg);
921
922 pMsg->u32ClientId = u32ClientId;
923 pMsg->pSSM = pSSM;
924
925 hgcmObjDereference(pMsg);
926
927 rc = hgcmMsgSend(hMsg);
928 }
929
930 LogFlowFunc(("rc = %Rrc\n", rc));
931 return rc;
932}
933
934
935/** The method creates a service and references it.
936 *
937 * @param pszServiceLibrary The library to be loaded.
938 * @param pszServiceName The name of the service.
939 * @return VBox rc.
940 * @thread main HGCM
941 */
942/* static */ int HGCMService::LoadService(const char *pszServiceLibrary, const char *pszServiceName)
943{
944 LogFlowFunc(("lib %s, name = %s\n", pszServiceLibrary, pszServiceName));
945
946 /* Look at already loaded services to avoid double loading. */
947
948 HGCMService *pSvc;
949 int rc = HGCMService::ResolveService(&pSvc, pszServiceName);
950
951 if (RT_SUCCESS(rc))
952 {
953 /* The service is already loaded. */
954 pSvc->ReleaseService();
955 rc = VERR_HGCM_SERVICE_EXISTS;
956 }
957 else
958 {
959 /* Create the new service. */
960 pSvc = new HGCMService();
961
962 if (!pSvc)
963 {
964 rc = VERR_NO_MEMORY;
965 }
966 else
967 {
968 /* Load the library and call the initialization entry point. */
969 rc = pSvc->instanceCreate(pszServiceLibrary, pszServiceName);
970
971 if (RT_SUCCESS(rc))
972 {
973 /* Insert the just created service to list for future references. */
974 pSvc->m_pSvcNext = sm_pSvcListHead;
975 pSvc->m_pSvcPrev = NULL;
976
977 if (sm_pSvcListHead)
978 {
979 sm_pSvcListHead->m_pSvcPrev = pSvc;
980 }
981 else
982 {
983 sm_pSvcListTail = pSvc;
984 }
985
986 sm_pSvcListHead = pSvc;
987
988 sm_cServices++;
989
990 /* Reference the service (for first time) until it is unloaded on HGCM termination. */
991 AssertRelease(pSvc->m_u32RefCnt == 0);
992 pSvc->ReferenceService();
993
994 LogFlowFunc(("service %p\n", pSvc));
995 }
996 }
997 }
998
999 LogFlowFunc(("rc = %Rrc\n", rc));
1000 return rc;
1001}
1002
1003/** The method unloads a service.
1004 *
1005 * @thread main HGCM
1006 */
1007void HGCMService::UnloadService(void)
1008{
1009 LogFlowFunc(("name = %s\n", m_pszSvcName));
1010
1011 /* Remove the service from the list. */
1012 if (m_pSvcNext)
1013 {
1014 m_pSvcNext->m_pSvcPrev = m_pSvcPrev;
1015 }
1016 else
1017 {
1018 sm_pSvcListTail = m_pSvcPrev;
1019 }
1020
1021 if (m_pSvcPrev)
1022 {
1023 m_pSvcPrev->m_pSvcNext = m_pSvcNext;
1024 }
1025 else
1026 {
1027 sm_pSvcListHead = m_pSvcNext;
1028 }
1029
1030 sm_cServices--;
1031
1032 /* The service must be unloaded only if all clients were disconnected. */
1033 LogFlowFunc(("m_u32RefCnt = %d\n", m_u32RefCnt));
1034 AssertRelease(m_u32RefCnt == 1);
1035
1036 /* Now the service can be released. */
1037 ReleaseService();
1038}
1039
1040/** The method unloads all services.
1041 *
1042 * @thread main HGCM
1043 */
1044/* static */ void HGCMService::UnloadAll(void)
1045{
1046 while (sm_pSvcListHead)
1047 {
1048 sm_pSvcListHead->UnloadService();
1049 }
1050}
1051
1052/** The method obtains a referenced pointer to the service with
1053 * specified name. The caller must call ReleaseService when
1054 * the pointer is no longer needed.
1055 *
1056 * @param ppSvc Where to store the pointer to the service.
1057 * @param pszServiceName The name of the service.
1058 * @return VBox rc.
1059 * @thread main HGCM
1060 */
1061/* static */ int HGCMService::ResolveService(HGCMService **ppSvc, const char *pszServiceName)
1062{
1063 LogFlowFunc(("ppSvc = %p name = %s\n",
1064 ppSvc, pszServiceName));
1065
1066 if (!ppSvc || !pszServiceName)
1067 {
1068 return VERR_INVALID_PARAMETER;
1069 }
1070
1071 HGCMService *pSvc = sm_pSvcListHead;
1072
1073 while (pSvc)
1074 {
1075 if (strcmp(pSvc->m_pszSvcName, pszServiceName) == 0)
1076 {
1077 break;
1078 }
1079
1080 pSvc = pSvc->m_pSvcNext;
1081 }
1082
1083 LogFlowFunc(("lookup in the list is %p\n", pSvc));
1084
1085 if (pSvc == NULL)
1086 {
1087 *ppSvc = NULL;
1088 return VERR_HGCM_SERVICE_NOT_FOUND;
1089 }
1090
1091 pSvc->ReferenceService();
1092
1093 *ppSvc = pSvc;
1094
1095 return VINF_SUCCESS;
1096}
1097
1098/** The method increases reference counter.
1099 *
1100 * @thread main HGCM
1101 */
1102void HGCMService::ReferenceService(void)
1103{
1104 ASMAtomicIncU32(&m_u32RefCnt);
1105 LogFlowFunc(("[%s] m_u32RefCnt = %d\n", m_pszSvcName, m_u32RefCnt));
1106}
1107
1108/** The method dereferences a service and deletes it when no more refs.
1109 *
1110 * @thread main HGCM
1111 */
1112void HGCMService::ReleaseService(void)
1113{
1114 LogFlowFunc(("m_u32RefCnt = %d\n", m_u32RefCnt));
1115 uint32_t u32RefCnt = ASMAtomicDecU32(&m_u32RefCnt);
1116 AssertRelease(u32RefCnt != ~0U);
1117
1118 LogFlowFunc(("u32RefCnt = %d, name %s\n", u32RefCnt, m_pszSvcName));
1119
1120 if (u32RefCnt == 0)
1121 {
1122 instanceDestroy();
1123 delete this;
1124 }
1125}
1126
1127/** The method is called when the VM is being reset or terminated
1128 * and disconnects all clients from all services.
1129 *
1130 * @thread main HGCM
1131 */
1132/* static */ void HGCMService::Reset(void)
1133{
1134 g_fResetting = true;
1135
1136 HGCMService *pSvc = sm_pSvcListHead;
1137
1138 while (pSvc)
1139 {
1140 while (pSvc->m_cClients && pSvc->m_paClientIds)
1141 {
1142 LogFlowFunc(("handle %d\n", pSvc->m_paClientIds[0]));
1143 pSvc->DisconnectClient(pSvc->m_paClientIds[0], false);
1144 }
1145
1146#ifdef VBOX_WITH_CRHGSMI
1147 /* @todo: could this actually happen that the service is destroyed on ReleaseService? */
1148 HGCMService *pNextSvc = pSvc->m_pSvcNext;
1149 while (pSvc->m_cHandleAcquires)
1150 {
1151 pSvc->HandleReleased();
1152 pSvc->ReleaseService();
1153 }
1154 pSvc = pNextSvc;
1155#else
1156 pSvc = pSvc->m_pSvcNext;
1157#endif
1158 }
1159
1160 g_fResetting = false;
1161}
1162
1163/** The method saves the HGCM state.
1164 *
1165 * @param pSSM The saved state context.
1166 * @return VBox rc.
1167 * @thread main HGCM
1168 */
1169/* static */ int HGCMService::SaveState(PSSMHANDLE pSSM)
1170{
1171 /* Save the current handle count and restore afterwards to avoid client id conflicts. */
1172 int rc = SSMR3PutU32(pSSM, hgcmObjQueryHandleCount());
1173 AssertRCReturn(rc, rc);
1174
1175 LogFlowFunc(("%d services to be saved:\n", sm_cServices));
1176
1177 /* Save number of services. */
1178 rc = SSMR3PutU32(pSSM, sm_cServices);
1179 AssertRCReturn(rc, rc);
1180
1181 /* Save every service. */
1182 HGCMService *pSvc = sm_pSvcListHead;
1183
1184 while (pSvc)
1185 {
1186 LogFlowFunc(("Saving service [%s]\n", pSvc->m_pszSvcName));
1187
1188 /* Save the length of the service name. */
1189 rc = SSMR3PutU32(pSSM, (uint32_t) strlen(pSvc->m_pszSvcName) + 1);
1190 AssertRCReturn(rc, rc);
1191
1192 /* Save the name of the service. */
1193 rc = SSMR3PutStrZ(pSSM, pSvc->m_pszSvcName);
1194 AssertRCReturn(rc, rc);
1195
1196 /* Save the number of clients. */
1197 rc = SSMR3PutU32(pSSM, pSvc->m_cClients);
1198 AssertRCReturn(rc, rc);
1199
1200 /* Call the service for every client. Normally a service must not have
1201 * a global state to be saved: only per client info is relevant.
1202 * The global state of a service is configured during VM startup.
1203 */
1204 int i;
1205
1206 for (i = 0; i < pSvc->m_cClients; i++)
1207 {
1208 uint32_t u32ClientId = pSvc->m_paClientIds[i];
1209
1210 Log(("client id 0x%08X\n", u32ClientId));
1211
1212 /* Save the client id. */
1213 rc = SSMR3PutU32(pSSM, u32ClientId);
1214 AssertRCReturn(rc, rc);
1215
1216 /* Call the service, so the operation is executed by the service thread. */
1217 rc = pSvc->saveClientState(u32ClientId, pSSM);
1218 AssertRCReturn(rc, rc);
1219 }
1220
1221 pSvc = pSvc->m_pSvcNext;
1222 }
1223
1224 return VINF_SUCCESS;
1225}
1226
1227/** The method loads saved HGCM state.
1228 *
1229 * @param pSSM The saved state context.
1230 * @return VBox rc.
1231 * @thread main HGCM
1232 */
1233/* static */ int HGCMService::LoadState(PSSMHANDLE pSSM)
1234{
1235 /* Restore handle count to avoid client id conflicts. */
1236 uint32_t u32;
1237
1238 int rc = SSMR3GetU32(pSSM, &u32);
1239 AssertRCReturn(rc, rc);
1240
1241 hgcmObjSetHandleCount(u32);
1242
1243 /* Get the number of services. */
1244 uint32_t cServices;
1245
1246 rc = SSMR3GetU32(pSSM, &cServices);
1247 AssertRCReturn(rc, rc);
1248
1249 LogFlowFunc(("%d services to be restored:\n", cServices));
1250
1251 while (cServices--)
1252 {
1253 /* Get the length of the service name. */
1254 rc = SSMR3GetU32(pSSM, &u32);
1255 AssertRCReturn(rc, rc);
1256 AssertReturn(u32 <= VBOX_HGCM_SVC_NAME_MAX_BYTES, VERR_SSM_UNEXPECTED_DATA);
1257
1258 char *pszServiceName = (char *)alloca(u32);
1259
1260 /* Get the service name. */
1261 rc = SSMR3GetStrZ(pSSM, pszServiceName, u32);
1262 AssertRCReturn(rc, rc);
1263
1264 LogRel(("HGCM: restoring [%s]\n", pszServiceName));
1265
1266 /* Resolve the service instance. */
1267 HGCMService *pSvc;
1268 rc = ResolveService(&pSvc, pszServiceName);
1269 AssertLogRelMsgReturn(pSvc, ("rc=%Rrc, %s\n", rc, pszServiceName), VERR_SSM_UNEXPECTED_DATA);
1270
1271 /* Get the number of clients. */
1272 uint32_t cClients;
1273 rc = SSMR3GetU32(pSSM, &cClients);
1274 if (RT_FAILURE(rc))
1275 {
1276 pSvc->ReleaseService();
1277 AssertFailed();
1278 return rc;
1279 }
1280
1281 while (cClients--)
1282 {
1283 /* Get the client id. */
1284 uint32_t u32ClientId;
1285 rc = SSMR3GetU32(pSSM, &u32ClientId);
1286 if (RT_FAILURE(rc))
1287 {
1288 pSvc->ReleaseService();
1289 AssertFailed();
1290 return rc;
1291 }
1292
1293 /* Connect the client. */
1294 rc = pSvc->CreateAndConnectClient(NULL, u32ClientId);
1295 if (RT_FAILURE(rc))
1296 {
1297 pSvc->ReleaseService();
1298 AssertLogRelMsgFailed(("rc=%Rrc %s\n", rc, pszServiceName));
1299 return rc;
1300 }
1301
1302 /* Call the service, so the operation is executed by the service thread. */
1303 rc = pSvc->loadClientState(u32ClientId, pSSM);
1304 if (RT_FAILURE(rc))
1305 {
1306 pSvc->ReleaseService();
1307 AssertLogRelMsgFailed(("rc=%Rrc %s\n", rc, pszServiceName));
1308 return rc;
1309 }
1310 }
1311
1312 pSvc->ReleaseService();
1313 }
1314
1315 return VINF_SUCCESS;
1316}
1317
1318/* Create a new client instance and connect it to the service.
1319 *
1320 * @param pu32ClientIdOut If not NULL, then the method must generate a new handle for the client.
1321 * If NULL, use the given 'u32ClientIdIn' handle.
1322 * @param u32ClientIdIn The handle for the client, when 'pu32ClientIdOut' is NULL.
1323 * @return VBox rc.
1324 */
1325int HGCMService::CreateAndConnectClient(uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn)
1326{
1327 LogFlowFunc(("pu32ClientIdOut = %p, u32ClientIdIn = %d\n", pu32ClientIdOut, u32ClientIdIn));
1328
1329 /* Allocate a client information structure. */
1330 HGCMClient *pClient = new HGCMClient();
1331
1332 if (!pClient)
1333 {
1334 Log1WarningFunc(("Could not allocate HGCMClient!!!\n"));
1335 return VERR_NO_MEMORY;
1336 }
1337
1338 uint32_t handle;
1339
1340 if (pu32ClientIdOut != NULL)
1341 {
1342 handle = hgcmObjGenerateHandle(pClient);
1343 }
1344 else
1345 {
1346 handle = hgcmObjAssignHandle(pClient, u32ClientIdIn);
1347 }
1348
1349 LogFlowFunc(("client id = %d\n", handle));
1350
1351 AssertRelease(handle);
1352
1353 /* Initialize the HGCM part of the client. */
1354 int rc = pClient->Init(this);
1355
1356 if (RT_SUCCESS(rc))
1357 {
1358 /* Call the service. */
1359 HGCMMSGHANDLE hMsg;
1360
1361 rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_CONNECT, hgcmMessageAllocSvc);
1362
1363 if (RT_SUCCESS(rc))
1364 {
1365 HGCMMsgSvcConnect *pMsg = (HGCMMsgSvcConnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1366 AssertRelease(pMsg);
1367
1368 pMsg->u32ClientId = handle;
1369
1370 hgcmObjDereference(pMsg);
1371
1372 rc = hgcmMsgSend(hMsg);
1373
1374 if (RT_SUCCESS(rc))
1375 {
1376 /* Add the client Id to the array. */
1377 if (m_cClients == m_cClientsAllocated)
1378 {
1379 m_paClientIds = (uint32_t *)RTMemRealloc(m_paClientIds, (m_cClientsAllocated + 64) *
1380 sizeof(m_paClientIds[0]));
1381 Assert(m_paClientIds);
1382 m_cClientsAllocated += 64;
1383 }
1384
1385 m_paClientIds[m_cClients] = handle;
1386 m_cClients++;
1387 }
1388 }
1389 }
1390
1391 if (RT_FAILURE(rc))
1392 {
1393 hgcmObjDeleteHandle(handle);
1394 }
1395 else
1396 {
1397 if (pu32ClientIdOut != NULL)
1398 {
1399 *pu32ClientIdOut = handle;
1400 }
1401
1402 ReferenceService();
1403 }
1404
1405 LogFlowFunc(("rc = %Rrc\n", rc));
1406 return rc;
1407}
1408
1409/* Disconnect the client from the service and delete the client handle.
1410 *
1411 * @param u32ClientId The handle of the client.
1412 * @return VBox rc.
1413 */
1414int HGCMService::DisconnectClient(uint32_t u32ClientId, bool fFromService)
1415{
1416 int rc = VINF_SUCCESS;
1417
1418 LogFlowFunc(("client id = %d, fFromService = %d\n", u32ClientId, fFromService));
1419
1420 if (!fFromService)
1421 {
1422 /* Call the service. */
1423 HGCMMSGHANDLE hMsg;
1424
1425 rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_DISCONNECT, hgcmMessageAllocSvc);
1426
1427 if (RT_SUCCESS(rc))
1428 {
1429 HGCMMsgSvcDisconnect *pMsg = (HGCMMsgSvcDisconnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1430 AssertRelease(pMsg);
1431
1432 pMsg->u32ClientId = u32ClientId;
1433
1434 hgcmObjDereference(pMsg);
1435
1436 rc = hgcmMsgSend(hMsg);
1437 }
1438 else
1439 {
1440 LogRel(("(%d, %d) [%s] hgcmMsgAlloc(%p, SVC_MSG_DISCONNECT) failed %Rrc\n",
1441 u32ClientId, fFromService, RT_VALID_PTR(m_pszSvcName)? m_pszSvcName: "", m_thread, rc));
1442 }
1443 }
1444
1445 /* Remove the client id from the array in any case, rc does not matter. */
1446 int i;
1447
1448 for (i = 0; i < m_cClients; i++)
1449 {
1450 if (m_paClientIds[i] == u32ClientId)
1451 {
1452 m_cClients--;
1453
1454 if (m_cClients > i)
1455 {
1456 memmove (&m_paClientIds[i], &m_paClientIds[i + 1], sizeof(m_paClientIds[0]) * (m_cClients - i));
1457 }
1458
1459 /* Delete the client handle. */
1460 hgcmObjDeleteHandle(u32ClientId);
1461
1462 /* The service must be released. */
1463 ReleaseService();
1464
1465 break;
1466 }
1467 }
1468
1469 LogFlowFunc(("rc = %Rrc\n", rc));
1470 return rc;
1471}
1472
1473int HGCMService::RegisterExtension(HGCMSVCEXTHANDLE handle,
1474 PFNHGCMSVCEXT pfnExtension,
1475 void *pvExtension)
1476{
1477 LogFlowFunc(("%s\n", handle->pszServiceName));
1478
1479 /* Forward the message to the service thread. */
1480 HGCMMSGHANDLE hMsg = 0;
1481 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_REGEXT, hgcmMessageAllocSvc);
1482
1483 if (RT_SUCCESS(rc))
1484 {
1485 HGCMMsgSvcRegisterExtension *pMsg = (HGCMMsgSvcRegisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1486 AssertRelease(pMsg);
1487
1488 pMsg->handle = handle;
1489 pMsg->pfnExtension = pfnExtension;
1490 pMsg->pvExtension = pvExtension;
1491
1492 hgcmObjDereference(pMsg);
1493
1494 rc = hgcmMsgSend(hMsg);
1495 }
1496
1497 LogFlowFunc(("rc = %Rrc\n", rc));
1498 return rc;
1499}
1500
1501void HGCMService::UnregisterExtension(HGCMSVCEXTHANDLE handle)
1502{
1503 /* Forward the message to the service thread. */
1504 HGCMMSGHANDLE hMsg = 0;
1505 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_UNREGEXT, hgcmMessageAllocSvc);
1506
1507 if (RT_SUCCESS(rc))
1508 {
1509 HGCMMsgSvcUnregisterExtension *pMsg = (HGCMMsgSvcUnregisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1510 AssertRelease(pMsg);
1511
1512 pMsg->handle = handle;
1513
1514 hgcmObjDereference(pMsg);
1515
1516 rc = hgcmMsgSend(hMsg);
1517 }
1518
1519 LogFlowFunc(("rc = %Rrc\n", rc));
1520}
1521
1522/* Perform a guest call to the service.
1523 *
1524 * @param pHGCMPort The port to be used for completion confirmation.
1525 * @param pCmd The VBox HGCM context.
1526 * @param u32ClientId The client handle to be disconnected and deleted.
1527 * @param u32Function The function number.
1528 * @param cParms Number of parameters.
1529 * @param paParms Pointer to array of parameters.
1530 * @return VBox rc.
1531 */
1532int HGCMService::GuestCall(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId, uint32_t u32Function,
1533 uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1534{
1535 HGCMMSGHANDLE hMsg = 0;
1536
1537 LogFlow(("MAIN::HGCMService::Call\n"));
1538
1539 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_GUESTCALL, hgcmMessageAllocSvc);
1540
1541 if (RT_SUCCESS(rc))
1542 {
1543 HGCMMsgCall *pMsg = (HGCMMsgCall *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1544
1545 AssertRelease(pMsg);
1546
1547 pMsg->pCmd = pCmd;
1548 pMsg->pHGCMPort = pHGCMPort;
1549
1550 pMsg->u32ClientId = u32ClientId;
1551 pMsg->u32Function = u32Function;
1552 pMsg->cParms = cParms;
1553 pMsg->paParms = paParms;
1554
1555 hgcmObjDereference(pMsg);
1556
1557 rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
1558 }
1559 else
1560 {
1561 Log(("MAIN::HGCMService::Call: Message allocation failed: %Rrc\n", rc));
1562 }
1563
1564 LogFlowFunc(("rc = %Rrc\n", rc));
1565 return rc;
1566}
1567
1568/* Perform a host call the service.
1569 *
1570 * @param u32Function The function number.
1571 * @param cParms Number of parameters.
1572 * @param paParms Pointer to array of parameters.
1573 * @return VBox rc.
1574 */
1575int HGCMService::HostCall(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms)
1576{
1577 LogFlowFunc(("%s u32Function = %d, cParms = %d, paParms = %p\n",
1578 m_pszSvcName, u32Function, cParms, paParms));
1579
1580 HGCMMSGHANDLE hMsg = 0;
1581 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_HOSTCALL, hgcmMessageAllocSvc);
1582
1583 if (RT_SUCCESS(rc))
1584 {
1585 HGCMMsgHostCallSvc *pMsg = (HGCMMsgHostCallSvc *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1586 AssertRelease(pMsg);
1587
1588 pMsg->u32Function = u32Function;
1589 pMsg->cParms = cParms;
1590 pMsg->paParms = paParms;
1591
1592 hgcmObjDereference(pMsg);
1593
1594 rc = hgcmMsgSend(hMsg);
1595 }
1596
1597 LogFlowFunc(("rc = %Rrc\n", rc));
1598 return rc;
1599}
1600
1601#ifdef VBOX_WITH_CRHGSMI
1602static DECLCALLBACK(void) hgcmMsgFastCallCompletionCallback(int32_t result, HGCMMsgCore *pMsgCore)
1603{
1604 /* Call the VMMDev port interface to issue IRQ notification. */
1605 LogFlow(("MAIN::hgcmMsgFastCallCompletionCallback: message %p\n", pMsgCore));
1606
1607 HGCMMsgHostFastCallAsyncSvc *pMsg = (HGCMMsgHostFastCallAsyncSvc *)pMsgCore;
1608 if (pMsg->pfnCompletion)
1609 {
1610 pMsg->pfnCompletion(result, pMsg->u32Function, &pMsg->Param, pMsg->pvCompletion);
1611 }
1612}
1613
1614int HGCMService::HandleAcquired()
1615{
1616 ++m_cHandleAcquires;
1617 return VINF_SUCCESS;
1618}
1619
1620int HGCMService::HandleReleased()
1621{
1622 Assert(m_cHandleAcquires);
1623 if (m_cHandleAcquires)
1624 {
1625 --m_cHandleAcquires;
1626 return VINF_SUCCESS;
1627 }
1628 return VERR_INVALID_STATE;
1629}
1630
1631int HGCMService::HostFastCallAsync(uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
1632 void *pvCompletion)
1633{
1634 LogFlowFunc(("%s u32Function = %d, pParm = %p\n",
1635 m_pszSvcName, u32Function, pParm));
1636
1637 HGCMMSGHANDLE hMsg = 0;
1638 int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_HOSTFASTCALLASYNC, hgcmMessageAllocSvc);
1639
1640 if (RT_SUCCESS(rc))
1641 {
1642 HGCMMsgHostFastCallAsyncSvc *pMsg = (HGCMMsgHostFastCallAsyncSvc *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
1643 AssertRelease(pMsg);
1644
1645 pMsg->u32Function = u32Function;
1646 pMsg->Param = *pParm;
1647 pMsg->pfnCompletion = pfnCompletion;
1648 pMsg->pvCompletion = pvCompletion;
1649
1650 hgcmObjDereference(pMsg);
1651
1652 rc = hgcmMsgPost(hMsg, hgcmMsgFastCallCompletionCallback);
1653 }
1654
1655 LogFlowFunc(("rc = %Rrc\n", rc));
1656 return rc;
1657}
1658#endif
1659
1660/*
1661 * Main HGCM thread that manages services.
1662 */
1663
1664/* Messages processed by the main HGCM thread. */
1665#define HGCM_MSG_CONNECT (10) /* Connect a client to a service. */
1666#define HGCM_MSG_DISCONNECT (11) /* Disconnect the specified client id. */
1667#define HGCM_MSG_LOAD (12) /* Load the service. */
1668#define HGCM_MSG_HOSTCALL (13) /* Call the service. */
1669#define HGCM_MSG_LOADSTATE (14) /* Load saved state for the specified service. */
1670#define HGCM_MSG_SAVESTATE (15) /* Save state for the specified service. */
1671#define HGCM_MSG_RESET (16) /* Disconnect all clients from the specified service. */
1672#define HGCM_MSG_QUIT (17) /* Unload all services and terminate the thread. */
1673#define HGCM_MSG_REGEXT (18) /* Register a service extension. */
1674#define HGCM_MSG_UNREGEXT (19) /* Unregister a service extension. */
1675#ifdef VBOX_WITH_CRHGSMI
1676# define HGCM_MSG_SVCAQUIRE (30) /* Acquire a service handle (for fast host calls) */
1677# define HGCM_MSG_SVCRELEASE (31) /* Release a service */
1678#endif
1679
1680class HGCMMsgMainConnect: public HGCMMsgHeader
1681{
1682 public:
1683 /* Service name. */
1684 const char *pszServiceName;
1685 /* Where to store the client handle. */
1686 uint32_t *pu32ClientId;
1687};
1688
1689class HGCMMsgMainDisconnect: public HGCMMsgHeader
1690{
1691 public:
1692 /* Handle of the client to be disconnected. */
1693 uint32_t u32ClientId;
1694};
1695
1696class HGCMMsgMainLoad: public HGCMMsgCore
1697{
1698 public:
1699 /* Name of the library to be loaded. */
1700 const char *pszServiceLibrary;
1701 /* Name to be assigned to the service. */
1702 const char *pszServiceName;
1703};
1704
1705class HGCMMsgMainHostCall: public HGCMMsgCore
1706{
1707 public:
1708 /* Which service to call. */
1709 const char *pszServiceName;
1710 /* Function number. */
1711 uint32_t u32Function;
1712 /* Number of the function parameters. */
1713 uint32_t cParms;
1714 /* Pointer to array of the function parameters. */
1715 VBOXHGCMSVCPARM *paParms;
1716};
1717
1718class HGCMMsgMainLoadSaveState: public HGCMMsgCore
1719{
1720 public:
1721 /* SSM context. */
1722 PSSMHANDLE pSSM;
1723};
1724
1725class HGCMMsgMainReset: public HGCMMsgCore
1726{
1727};
1728
1729class HGCMMsgMainQuit: public HGCMMsgCore
1730{
1731};
1732
1733class HGCMMsgMainRegisterExtension: public HGCMMsgCore
1734{
1735 public:
1736 /* Returned handle to be used in HGCMMsgMainUnregisterExtension. */
1737 HGCMSVCEXTHANDLE *pHandle;
1738 /* Name of the service. */
1739 const char *pszServiceName;
1740 /* The extension entry point. */
1741 PFNHGCMSVCEXT pfnExtension;
1742 /* The extension pointer. */
1743 void *pvExtension;
1744};
1745
1746class HGCMMsgMainUnregisterExtension: public HGCMMsgCore
1747{
1748 public:
1749 /* Handle of the registered extension. */
1750 HGCMSVCEXTHANDLE handle;
1751};
1752
1753#ifdef VBOX_WITH_CRHGSMI
1754class HGCMMsgMainSvcAcquire: public HGCMMsgCore
1755{
1756 public:
1757 /* Which service to call. */
1758 const char *pszServiceName;
1759 /* Returned service. */
1760 HGCMService *pService;
1761};
1762
1763class HGCMMsgMainSvcRelease: public HGCMMsgCore
1764{
1765 public:
1766 /* Svc . */
1767 HGCMService *pService;
1768};
1769#endif
1770
1771
1772static HGCMMsgCore *hgcmMainMessageAlloc (uint32_t u32MsgId)
1773{
1774 switch (u32MsgId)
1775 {
1776 case HGCM_MSG_CONNECT: return new HGCMMsgMainConnect();
1777 case HGCM_MSG_DISCONNECT: return new HGCMMsgMainDisconnect();
1778 case HGCM_MSG_LOAD: return new HGCMMsgMainLoad();
1779 case HGCM_MSG_HOSTCALL: return new HGCMMsgMainHostCall();
1780 case HGCM_MSG_LOADSTATE:
1781 case HGCM_MSG_SAVESTATE: return new HGCMMsgMainLoadSaveState();
1782 case HGCM_MSG_RESET: return new HGCMMsgMainReset();
1783 case HGCM_MSG_QUIT: return new HGCMMsgMainQuit();
1784 case HGCM_MSG_REGEXT: return new HGCMMsgMainRegisterExtension();
1785 case HGCM_MSG_UNREGEXT: return new HGCMMsgMainUnregisterExtension();
1786#ifdef VBOX_WITH_CRHGSMI
1787 case HGCM_MSG_SVCAQUIRE: return new HGCMMsgMainSvcAcquire();
1788 case HGCM_MSG_SVCRELEASE: return new HGCMMsgMainSvcRelease();
1789#endif
1790
1791 default:
1792 AssertReleaseMsgFailed(("Msg id = %08X\n", u32MsgId));
1793 }
1794
1795 return NULL;
1796}
1797
1798
1799/* The main HGCM thread handler. */
1800static DECLCALLBACK(void) hgcmThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser)
1801{
1802 LogFlowFunc(("ThreadHandle = %p, pvUser = %p\n",
1803 ThreadHandle, pvUser));
1804
1805 NOREF(pvUser);
1806
1807 bool fQuit = false;
1808
1809 while (!fQuit)
1810 {
1811 HGCMMsgCore *pMsgCore;
1812 int rc = hgcmMsgGet(ThreadHandle, &pMsgCore);
1813
1814 if (RT_FAILURE(rc))
1815 {
1816 /* The error means some serious unrecoverable problem in the hgcmMsg/hgcmThread layer. */
1817 AssertMsgFailed(("%Rrc\n", rc));
1818 break;
1819 }
1820
1821 uint32_t u32MsgId = pMsgCore->MsgId();
1822
1823 switch (u32MsgId)
1824 {
1825 case HGCM_MSG_CONNECT:
1826 {
1827 HGCMMsgMainConnect *pMsg = (HGCMMsgMainConnect *)pMsgCore;
1828
1829 LogFlowFunc(("HGCM_MSG_CONNECT pszServiceName %s, pu32ClientId %p\n",
1830 pMsg->pszServiceName, pMsg->pu32ClientId));
1831
1832 /* Resolve the service name to the pointer to service instance.
1833 */
1834 HGCMService *pService;
1835 rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
1836
1837 if (RT_SUCCESS(rc))
1838 {
1839 /* Call the service instance method. */
1840 rc = pService->CreateAndConnectClient(pMsg->pu32ClientId, 0);
1841
1842 /* Release the service after resolve. */
1843 pService->ReleaseService();
1844 }
1845 } break;
1846
1847 case HGCM_MSG_DISCONNECT:
1848 {
1849 HGCMMsgMainDisconnect *pMsg = (HGCMMsgMainDisconnect *)pMsgCore;
1850
1851 LogFlowFunc(("HGCM_MSG_DISCONNECT u32ClientId = %d\n",
1852 pMsg->u32ClientId));
1853
1854 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
1855
1856 if (!pClient)
1857 {
1858 rc = VERR_HGCM_INVALID_CLIENT_ID;
1859 break;
1860 }
1861
1862 /* The service the client belongs to. */
1863 HGCMService *pService = pClient->pService;
1864
1865 /* Call the service instance to disconnect the client. */
1866 rc = pService->DisconnectClient(pMsg->u32ClientId, false);
1867
1868 hgcmObjDereference(pClient);
1869 } break;
1870
1871 case HGCM_MSG_LOAD:
1872 {
1873 HGCMMsgMainLoad *pMsg = (HGCMMsgMainLoad *)pMsgCore;
1874
1875 LogFlowFunc(("HGCM_MSG_LOAD pszServiceName = %s, pMsg->pszServiceLibrary = %s\n",
1876 pMsg->pszServiceName, pMsg->pszServiceLibrary));
1877
1878 rc = HGCMService::LoadService(pMsg->pszServiceLibrary, pMsg->pszServiceName);
1879 } break;
1880
1881 case HGCM_MSG_HOSTCALL:
1882 {
1883 HGCMMsgMainHostCall *pMsg = (HGCMMsgMainHostCall *)pMsgCore;
1884
1885 LogFlowFunc(("HGCM_MSG_HOSTCALL pszServiceName %s, u32Function %d, cParms %d, paParms %p\n",
1886 pMsg->pszServiceName, pMsg->u32Function, pMsg->cParms, pMsg->paParms));
1887
1888 /* Resolve the service name to the pointer to service instance. */
1889 HGCMService *pService;
1890 rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
1891
1892 if (RT_SUCCESS(rc))
1893 {
1894 rc = pService->HostCall(pMsg->u32Function, pMsg->cParms, pMsg->paParms);
1895
1896 pService->ReleaseService();
1897 }
1898 } break;
1899
1900#ifdef VBOX_WITH_CRHGSMI
1901 case HGCM_MSG_SVCAQUIRE:
1902 {
1903 HGCMMsgMainSvcAcquire *pMsg = (HGCMMsgMainSvcAcquire *)pMsgCore;
1904
1905 LogFlowFunc(("HGCM_MSG_SVCAQUIRE pszServiceName %s\n", pMsg->pszServiceName));
1906
1907 /* Resolve the service name to the pointer to service instance. */
1908 HGCMService *pService;
1909 rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
1910 if (RT_SUCCESS(rc))
1911 {
1912 rc = pService->HandleAcquired();
1913 if (RT_SUCCESS(rc))
1914 {
1915 pMsg->pService = pService;
1916 }
1917 else
1918 {
1919 pService->ReleaseService();
1920 }
1921 }
1922 } break;
1923
1924 case HGCM_MSG_SVCRELEASE:
1925 {
1926 HGCMMsgMainSvcRelease *pMsg = (HGCMMsgMainSvcRelease *)pMsgCore;
1927
1928 LogFlowFunc(("HGCM_MSG_SVCARELEASE pService %p\n", pMsg->pService));
1929
1930 /* Resolve the service name to the pointer to service instance. */
1931
1932 rc = pMsg->pService->HandleReleased();
1933 if (RT_SUCCESS(rc))
1934 {
1935 pMsg->pService->ReleaseService();
1936 }
1937 } break;
1938#endif
1939
1940 case HGCM_MSG_RESET:
1941 {
1942 LogFlowFunc(("HGCM_MSG_RESET\n"));
1943
1944 HGCMService::Reset();
1945 } break;
1946
1947 case HGCM_MSG_LOADSTATE:
1948 {
1949 HGCMMsgMainLoadSaveState *pMsg = (HGCMMsgMainLoadSaveState *)pMsgCore;
1950
1951 LogFlowFunc(("HGCM_MSG_LOADSTATE\n"));
1952
1953 rc = HGCMService::LoadState(pMsg->pSSM);
1954 } break;
1955
1956 case HGCM_MSG_SAVESTATE:
1957 {
1958 HGCMMsgMainLoadSaveState *pMsg = (HGCMMsgMainLoadSaveState *)pMsgCore;
1959
1960 LogFlowFunc(("HGCM_MSG_SAVESTATE\n"));
1961
1962 rc = HGCMService::SaveState(pMsg->pSSM);
1963 } break;
1964
1965 case HGCM_MSG_QUIT:
1966 {
1967 LogFlowFunc(("HGCM_MSG_QUIT\n"));
1968
1969 HGCMService::UnloadAll();
1970
1971 fQuit = true;
1972 } break;
1973
1974 case HGCM_MSG_REGEXT:
1975 {
1976 HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)pMsgCore;
1977
1978 LogFlowFunc(("HGCM_MSG_REGEXT\n"));
1979
1980 /* Allocate the handle data. */
1981 HGCMSVCEXTHANDLE handle = (HGCMSVCEXTHANDLE)RTMemAllocZ(sizeof(struct _HGCMSVCEXTHANDLEDATA)
1982 + strlen(pMsg->pszServiceName)
1983 + sizeof(char));
1984
1985 if (handle == NULL)
1986 {
1987 rc = VERR_NO_MEMORY;
1988 }
1989 else
1990 {
1991 handle->pszServiceName = (char *)((uint8_t *)handle + sizeof(struct _HGCMSVCEXTHANDLEDATA));
1992 strcpy(handle->pszServiceName, pMsg->pszServiceName);
1993
1994 HGCMService *pService;
1995 rc = HGCMService::ResolveService(&pService, handle->pszServiceName);
1996
1997 if (RT_SUCCESS(rc))
1998 {
1999 pService->RegisterExtension(handle, pMsg->pfnExtension, pMsg->pvExtension);
2000
2001 pService->ReleaseService();
2002 }
2003
2004 if (RT_FAILURE(rc))
2005 {
2006 RTMemFree(handle);
2007 }
2008 else
2009 {
2010 *pMsg->pHandle = handle;
2011 }
2012 }
2013 } break;
2014
2015 case HGCM_MSG_UNREGEXT:
2016 {
2017 HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)pMsgCore;
2018
2019 LogFlowFunc(("HGCM_MSG_UNREGEXT\n"));
2020
2021 HGCMService *pService;
2022 rc = HGCMService::ResolveService(&pService, pMsg->handle->pszServiceName);
2023
2024 if (RT_SUCCESS(rc))
2025 {
2026 pService->UnregisterExtension(pMsg->handle);
2027
2028 pService->ReleaseService();
2029 }
2030
2031 RTMemFree(pMsg->handle);
2032 } break;
2033
2034 default:
2035 {
2036 AssertMsgFailed(("hgcmThread: Unsupported message number %08X!!!\n", u32MsgId));
2037 rc = VERR_NOT_SUPPORTED;
2038 } break;
2039 }
2040
2041 /* Complete the message processing. */
2042 hgcmMsgComplete(pMsgCore, rc);
2043
2044 LogFlowFunc(("message processed %Rrc\n", rc));
2045 }
2046}
2047
2048
2049/*
2050 * The HGCM API.
2051 */
2052
2053/* The main hgcm thread. */
2054static HGCMTHREADHANDLE g_hgcmThread = 0;
2055
2056/*
2057 * Public HGCM functions.
2058 *
2059 * hgcmGuest* - called as a result of the guest HGCM requests.
2060 * hgcmHost* - called by the host.
2061 */
2062
2063/* Load a HGCM service from the specified library.
2064 * Assign the specified name to the service.
2065 *
2066 * @param pszServiceLibrary The library to be loaded.
2067 * @param pszServiceName The name to be assigned to the service.
2068 * @return VBox rc.
2069 */
2070int HGCMHostLoad(const char *pszServiceLibrary,
2071 const char *pszServiceName)
2072{
2073 LogFlowFunc(("lib = %s, name = %s\n", pszServiceLibrary, pszServiceName));
2074
2075 if (!pszServiceLibrary || !pszServiceName)
2076 {
2077 return VERR_INVALID_PARAMETER;
2078 }
2079
2080 /* Forward the request to the main hgcm thread. */
2081 HGCMMSGHANDLE hMsg = 0;
2082
2083 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_LOAD, hgcmMainMessageAlloc);
2084
2085 if (RT_SUCCESS(rc))
2086 {
2087 /* Initialize the message. Since the message is synchronous, use the supplied pointers. */
2088 HGCMMsgMainLoad *pMsg = (HGCMMsgMainLoad *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2089 AssertRelease(pMsg);
2090
2091 pMsg->pszServiceLibrary = pszServiceLibrary;
2092 pMsg->pszServiceName = pszServiceName;
2093
2094 hgcmObjDereference(pMsg);
2095
2096 rc = hgcmMsgSend(hMsg);
2097 }
2098
2099 LogFlowFunc(("rc = %Rrc\n", rc));
2100 return rc;
2101}
2102
2103/* Register a HGCM service extension.
2104 *
2105 * @param pHandle Returned handle for the registered extension.
2106 * @param pszServiceName The name of the service.
2107 * @param pfnExtension The extension entry point (callback).
2108 * @param pvExtension The extension pointer.
2109 * @return VBox rc.
2110 */
2111int HGCMHostRegisterServiceExtension(HGCMSVCEXTHANDLE *pHandle,
2112 const char *pszServiceName,
2113 PFNHGCMSVCEXT pfnExtension,
2114 void *pvExtension)
2115{
2116 LogFlowFunc(("pHandle = %p, name = %s, pfn = %p, rv = %p\n", pHandle, pszServiceName, pfnExtension, pvExtension));
2117
2118 if (!pHandle || !pszServiceName || !pfnExtension)
2119 {
2120 return VERR_INVALID_PARAMETER;
2121 }
2122
2123 /* Forward the request to the main hgcm thread. */
2124 HGCMMSGHANDLE hMsg = 0;
2125
2126 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_REGEXT, hgcmMainMessageAlloc);
2127
2128 if (RT_SUCCESS(rc))
2129 {
2130 /* Initialize the message. Since the message is synchronous, use the supplied pointers. */
2131 HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2132 AssertRelease(pMsg);
2133
2134 pMsg->pHandle = pHandle;
2135 pMsg->pszServiceName = pszServiceName;
2136 pMsg->pfnExtension = pfnExtension;
2137 pMsg->pvExtension = pvExtension;
2138
2139 hgcmObjDereference(pMsg);
2140
2141 rc = hgcmMsgSend(hMsg);
2142 }
2143
2144 LogFlowFunc(("*pHandle = %p, rc = %Rrc\n", *pHandle, rc));
2145 return rc;
2146}
2147
2148void HGCMHostUnregisterServiceExtension(HGCMSVCEXTHANDLE handle)
2149{
2150 LogFlowFunc(("handle = %p\n", handle));
2151
2152 /* Forward the request to the main hgcm thread. */
2153 HGCMMSGHANDLE hMsg = 0;
2154
2155 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_UNREGEXT, hgcmMainMessageAlloc);
2156
2157 if (RT_SUCCESS(rc))
2158 {
2159 /* Initialize the message. */
2160 HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2161 AssertRelease(pMsg);
2162
2163 pMsg->handle = handle;
2164
2165 hgcmObjDereference(pMsg);
2166
2167 rc = hgcmMsgSend(hMsg);
2168 }
2169
2170 LogFlowFunc(("rc = %Rrc\n", rc));
2171 return;
2172}
2173
2174/* Find a service and inform it about a client connection, create a client handle.
2175 *
2176 * @param pHGCMPort The port to be used for completion confirmation.
2177 * @param pCmd The VBox HGCM context.
2178 * @param pszServiceName The name of the service to be connected to.
2179 * @param pu32ClientId Where the store the created client handle.
2180 * @return VBox rc.
2181 */
2182int HGCMGuestConnect(PPDMIHGCMPORT pHGCMPort,
2183 PVBOXHGCMCMD pCmd,
2184 const char *pszServiceName,
2185 uint32_t *pu32ClientId)
2186{
2187 LogFlowFunc(("pHGCMPort = %p, pCmd = %p, name = %s, pu32ClientId = %p\n",
2188 pHGCMPort, pCmd, pszServiceName, pu32ClientId));
2189
2190 if (pHGCMPort == NULL || pCmd == NULL || pszServiceName == NULL || pu32ClientId == NULL)
2191 {
2192 return VERR_INVALID_PARAMETER;
2193 }
2194
2195 /* Forward the request to the main hgcm thread. */
2196 HGCMMSGHANDLE hMsg = 0;
2197
2198 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_CONNECT, hgcmMainMessageAlloc);
2199
2200 if (RT_SUCCESS(rc))
2201 {
2202 /* Initialize the message. Since 'pszServiceName' and 'pu32ClientId'
2203 * will not be deallocated by the caller until the message is completed,
2204 * use the supplied pointers.
2205 */
2206 HGCMMsgMainConnect *pMsg = (HGCMMsgMainConnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2207 AssertRelease(pMsg);
2208
2209 pMsg->pHGCMPort = pHGCMPort;
2210 pMsg->pCmd = pCmd;
2211 pMsg->pszServiceName = pszServiceName;
2212 pMsg->pu32ClientId = pu32ClientId;
2213
2214 hgcmObjDereference(pMsg);
2215
2216 rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
2217 }
2218
2219 LogFlowFunc(("rc = %Rrc\n", rc));
2220 return rc;
2221}
2222
2223/* Tell a service that the client is disconnecting, destroy the client handle.
2224 *
2225 * @param pHGCMPort The port to be used for completion confirmation.
2226 * @param pCmd The VBox HGCM context.
2227 * @param u32ClientId The client handle to be disconnected and deleted.
2228 * @return VBox rc.
2229 */
2230int HGCMGuestDisconnect(PPDMIHGCMPORT pHGCMPort,
2231 PVBOXHGCMCMD pCmd,
2232 uint32_t u32ClientId)
2233{
2234 LogFlowFunc(("pHGCMPort = %p, pCmd = %p, u32ClientId = %d\n",
2235 pHGCMPort, pCmd, u32ClientId));
2236
2237 if (!pHGCMPort || !pCmd || !u32ClientId)
2238 {
2239 return VERR_INVALID_PARAMETER;
2240 }
2241
2242 /* Forward the request to the main hgcm thread. */
2243 HGCMMSGHANDLE hMsg = 0;
2244
2245 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_DISCONNECT, hgcmMainMessageAlloc);
2246
2247 if (RT_SUCCESS(rc))
2248 {
2249 /* Initialize the message. */
2250 HGCMMsgMainDisconnect *pMsg = (HGCMMsgMainDisconnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2251 AssertRelease(pMsg);
2252
2253 pMsg->pCmd = pCmd;
2254 pMsg->pHGCMPort = pHGCMPort;
2255 pMsg->u32ClientId = u32ClientId;
2256
2257 hgcmObjDereference(pMsg);
2258
2259 rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
2260 }
2261
2262 LogFlowFunc(("rc = %Rrc\n", rc));
2263 return rc;
2264}
2265
2266/* Helper to send either HGCM_MSG_SAVESTATE or HGCM_MSG_LOADSTATE messages to the main HGCM thread.
2267 *
2268 * @param pSSM The SSM handle.
2269 * @param u32MsgId The message to be sent: HGCM_MSG_SAVESTATE or HGCM_MSG_LOADSTATE.
2270 * @return VBox rc.
2271 */
2272static int hgcmHostLoadSaveState(PSSMHANDLE pSSM,
2273 uint32_t u32MsgId)
2274{
2275 LogFlowFunc(("pSSM = %p, u32MsgId = %d\n", pSSM, u32MsgId));
2276
2277 HGCMMSGHANDLE hMsg = 0;
2278
2279 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, u32MsgId, hgcmMainMessageAlloc);
2280
2281 if (RT_SUCCESS(rc))
2282 {
2283 HGCMMsgMainLoadSaveState *pMsg = (HGCMMsgMainLoadSaveState *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2284 AssertRelease(pMsg);
2285
2286 pMsg->pSSM = pSSM;
2287
2288 hgcmObjDereference(pMsg);
2289
2290 rc = hgcmMsgSend(hMsg);
2291 }
2292
2293 LogFlowFunc(("rc = %Rrc\n", rc));
2294 return rc;
2295}
2296
2297/* Save the state of services.
2298 *
2299 * @param pSSM The SSM handle.
2300 * @return VBox rc.
2301 */
2302int HGCMHostSaveState(PSSMHANDLE pSSM)
2303{
2304 return hgcmHostLoadSaveState(pSSM, HGCM_MSG_SAVESTATE);
2305}
2306
2307/* Load the state of services.
2308 *
2309 * @param pSSM The SSM handle.
2310 * @return VBox rc.
2311 */
2312int HGCMHostLoadState(PSSMHANDLE pSSM)
2313{
2314 return hgcmHostLoadSaveState(pSSM, HGCM_MSG_LOADSTATE);
2315}
2316
2317/* The guest calls the service.
2318 *
2319 * @param pHGCMPort The port to be used for completion confirmation.
2320 * @param pCmd The VBox HGCM context.
2321 * @param u32ClientId The client handle to be disconnected and deleted.
2322 * @param u32Function The function number.
2323 * @param cParms Number of parameters.
2324 * @param paParms Pointer to array of parameters.
2325 * @return VBox rc.
2326 */
2327int HGCMGuestCall(PPDMIHGCMPORT pHGCMPort,
2328 PVBOXHGCMCMD pCmd,
2329 uint32_t u32ClientId,
2330 uint32_t u32Function,
2331 uint32_t cParms,
2332 VBOXHGCMSVCPARM *paParms)
2333{
2334 LogFlowFunc(("pHGCMPort = %p, pCmd = %p, u32ClientId = %d, u32Function = %d, cParms = %d, paParms = %p\n",
2335 pHGCMPort, pCmd, u32ClientId, u32Function, cParms, paParms));
2336
2337 if (!pHGCMPort || !pCmd || u32ClientId == 0)
2338 {
2339 return VERR_INVALID_PARAMETER;
2340 }
2341
2342 int rc = VERR_HGCM_INVALID_CLIENT_ID;
2343
2344 /* Resolve the client handle to the client instance pointer. */
2345 HGCMClient *pClient = (HGCMClient *)hgcmObjReference(u32ClientId, HGCMOBJ_CLIENT);
2346
2347 if (pClient)
2348 {
2349 AssertRelease(pClient->pService);
2350
2351 /* Forward the message to the service thread. */
2352 rc = pClient->pService->GuestCall(pHGCMPort, pCmd, u32ClientId, u32Function, cParms, paParms);
2353
2354 hgcmObjDereference(pClient);
2355 }
2356
2357 LogFlowFunc(("rc = %Rrc\n", rc));
2358 return rc;
2359}
2360
2361/* The host calls the service.
2362 *
2363 * @param pszServiceName The service name to be called.
2364 * @param u32Function The function number.
2365 * @param cParms Number of parameters.
2366 * @param paParms Pointer to array of parameters.
2367 * @return VBox rc.
2368 */
2369int HGCMHostCall(const char *pszServiceName,
2370 uint32_t u32Function,
2371 uint32_t cParms,
2372 VBOXHGCMSVCPARM *paParms)
2373{
2374 LogFlowFunc(("name = %s, u32Function = %d, cParms = %d, paParms = %p\n",
2375 pszServiceName, u32Function, cParms, paParms));
2376
2377 if (!pszServiceName)
2378 {
2379 return VERR_INVALID_PARAMETER;
2380 }
2381
2382 HGCMMSGHANDLE hMsg = 0;
2383
2384 /* Host calls go to main HGCM thread that resolves the service name to the
2385 * service instance pointer and then, using the service pointer, forwards
2386 * the message to the service thread.
2387 * So it is slow but host calls are intended mostly for configuration and
2388 * other non-time-critical functions.
2389 */
2390 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_HOSTCALL, hgcmMainMessageAlloc);
2391
2392 if (RT_SUCCESS(rc))
2393 {
2394 HGCMMsgMainHostCall *pMsg = (HGCMMsgMainHostCall *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2395 AssertRelease(pMsg);
2396
2397 pMsg->pszServiceName = (char *)pszServiceName;
2398 pMsg->u32Function = u32Function;
2399 pMsg->cParms = cParms;
2400 pMsg->paParms = paParms;
2401
2402 hgcmObjDereference(pMsg);
2403
2404 rc = hgcmMsgSend(hMsg);
2405 }
2406
2407 LogFlowFunc(("rc = %Rrc\n", rc));
2408 return rc;
2409}
2410
2411#ifdef VBOX_WITH_CRHGSMI
2412int HGCMHostSvcHandleCreate(const char *pszServiceName, HGCMCVSHANDLE * phSvc)
2413{
2414 LogFlowFunc(("name = %s\n", pszServiceName));
2415
2416 if (!pszServiceName)
2417 {
2418 return VERR_INVALID_PARAMETER;
2419 }
2420
2421 if (!phSvc)
2422 {
2423 return VERR_INVALID_PARAMETER;
2424 }
2425
2426 HGCMMSGHANDLE hMsg = 0;
2427
2428 /* Host calls go to main HGCM thread that resolves the service name to the
2429 * service instance pointer and then, using the service pointer, forwards
2430 * the message to the service thread.
2431 * So it is slow but host calls are intended mostly for configuration and
2432 * other non-time-critical functions.
2433 */
2434 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_SVCAQUIRE, hgcmMainMessageAlloc);
2435
2436 if (RT_SUCCESS(rc))
2437 {
2438 HGCMMsgMainSvcAcquire *pMsg = (HGCMMsgMainSvcAcquire *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2439 AssertRelease(pMsg);
2440
2441 pMsg->pszServiceName = (char *)pszServiceName;
2442 pMsg->pService = NULL;
2443
2444 rc = hgcmMsgSend(hMsg);
2445 if (RT_SUCCESS(rc))
2446 {
2447 /* for simplicity just use a svc ptr as handle for now */
2448 *phSvc = (HGCMCVSHANDLE)pMsg->pService;
2449 }
2450
2451 hgcmObjDereference(pMsg);
2452 }
2453
2454 LogFlowFunc(("rc = %Rrc\n", rc));
2455 return rc;
2456}
2457
2458int HGCMHostSvcHandleDestroy(HGCMCVSHANDLE hSvc)
2459{
2460 LogFlowFunc(("hSvc = %p\n", hSvc));
2461
2462 if (!hSvc)
2463 {
2464 return VERR_INVALID_PARAMETER;
2465 }
2466
2467 HGCMMSGHANDLE hMsg = 0;
2468
2469 /* Host calls go to main HGCM thread that resolves the service name to the
2470 * service instance pointer and then, using the service pointer, forwards
2471 * the message to the service thread.
2472 * So it is slow but host calls are intended mostly for configuration and
2473 * other non-time-critical functions.
2474 */
2475 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_SVCRELEASE, hgcmMainMessageAlloc);
2476
2477 if (RT_SUCCESS(rc))
2478 {
2479 HGCMMsgMainSvcRelease *pMsg = (HGCMMsgMainSvcRelease *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
2480 AssertRelease(pMsg);
2481
2482 pMsg->pService = (HGCMService *)hSvc;
2483
2484 hgcmObjDereference(pMsg);
2485
2486 rc = hgcmMsgSend(hMsg);
2487 }
2488
2489 LogFlowFunc(("rc = %Rrc\n", rc));
2490 return rc;
2491}
2492
2493int HGCMHostFastCallAsync(HGCMCVSHANDLE hSvc, uint32_t function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
2494 void *pvCompletion)
2495{
2496 LogFlowFunc(("hSvc = %p, u32Function = %d, pParm = %p\n",
2497 hSvc, function, pParm));
2498
2499 if (!hSvc)
2500 {
2501 return VERR_INVALID_PARAMETER;
2502 }
2503
2504 HGCMService *pService = (HGCMService *)hSvc;
2505 int rc = pService->HostFastCallAsync(function, pParm, pfnCompletion, pvCompletion);
2506
2507 LogFlowFunc(("rc = %Rrc\n", rc));
2508 return rc;
2509}
2510#endif
2511
2512int HGCMHostReset(void)
2513{
2514 LogFlowFunc(("\n"));
2515
2516 /* Disconnect all clients.
2517 */
2518
2519 HGCMMSGHANDLE hMsg = 0;
2520
2521 int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_RESET, hgcmMainMessageAlloc);
2522
2523 if (RT_SUCCESS(rc))
2524 {
2525 rc = hgcmMsgSend(hMsg);
2526 }
2527
2528 LogFlowFunc(("rc = %Rrc\n", rc));
2529 return rc;
2530}
2531
2532int HGCMHostInit(void)
2533{
2534 LogFlowFunc(("\n"));
2535
2536 int rc = hgcmThreadInit();
2537
2538 if (RT_SUCCESS(rc))
2539 {
2540 /*
2541 * Start main HGCM thread.
2542 */
2543
2544 rc = hgcmThreadCreate(&g_hgcmThread, "MainHGCMthread", hgcmThread, NULL);
2545
2546 if (RT_FAILURE(rc))
2547 {
2548 LogRel(("Failed to start HGCM thread. HGCM services will be unavailable!!! rc = %Rrc\n", rc));
2549 }
2550 }
2551
2552 LogFlowFunc(("rc = %Rrc\n", rc));
2553 return rc;
2554}
2555
2556int HGCMHostShutdown(void)
2557{
2558 LogFlowFunc(("\n"));
2559
2560 /*
2561 * Do HGCMReset and then unload all services.
2562 */
2563
2564 int rc = HGCMHostReset();
2565
2566 if (RT_SUCCESS(rc))
2567 {
2568 /* Send the quit message to the main hgcmThread. */
2569 HGCMMSGHANDLE hMsg = 0;
2570
2571 rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_QUIT, hgcmMainMessageAlloc);
2572
2573 if (RT_SUCCESS(rc))
2574 {
2575 rc = hgcmMsgSend(hMsg);
2576
2577 if (RT_SUCCESS(rc))
2578 {
2579 /* Wait for the thread termination. */
2580 hgcmThreadWait(g_hgcmThread);
2581 g_hgcmThread = 0;
2582
2583 hgcmThreadUninit();
2584 }
2585 }
2586 }
2587
2588 LogFlowFunc(("rc = %Rrc\n", rc));
2589 return rc;
2590}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette