VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServicePageSharing.cpp@ 36214

Last change on this file since 36214 was 35036, checked in by vboxsync, 14 years ago

Warning.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.3 KB
Line 
1/* $Id: VBoxServicePageSharing.cpp 35036 2010-12-13 16:56:27Z vboxsync $ */
2/** @file
3 * VBoxService - Guest page sharing.
4 */
5
6/*
7 * Copyright (C) 2006-2010 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
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#include <iprt/assert.h>
23#include <iprt/avl.h>
24#include <iprt/asm.h>
25#include <iprt/mem.h>
26#include <iprt/process.h>
27#include <iprt/env.h>
28#include <iprt/stream.h>
29#include <iprt/file.h>
30#include <iprt/string.h>
31#include <iprt/semaphore.h>
32#include <iprt/system.h>
33#include <iprt/thread.h>
34#include <iprt/time.h>
35#include <VBox/VBoxGuestLib.h>
36#include "VBoxServiceInternal.h"
37#include "VBoxServiceUtils.h"
38
39
40/*******************************************************************************
41* Global Variables *
42*******************************************************************************/
43
44/** The semaphore we're blocking on. */
45static RTSEMEVENTMULTI g_PageSharingEvent = NIL_RTSEMEVENTMULTI;
46
47#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)
48#include <tlhelp32.h>
49#include <psapi.h>
50#include <winternl.h>
51
52typedef struct
53{
54 AVLPVNODECORE Core;
55 HMODULE hModule;
56 char szFileVersion[16];
57 MODULEENTRY32 Info;
58} KNOWN_MODULE, *PKNOWN_MODULE;
59
60#define SystemModuleInformation 11
61
62typedef struct _RTL_PROCESS_MODULE_INFORMATION
63{
64 ULONG Section;
65 PVOID MappedBase;
66 PVOID ImageBase;
67 ULONG ImageSize;
68 ULONG Flags;
69 USHORT LoadOrderIndex;
70 USHORT InitOrderIndex;
71 USHORT LoadCount;
72 USHORT OffsetToFileName;
73 CHAR FullPathName[256];
74} RTL_PROCESS_MODULE_INFORMATION, *PRTL_PROCESS_MODULE_INFORMATION;
75
76typedef struct _RTL_PROCESS_MODULES
77{
78 ULONG NumberOfModules;
79 RTL_PROCESS_MODULE_INFORMATION Modules[1];
80} RTL_PROCESS_MODULES, *PRTL_PROCESS_MODULES;
81
82typedef NTSTATUS (WINAPI *PFNZWQUERYSYSTEMINFORMATION)(ULONG, PVOID, ULONG, PULONG);
83static PFNZWQUERYSYSTEMINFORMATION ZwQuerySystemInformation = NULL;
84static HMODULE hNtdll = 0;
85
86
87static DECLCALLBACK(int) VBoxServicePageSharingEmptyTreeCallback(PAVLPVNODECORE pNode, void *pvUser);
88
89static PAVLPVNODECORE g_pKnownModuleTree = NULL;
90static uint64_t g_idSession = 0;
91
92/**
93 * Registers a new module with the VMM
94 * @param pModule Module ptr
95 * @param fValidateMemory Validate/touch memory pages or not
96 */
97void VBoxServicePageSharingRegisterModule(PKNOWN_MODULE pModule, bool fValidateMemory)
98{
99 VMMDEVSHAREDREGIONDESC aRegions[VMMDEVSHAREDREGIONDESC_MAX];
100 DWORD dwModuleSize = pModule->Info.modBaseSize;
101 BYTE *pBaseAddress = pModule->Info.modBaseAddr;
102 DWORD cbVersionSize, dummy;
103 BYTE *pVersionInfo;
104
105 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule\n");
106
107 cbVersionSize = GetFileVersionInfoSize(pModule->Info.szExePath, &dummy);
108 if (!cbVersionSize)
109 {
110 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: GetFileVersionInfoSize failed with %d\n", GetLastError());
111 return;
112 }
113 pVersionInfo = (BYTE *)RTMemAlloc(cbVersionSize);
114 if (!pVersionInfo)
115 return;
116
117 if (!GetFileVersionInfo(pModule->Info.szExePath, 0, cbVersionSize, pVersionInfo))
118 {
119 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: GetFileVersionInfo failed with %d\n", GetLastError());
120 goto end;
121 }
122
123 /* Fetch default code page. */
124 struct LANGANDCODEPAGE {
125 WORD wLanguage;
126 WORD wCodePage;
127 } *lpTranslate;
128
129 UINT cbTranslate;
130 BOOL ret = VerQueryValue(pVersionInfo, TEXT("\\VarFileInfo\\Translation"), (LPVOID *)&lpTranslate, &cbTranslate);
131 if ( !ret
132 || cbTranslate < 4)
133 {
134 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: VerQueryValue failed with %d (cb=%d)\n", GetLastError(), cbTranslate);
135 goto end;
136 }
137
138 unsigned i;
139 UINT cbFileVersion;
140 char *lpszFileVersion;
141 unsigned cTranslationBlocks = cbTranslate/sizeof(struct LANGANDCODEPAGE);
142
143 for(i = 0; i < cTranslationBlocks; i++)
144 {
145 /* Fetch file version string. */
146 char szFileVersionLocation[256];
147
148 sprintf(szFileVersionLocation, TEXT("\\StringFileInfo\\%04x%04x\\FileVersion"), lpTranslate[i].wLanguage, lpTranslate[i].wCodePage);
149 ret = VerQueryValue(pVersionInfo, szFileVersionLocation, (LPVOID *)&lpszFileVersion, &cbFileVersion);
150 if (ret)
151 break;
152 }
153 if (i == cTranslationBlocks)
154 {
155 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: no file version found!\n");
156 goto end;
157 }
158
159 _snprintf(pModule->szFileVersion, sizeof(pModule->szFileVersion), "%s", lpszFileVersion);
160 pModule->szFileVersion[RT_ELEMENTS(pModule->szFileVersion) - 1] = 0;
161
162 unsigned idxRegion = 0;
163
164 if (fValidateMemory)
165 {
166 do
167 {
168 MEMORY_BASIC_INFORMATION MemInfo;
169
170 SIZE_T ret = VirtualQuery(pBaseAddress, &MemInfo, sizeof(MemInfo));
171 Assert(ret);
172 if (!ret)
173 {
174 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: VirtualQueryEx failed with %d\n", GetLastError());
175 break;
176 }
177
178 if ( MemInfo.State == MEM_COMMIT
179 && MemInfo.Type == MEM_IMAGE)
180 {
181 switch (MemInfo.Protect)
182 {
183 case PAGE_EXECUTE:
184 case PAGE_EXECUTE_READ:
185 case PAGE_READONLY:
186 {
187 char *pRegion = (char *)MemInfo.BaseAddress;
188
189 /* Skip the first region as it only contains the image file header. */
190 if (pRegion != (char *)pModule->Info.modBaseAddr)
191 {
192 /* Touch all pages. */
193 while (pRegion < (char *)MemInfo.BaseAddress + MemInfo.RegionSize)
194 {
195 /* Try to trick the optimizer to leave the page touching code in place. */
196 ASMProbeReadByte(pRegion);
197 pRegion += PAGE_SIZE;
198 }
199 }
200#ifdef RT_ARCH_X86
201 aRegions[idxRegion].GCRegionAddr = (RTGCPTR32)MemInfo.BaseAddress;
202#else
203 aRegions[idxRegion].GCRegionAddr = (RTGCPTR64)MemInfo.BaseAddress;
204#endif
205 aRegions[idxRegion].cbRegion = MemInfo.RegionSize;
206 idxRegion++;
207
208 break;
209 }
210
211 default:
212 break; /* ignore */
213 }
214 }
215
216 pBaseAddress = (BYTE *)MemInfo.BaseAddress + MemInfo.RegionSize;
217 if (dwModuleSize > MemInfo.RegionSize)
218 {
219 dwModuleSize -= MemInfo.RegionSize;
220 }
221 else
222 {
223 dwModuleSize = 0;
224 break;
225 }
226
227 if (idxRegion >= RT_ELEMENTS(aRegions))
228 break; /* out of room */
229 }
230 while (dwModuleSize);
231 }
232 else
233 {
234 /* We can't probe kernel memory ranges, so pretend it's one big region. */
235#ifdef RT_ARCH_X86
236 aRegions[idxRegion].GCRegionAddr = (RTGCPTR32)pBaseAddress;
237#else
238 aRegions[idxRegion].GCRegionAddr = (RTGCPTR64)pBaseAddress;
239#endif
240 aRegions[idxRegion].cbRegion = dwModuleSize;
241 idxRegion++;
242 }
243 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: VbglR3RegisterSharedModule %s %s base=%p size=%x cregions=%d\n", pModule->Info.szModule, pModule->szFileVersion, pModule->Info.modBaseAddr, pModule->Info.modBaseSize, idxRegion);
244#ifdef RT_ARCH_X86
245 int rc = VbglR3RegisterSharedModule(pModule->Info.szModule, pModule->szFileVersion, (RTGCPTR32)pModule->Info.modBaseAddr,
246 pModule->Info.modBaseSize, idxRegion, aRegions);
247#else
248 int rc = VbglR3RegisterSharedModule(pModule->Info.szModule, pModule->szFileVersion, (RTGCPTR64)pModule->Info.modBaseAddr,
249 pModule->Info.modBaseSize, idxRegion, aRegions);
250#endif
251
252// AssertRC(rc);
253 if (RT_FAILURE(rc))
254 VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: VbglR3RegisterSharedModule failed with %d\n", rc);
255
256end:
257 RTMemFree(pVersionInfo);
258 return;
259}
260
261/**
262 * Inspect all loaded modules for the specified process
263 * @param dwProcessId Process id
264 */
265void VBoxServicePageSharingInspectModules(DWORD dwProcessId, PAVLPVNODECORE *ppNewTree)
266{
267 HANDLE hProcess, hSnapshot;
268
269 /* Get a list of all the modules in this process. */
270 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,
271 FALSE /* no child process handle inheritance */, dwProcessId);
272 if (hProcess == NULL)
273 {
274 VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules: OpenProcess %x failed with %d\n", dwProcessId, GetLastError());
275 return;
276 }
277
278 hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);
279 if (hSnapshot == INVALID_HANDLE_VALUE)
280 {
281 VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules: CreateToolhelp32Snapshot failed with %d\n", GetLastError());
282 CloseHandle(hProcess);
283 return;
284 }
285
286 VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules\n");
287
288 MODULEENTRY32 ModuleInfo;
289 BOOL bRet;
290
291 ModuleInfo.dwSize = sizeof(ModuleInfo);
292 bRet = Module32First(hSnapshot, &ModuleInfo);
293 do
294 {
295 /** todo when changing this make sure VBoxService.exe is excluded! */
296 char *pszDot = strrchr(ModuleInfo.szModule, '.');
297 if ( pszDot
298 && (pszDot[1] == 'e' || pszDot[1] == 'E'))
299 continue; /* ignore executables for now. */
300
301 /* Found it before? */
302 PAVLPVNODECORE pRec = RTAvlPVGet(ppNewTree, ModuleInfo.modBaseAddr);
303 if (!pRec)
304 {
305 pRec = RTAvlPVRemove(&g_pKnownModuleTree, ModuleInfo.modBaseAddr);
306 if (!pRec)
307 {
308 /* New module; register it. */
309 PKNOWN_MODULE pModule = (PKNOWN_MODULE)RTMemAllocZ(sizeof(*pModule));
310 Assert(pModule);
311 if (!pModule)
312 break;
313
314 pModule->Info = ModuleInfo;
315 pModule->Core.Key = ModuleInfo.modBaseAddr;
316 pModule->hModule = LoadLibraryEx(ModuleInfo.szExePath, 0, DONT_RESOLVE_DLL_REFERENCES);
317 if (pModule->hModule)
318 VBoxServicePageSharingRegisterModule(pModule, true /* validate pages */);
319
320 VBoxServiceVerbose(3, "\n\n MODULE NAME: %s", ModuleInfo.szModule );
321 VBoxServiceVerbose(3, "\n executable = %s", ModuleInfo.szExePath );
322 VBoxServiceVerbose(3, "\n process ID = 0x%08X", ModuleInfo.th32ProcessID );
323 VBoxServiceVerbose(3, "\n base address = 0x%08X", (DWORD) ModuleInfo.modBaseAddr );
324 VBoxServiceVerbose(3, "\n base size = %d", ModuleInfo.modBaseSize );
325
326 pRec = &pModule->Core;
327 }
328 bool ret = RTAvlPVInsert(ppNewTree, pRec);
329 Assert(ret); NOREF(ret);
330 }
331 }
332 while (Module32Next(hSnapshot, &ModuleInfo));
333
334 CloseHandle(hSnapshot);
335 CloseHandle(hProcess);
336}
337
338/**
339 * Inspect all running processes for executables and dlls that might be worth sharing
340 * with other VMs.
341 *
342 */
343void VBoxServicePageSharingInspectGuest()
344{
345 HANDLE hSnapshot;
346 PAVLPVNODECORE pNewTree = NULL;
347 DWORD dwProcessId = GetCurrentProcessId();
348
349 VBoxServiceVerbose(3, "VBoxServicePageSharingInspectGuest\n");
350
351 hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
352 if (hSnapshot == INVALID_HANDLE_VALUE)
353 {
354 VBoxServiceVerbose(3, "VBoxServicePageSharingInspectGuest: CreateToolhelp32Snapshot failed with %d\n", GetLastError());
355 return;
356 }
357
358 /* Check loaded modules for all running processes. */
359 PROCESSENTRY32 ProcessInfo;
360
361 ProcessInfo.dwSize = sizeof(ProcessInfo);
362 Process32First(hSnapshot, &ProcessInfo);
363
364 do
365 {
366 /* Skip our own process. */
367 if (ProcessInfo.th32ProcessID != dwProcessId)
368 VBoxServicePageSharingInspectModules(ProcessInfo.th32ProcessID, &pNewTree);
369 }
370 while (Process32Next(hSnapshot, &ProcessInfo));
371
372 CloseHandle(hSnapshot);
373
374 /* Check all loaded kernel modules. */
375 if (ZwQuerySystemInformation)
376 {
377 ULONG cbBuffer = 0;
378 PVOID pBuffer = NULL;
379 PRTL_PROCESS_MODULES pSystemModules;
380
381 NTSTATUS ret = ZwQuerySystemInformation(SystemModuleInformation, (PVOID)&cbBuffer, 0, &cbBuffer);
382 if (!cbBuffer)
383 {
384 VBoxServiceVerbose(1, "ZwQuerySystemInformation returned length 0\n");
385 goto skipkernelmodules;
386 }
387
388 pBuffer = RTMemAllocZ(cbBuffer);
389 if (!pBuffer)
390 goto skipkernelmodules;
391
392 ret = ZwQuerySystemInformation(SystemModuleInformation, pBuffer, cbBuffer, &cbBuffer);
393 if (ret != STATUS_SUCCESS)
394 {
395 VBoxServiceVerbose(1, "ZwQuerySystemInformation returned %x (1)\n", ret);
396 goto skipkernelmodules;
397 }
398
399 pSystemModules = (PRTL_PROCESS_MODULES)pBuffer;
400 for (unsigned i = 0; i < pSystemModules->NumberOfModules; i++)
401 {
402 VBoxServiceVerbose(4, "\n\n KERNEL MODULE NAME: %s", pSystemModules->Modules[i].FullPathName[pSystemModules->Modules[i].OffsetToFileName] );
403 VBoxServiceVerbose(4, "\n executable = %s", pSystemModules->Modules[i].FullPathName );
404 VBoxServiceVerbose(4, "\n flags = 0x%08X\n", pSystemModules->Modules[i].Flags);
405
406 /* User-mode modules seem to have no flags set; skip them as we detected them above. */
407 if (pSystemModules->Modules[i].Flags == 0)
408 continue;
409
410 /* Found it before? */
411 PAVLPVNODECORE pRec = RTAvlPVGet(&pNewTree, pSystemModules->Modules[i].ImageBase);
412 if (!pRec)
413 {
414 pRec = RTAvlPVRemove(&g_pKnownModuleTree, pSystemModules->Modules[i].ImageBase);
415 if (!pRec)
416 {
417 /* New module; register it. */
418 char szFullFilePath[512];
419 PKNOWN_MODULE pModule = (PKNOWN_MODULE)RTMemAllocZ(sizeof(*pModule));
420 Assert(pModule);
421 if (!pModule)
422 break;
423
424 strcpy(pModule->Info.szModule, &pSystemModules->Modules[i].FullPathName[pSystemModules->Modules[i].OffsetToFileName]);
425 GetSystemDirectoryA(szFullFilePath, sizeof(szFullFilePath));
426
427 /* skip \Systemroot\system32 */
428 char *lpPath = strchr(&pSystemModules->Modules[i].FullPathName[1], '\\');
429 if (!lpPath)
430 {
431 /* Seen just file names in XP; try to locate the file in the system32 and system32\drivers directories. */
432 strcat(szFullFilePath, "\\");
433 strcat(szFullFilePath, pSystemModules->Modules[i].FullPathName);
434 VBoxServiceVerbose(3, "Unexpected kernel module name try %s\n", szFullFilePath);
435 if (RTFileExists(szFullFilePath) == false)
436 {
437 GetSystemDirectoryA(szFullFilePath, sizeof(szFullFilePath));
438 strcat(szFullFilePath, "\\drivers\\");
439 strcat(szFullFilePath, pSystemModules->Modules[i].FullPathName);
440 VBoxServiceVerbose(3, "Unexpected kernel module name try %s\n", szFullFilePath);
441 if (RTFileExists(szFullFilePath) == false)
442 {
443 VBoxServiceVerbose(1, "Unexpected kernel module name %s\n", pSystemModules->Modules[i].FullPathName);
444 RTMemFree(pModule);
445 continue;
446 }
447 }
448 }
449 else
450 {
451 lpPath = strchr(lpPath+1, '\\');
452 if (!lpPath)
453 {
454 VBoxServiceVerbose(1, "Unexpected kernel module name %s (2)\n", pSystemModules->Modules[i].FullPathName);
455 RTMemFree(pModule);
456 continue;
457 }
458
459 strcat(szFullFilePath, lpPath);
460 }
461
462 strcpy(pModule->Info.szExePath, szFullFilePath);
463 pModule->Info.modBaseAddr = (BYTE *)pSystemModules->Modules[i].ImageBase;
464 pModule->Info.modBaseSize = pSystemModules->Modules[i].ImageSize;
465
466 pModule->Core.Key = pSystemModules->Modules[i].ImageBase;
467 VBoxServicePageSharingRegisterModule(pModule, false /* don't check memory pages */);
468
469 VBoxServiceVerbose(3, "\n\n KERNEL MODULE NAME: %s", pModule->Info.szModule );
470 VBoxServiceVerbose(3, "\n executable = %s", pModule->Info.szExePath );
471 VBoxServiceVerbose(3, "\n base address = 0x%08X", (DWORD) pModule->Info.modBaseAddr );
472 VBoxServiceVerbose(3, "\n flags = 0x%08X", pSystemModules->Modules[i].Flags);
473 VBoxServiceVerbose(3, "\n base size = %d", pModule->Info.modBaseSize );
474
475 pRec = &pModule->Core;
476 }
477 bool ret = RTAvlPVInsert(&pNewTree, pRec);
478 Assert(ret); NOREF(ret);
479 }
480 }
481skipkernelmodules:
482 if (pBuffer)
483 RTMemFree(pBuffer);
484 }
485
486 /* Delete leftover modules in the old tree. */
487 RTAvlPVDestroy(&g_pKnownModuleTree, VBoxServicePageSharingEmptyTreeCallback, NULL);
488
489 /* Check all registered modules. */
490 VbglR3CheckSharedModules();
491
492 /* Activate new module tree. */
493 g_pKnownModuleTree = pNewTree;
494}
495
496/**
497 * RTAvlPVDestroy callback.
498 */
499static DECLCALLBACK(int) VBoxServicePageSharingEmptyTreeCallback(PAVLPVNODECORE pNode, void *pvUser)
500{
501 PKNOWN_MODULE pModule = (PKNOWN_MODULE)pNode;
502 bool *pfUnregister = (bool *)pvUser;
503
504 VBoxServiceVerbose(3, "VBoxServicePageSharingEmptyTreeCallback %s %s\n", pModule->Info.szModule, pModule->szFileVersion);
505
506 /* Dereference module in the hypervisor. */
507 if ( !pfUnregister
508 || *pfUnregister == true)
509 {
510 #ifdef RT_ARCH_X86
511 int rc = VbglR3UnregisterSharedModule(pModule->Info.szModule, pModule->szFileVersion, (RTGCPTR32)pModule->Info.modBaseAddr, pModule->Info.modBaseSize);
512 #else
513 int rc = VbglR3UnregisterSharedModule(pModule->Info.szModule, pModule->szFileVersion, (RTGCPTR64)pModule->Info.modBaseAddr, pModule->Info.modBaseSize);
514 #endif
515 AssertRC(rc);
516 }
517
518 if (pModule->hModule)
519 FreeLibrary(pModule->hModule);
520 RTMemFree(pNode);
521 return 0;
522}
523
524
525#elif TARGET_NT4
526void VBoxServicePageSharingInspectGuest()
527{
528 /* not implemented */
529}
530#else
531void VBoxServicePageSharingInspectGuest()
532{
533 /* @todo other platforms */
534}
535#endif
536
537/** @copydoc VBOXSERVICE::pfnPreInit */
538static DECLCALLBACK(int) VBoxServicePageSharingPreInit(void)
539{
540 return VINF_SUCCESS;
541}
542
543
544/** @copydoc VBOXSERVICE::pfnOption */
545static DECLCALLBACK(int) VBoxServicePageSharingOption(const char **ppszShort, int argc, char **argv, int *pi)
546{
547 NOREF(ppszShort);
548 NOREF(argc);
549 NOREF(argv);
550 NOREF(pi);
551 return VINF_SUCCESS;
552}
553
554
555/** @copydoc VBOXSERVICE::pfnInit */
556static DECLCALLBACK(int) VBoxServicePageSharingInit(void)
557{
558 VBoxServiceVerbose(3, "VBoxServicePageSharingInit\n");
559
560 int rc = RTSemEventMultiCreate(&g_PageSharingEvent);
561 AssertRCReturn(rc, rc);
562
563#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)
564 hNtdll = LoadLibrary("ntdll.dll");
565
566 if (hNtdll)
567 ZwQuerySystemInformation = (PFNZWQUERYSYSTEMINFORMATION)GetProcAddress(hNtdll, "ZwQuerySystemInformation");
568
569 rc = VbglR3GetSessionId(&g_idSession);
570 AssertRCReturn(rc, rc);
571#endif
572
573 /* Never fail here. */
574 return VINF_SUCCESS;
575}
576
577/** @copydoc VBOXSERVICE::pfnWorker */
578DECLCALLBACK(int) VBoxServicePageSharingWorker(bool volatile *pfShutdown)
579{
580 /*
581 * Tell the control thread that it can continue
582 * spawning services.
583 */
584 RTThreadUserSignal(RTThreadSelf());
585
586 /*
587 * Now enter the loop retrieving runtime data continuously.
588 */
589 for (;;)
590 {
591 BOOL fEnabled = VbglR3PageSharingIsEnabled();
592
593 VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: enabled=%d\n", fEnabled);
594
595 if (fEnabled)
596 VBoxServicePageSharingInspectGuest();
597
598 /*
599 * Block for a minute.
600 *
601 * The event semaphore takes care of ignoring interruptions and it
602 * allows us to implement service wakeup later.
603 */
604 if (*pfShutdown)
605 break;
606 int rc = RTSemEventMultiWait(g_PageSharingEvent, 60000);
607 if (*pfShutdown)
608 break;
609 if (rc != VERR_TIMEOUT && RT_FAILURE(rc))
610 {
611 VBoxServiceError("VBoxServicePageSharingWorker: RTSemEventMultiWait failed; rc=%Rrc\n", rc);
612 break;
613 }
614#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)
615 uint64_t idNewSession = g_idSession;
616 rc = VbglR3GetSessionId(&idNewSession);
617 AssertRC(rc);
618
619 if (idNewSession != g_idSession)
620 {
621 bool fUnregister = false;
622
623 VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: VM was restored!!\n");
624 /* The VM was restored, so reregister all modules the next time. */
625 RTAvlPVDestroy(&g_pKnownModuleTree, VBoxServicePageSharingEmptyTreeCallback, &fUnregister);
626 g_pKnownModuleTree = NULL;
627
628 g_idSession = idNewSession;
629 }
630#endif
631 }
632
633 RTSemEventMultiDestroy(g_PageSharingEvent);
634 g_PageSharingEvent = NIL_RTSEMEVENTMULTI;
635
636 VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: finished thread\n");
637 return 0;
638}
639
640#ifdef RT_OS_WINDOWS
641
642/**
643 * This gets control when VBoxService is launched with -pagefusionfork by
644 * VBoxServicePageSharingWorkerProcess().
645 *
646 * @returns RTEXITCODE_SUCCESS.
647 *
648 * @remarks It won't normally return since the parent drops the shutdown hint
649 * via RTProcTerminate().
650 */
651RTEXITCODE VBoxServicePageSharingInitFork(void)
652{
653 VBoxServiceVerbose(3, "VBoxServicePageSharingInitFork\n");
654
655 bool fShutdown = false;
656 VBoxServicePageSharingInit();
657 VBoxServicePageSharingWorker(&fShutdown);
658
659 return RTEXITCODE_SUCCESS;
660}
661
662/** @copydoc VBOXSERVICE::pfnWorker */
663DECLCALLBACK(int) VBoxServicePageSharingWorkerProcess(bool volatile *pfShutdown)
664{
665 RTPROCESS hProcess = NIL_RTPROCESS;
666 int rc;
667
668 /*
669 * Tell the control thread that it can continue
670 * spawning services.
671 */
672 RTThreadUserSignal(RTThreadSelf());
673
674 /*
675 * Now enter the loop retrieving runtime data continuously.
676 */
677 for (;;)
678 {
679 BOOL fEnabled = VbglR3PageSharingIsEnabled();
680 VBoxServiceVerbose(3, "VBoxServicePageSharingWorkerProcess: enabled=%d\n", fEnabled);
681
682 /*
683 * Start a 2nd VBoxService process to deal with page fusion as we do
684 * not wish to dummy load dlls into this process. (First load with
685 * DONT_RESOLVE_DLL_REFERENCES, 2nd normal -> dll init routines not called!)
686 */
687 if ( fEnabled
688 && hProcess == NIL_RTPROCESS)
689 {
690 char szExeName[256];
691 char *pszExeName = RTProcGetExecutablePath(szExeName, sizeof(szExeName));
692 if (pszExeName)
693 {
694 char const *papszArgs[3];
695 papszArgs[0] = pszExeName;
696 papszArgs[1] = "--pagefusionfork";
697 papszArgs[2] = NULL;
698 rc = RTProcCreate(pszExeName, papszArgs, RTENV_DEFAULT, 0 /* normal child */, &hProcess);
699 if (RT_FAILURE(rc))
700 VBoxServiceError("VBoxServicePageSharingWorkerProcess: RTProcCreate %s failed; rc=%Rrc\n", pszExeName, rc);
701 }
702 }
703
704 /*
705 * Block for a minute.
706 *
707 * The event semaphore takes care of ignoring interruptions and it
708 * allows us to implement service wakeup later.
709 */
710 if (*pfShutdown)
711 break;
712 rc = RTSemEventMultiWait(g_PageSharingEvent, 60000);
713 if (*pfShutdown)
714 break;
715 if (rc != VERR_TIMEOUT && RT_FAILURE(rc))
716 {
717 VBoxServiceError("VBoxServicePageSharingWorkerProcess: RTSemEventMultiWait failed; rc=%Rrc\n", rc);
718 break;
719 }
720 }
721
722 if (hProcess != NIL_RTPROCESS)
723 RTProcTerminate(hProcess);
724
725 RTSemEventMultiDestroy(g_PageSharingEvent);
726 g_PageSharingEvent = NIL_RTSEMEVENTMULTI;
727
728 VBoxServiceVerbose(3, "VBoxServicePageSharingWorkerProcess: finished thread\n");
729 return 0;
730}
731
732#endif /* RT_OS_WINDOWS */
733
734/** @copydoc VBOXSERVICE::pfnTerm */
735static DECLCALLBACK(void) VBoxServicePageSharingTerm(void)
736{
737 VBoxServiceVerbose(3, "VBoxServicePageSharingTerm\n");
738
739#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)
740 if (hNtdll)
741 FreeLibrary(hNtdll);
742#endif
743 return;
744}
745
746
747/** @copydoc VBOXSERVICE::pfnStop */
748static DECLCALLBACK(void) VBoxServicePageSharingStop(void)
749{
750 RTSemEventMultiSignal(g_PageSharingEvent);
751}
752
753
754/**
755 * The 'pagesharing' service description.
756 */
757VBOXSERVICE g_PageSharing =
758{
759 /* pszName. */
760 "pagesharing",
761 /* pszDescription. */
762 "Page Sharing",
763 /* pszUsage. */
764 NULL,
765 /* pszOptions. */
766 NULL,
767 /* methods */
768 VBoxServicePageSharingPreInit,
769 VBoxServicePageSharingOption,
770 VBoxServicePageSharingInit,
771#ifdef RT_OS_WINDOWS
772 VBoxServicePageSharingWorkerProcess,
773#else
774 VBoxServicePageSharingWorker,
775#endif
776 VBoxServicePageSharingStop,
777 VBoxServicePageSharingTerm
778};
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