VirtualBox

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

Last change on this file since 69500 was 69500, checked in by vboxsync, 7 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use