~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-proposed

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

int rc = VbglR3RegisterSharedModule(pModule->Info.szModule, pModule->szFileVersion, (uintptr_t)pModule->Info.modBaseAddr,

245

pModule->Info.modBaseSize, idxRegion, aRegions);

246

if (RT_FAILURE(rc))

247

VBoxServiceVerbose(3, "VBoxServicePageSharingRegisterModule: VbglR3RegisterSharedModule failed with %Rrc\n", rc);

248

249

end:

250

RTMemFree(pVersionInfo);

251

return;

252

}

253

254

/**

255

* Inspect all loaded modules for the specified process

256

* @param dwProcessId Process id

257

258

void VBoxServicePageSharingInspectModules(DWORD dwProcessId, PAVLPVNODECORE *ppNewTree)

259

{

260

HANDLE hProcess, hSnapshot;

261

262

/* Get a list of all the modules in this process. */

263

hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,

264

FALSE /* no child process handle inheritance */, dwProcessId);

265

if (hProcess == NULL)

266

{

267

VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules: OpenProcess %x failed with %d\n", dwProcessId, GetLastError());

268

return;

269

}

270

271

hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcessId);

272

if (hSnapshot == INVALID_HANDLE_VALUE)

273

{

274

VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules: CreateToolhelp32Snapshot failed with %d\n", GetLastError());

275

CloseHandle(hProcess);

276

return;

277

}

278

279

VBoxServiceVerbose(3, "VBoxServicePageSharingInspectModules\n");

280

281

MODULEENTRY32 ModuleInfo;

282

BOOL bRet;

283

284

ModuleInfo.dwSize = sizeof(ModuleInfo);

285

bRet = Module32First(hSnapshot, &ModuleInfo);

286

287

{

288

/** @todo when changing this make sure VBoxService.exe is excluded! */

289

char *pszDot = strrchr(ModuleInfo.szModule, '.');

290

if ( pszDot

291

&& (pszDot[1] == 'e' || pszDot[1] == 'E'))

292

continue; /* ignore executables for now. */

293

294

/* Found it before? */

295

PAVLPVNODECORE pRec = RTAvlPVGet(ppNewTree, ModuleInfo.modBaseAddr);

296

if (!pRec)

297

{

298

pRec = RTAvlPVRemove(&g_pKnownModuleTree, ModuleInfo.modBaseAddr);

299

if (!pRec)

300

{

301

/* New module; register it. */

302

PKNOWN_MODULE pModule = (PKNOWN_MODULE)RTMemAllocZ(sizeof(*pModule));

303

Assert(pModule);

304

if (!pModule)

305

break;

306

307

pModule->Info = ModuleInfo;

308

pModule->Core.Key = ModuleInfo.modBaseAddr;

309

pModule->hModule = LoadLibraryEx(ModuleInfo.szExePath, 0, DONT_RESOLVE_DLL_REFERENCES);

310

if (pModule->hModule)

311

VBoxServicePageSharingRegisterModule(pModule, true /* validate pages */);

312

313

VBoxServiceVerbose(3, "\n\n MODULE NAME: %s", ModuleInfo.szModule );

314

VBoxServiceVerbose(3, "\n executable = %s", ModuleInfo.szExePath );

315

VBoxServiceVerbose(3, "\n process ID = 0x%08X", ModuleInfo.th32ProcessID );

316

VBoxServiceVerbose(3, "\n base address = 0x%08X", (DWORD) ModuleInfo.modBaseAddr );

317

VBoxServiceVerbose(3, "\n base size = %d", ModuleInfo.modBaseSize );

318

319

pRec = &pModule->Core;

320

}

321

bool ret = RTAvlPVInsert(ppNewTree, pRec);

322

Assert(ret); NOREF(ret);

323

}

324

}

325

while (Module32Next(hSnapshot, &ModuleInfo));

326

327

CloseHandle(hSnapshot);

328

CloseHandle(hProcess);

329

}

330

331

/**

332

* Inspect all running processes for executables and dlls that might be worth sharing

333

* with other VMs.

334

335

336

void VBoxServicePageSharingInspectGuest()

337

{

338

HANDLE hSnapshot;

339

PAVLPVNODECORE pNewTree = NULL;

340

DWORD dwProcessId = GetCurrentProcessId();

341

342

VBoxServiceVerbose(3, "VBoxServicePageSharingInspectGuest\n");

343

344

hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

345

if (hSnapshot == INVALID_HANDLE_VALUE)

346

{

347

VBoxServiceVerbose(3, "VBoxServicePageSharingInspectGuest: CreateToolhelp32Snapshot failed with %d\n", GetLastError());

348

return;

349

}

350

351

/* Check loaded modules for all running processes. */

352

PROCESSENTRY32 ProcessInfo;

353

354

ProcessInfo.dwSize = sizeof(ProcessInfo);

355

Process32First(hSnapshot, &ProcessInfo);

356

357

358

{

359

/* Skip our own process. */

360

if (ProcessInfo.th32ProcessID != dwProcessId)

361

VBoxServicePageSharingInspectModules(ProcessInfo.th32ProcessID, &pNewTree);

362

}

363

while (Process32Next(hSnapshot, &ProcessInfo));

364

365

CloseHandle(hSnapshot);

366

367

/* Check all loaded kernel modules. */

368

if (g_pfnZwQuerySystemInformation)

369

{

370

ULONG cbBuffer = 0;

371

PVOID pBuffer = NULL;

372

PRTL_PROCESS_MODULES pSystemModules;

373

374

NTSTATUS ret = g_pfnZwQuerySystemInformation(SystemModuleInformation, (PVOID)&cbBuffer, 0, &cbBuffer);

375

if (!cbBuffer)

376

{

377

VBoxServiceVerbose(1, "ZwQuerySystemInformation returned length 0\n");

378

goto skipkernelmodules;

379

}

380

381

pBuffer = RTMemAllocZ(cbBuffer);

382

if (!pBuffer)

383

goto skipkernelmodules;

384

385

ret = g_pfnZwQuerySystemInformation(SystemModuleInformation, pBuffer, cbBuffer, &cbBuffer);

386

if (ret != STATUS_SUCCESS)

387

{

388

VBoxServiceVerbose(1, "ZwQuerySystemInformation returned %x (1)\n", ret);

389

goto skipkernelmodules;

390

}

391

392

pSystemModules = (PRTL_PROCESS_MODULES)pBuffer;

393

for (unsigned i = 0; i < pSystemModules->NumberOfModules; i++)

394

{

395

VBoxServiceVerbose(4, "\n\n KERNEL MODULE NAME: %s", pSystemModules->Modules[i].FullPathName[pSystemModules->Modules[i].OffsetToFileName] );

396

VBoxServiceVerbose(4, "\n executable = %s", pSystemModules->Modules[i].FullPathName );

397

VBoxServiceVerbose(4, "\n flags = 0x%08X\n", pSystemModules->Modules[i].Flags);

398

399

/* User-mode modules seem to have no flags set; skip them as we detected them above. */

400

if (pSystemModules->Modules[i].Flags == 0)

401

continue;

402

403

/* Found it before? */

404

PAVLPVNODECORE pRec = RTAvlPVGet(&pNewTree, pSystemModules->Modules[i].ImageBase);

405

if (!pRec)

406

{

407

pRec = RTAvlPVRemove(&g_pKnownModuleTree, pSystemModules->Modules[i].ImageBase);

408

if (!pRec)

409

{

410

/* New module; register it. */

411

char szFullFilePath[512];

412

PKNOWN_MODULE pModule = (PKNOWN_MODULE)RTMemAllocZ(sizeof(*pModule));

413

Assert(pModule);

414

if (!pModule)

415

break;

416

417

strcpy(pModule->Info.szModule, &pSystemModules->Modules[i].FullPathName[pSystemModules->Modules[i].OffsetToFileName]);

418

GetSystemDirectoryA(szFullFilePath, sizeof(szFullFilePath));

419

420

/* skip \Systemroot\system32 */

421

char *lpPath = strchr(&pSystemModules->Modules[i].FullPathName[1], '\\');

422

if (!lpPath)

423

{

424

/* Seen just file names in XP; try to locate the file in the system32 and system32\drivers directories. */

425

strcat(szFullFilePath, "\\");

426

strcat(szFullFilePath, pSystemModules->Modules[i].FullPathName);

427

VBoxServiceVerbose(3, "Unexpected kernel module name try %s\n", szFullFilePath);

428

if (RTFileExists(szFullFilePath) == false)

429

{

430

GetSystemDirectoryA(szFullFilePath, sizeof(szFullFilePath));

431

strcat(szFullFilePath, "\\drivers\\");

432

strcat(szFullFilePath, pSystemModules->Modules[i].FullPathName);

433

VBoxServiceVerbose(3, "Unexpected kernel module name try %s\n", szFullFilePath);

434

if (RTFileExists(szFullFilePath) == false)

435

{

436

VBoxServiceVerbose(1, "Unexpected kernel module name %s\n", pSystemModules->Modules[i].FullPathName);

437

RTMemFree(pModule);

438

continue;

439

}

440

}

441

}

442

else

443

{

444

lpPath = strchr(lpPath+1, '\\');

445

if (!lpPath)

446

{

447

VBoxServiceVerbose(1, "Unexpected kernel module name %s (2)\n", pSystemModules->Modules[i].FullPathName);

448

RTMemFree(pModule);

449

continue;

450

}

451

452

strcat(szFullFilePath, lpPath);

453

}

454

455

strcpy(pModule->Info.szExePath, szFullFilePath);

456

pModule->Info.modBaseAddr = (BYTE *)pSystemModules->Modules[i].ImageBase;

457

pModule->Info.modBaseSize = pSystemModules->Modules[i].ImageSize;

458

459

pModule->Core.Key = pSystemModules->Modules[i].ImageBase;

460

VBoxServicePageSharingRegisterModule(pModule, false /* don't check memory pages */);

461

462

VBoxServiceVerbose(3, "\n\n KERNEL MODULE NAME: %s", pModule->Info.szModule );

463

VBoxServiceVerbose(3, "\n executable = %s", pModule->Info.szExePath );

464

VBoxServiceVerbose(3, "\n base address = 0x%08X", (DWORD) pModule->Info.modBaseAddr );

465

VBoxServiceVerbose(3, "\n flags = 0x%08X", pSystemModules->Modules[i].Flags);

466

VBoxServiceVerbose(3, "\n base size = %d", pModule->Info.modBaseSize );

467

468

pRec = &pModule->Core;

469

}

470

bool ret = RTAvlPVInsert(&pNewTree, pRec);

471

Assert(ret); NOREF(ret);

472

}

473

}

474

skipkernelmodules:

475

if (pBuffer)

476

RTMemFree(pBuffer);

477

}

478

479

/* Delete leftover modules in the old tree. */

480

RTAvlPVDestroy(&g_pKnownModuleTree, VBoxServicePageSharingEmptyTreeCallback, NULL);

481

482

/* Check all registered modules. */

483

VbglR3CheckSharedModules();

484

485

/* Activate new module tree. */

486

g_pKnownModuleTree = pNewTree;

487

}

488

489

/**

490

* RTAvlPVDestroy callback.

491

492

static DECLCALLBACK(int) VBoxServicePageSharingEmptyTreeCallback(PAVLPVNODECORE pNode, void *pvUser)

493

{

494

PKNOWN_MODULE pModule = (PKNOWN_MODULE)pNode;

495

bool *pfUnregister = (bool *)pvUser;

496

497

VBoxServiceVerbose(3, "VBoxServicePageSharingEmptyTreeCallback %s %s\n", pModule->Info.szModule, pModule->szFileVersion);

498

499

/* Dereference module in the hypervisor. */

500

if ( !pfUnregister

501

|| *pfUnregister)

502

{

503

int rc = VbglR3UnregisterSharedModule(pModule->Info.szModule, pModule->szFileVersion,

504

(uintptr_t)pModule->Info.modBaseAddr, pModule->Info.modBaseSize);

505

AssertRC(rc);

506

}

507

508

if (pModule->hModule)

509

FreeLibrary(pModule->hModule);

510

RTMemFree(pNode);

511

return 0;

512

}

513

514

515

#elif TARGET_NT4

516

void VBoxServicePageSharingInspectGuest()

517

{

518

/* not implemented */

519

}

520

#else

521

void VBoxServicePageSharingInspectGuest()

522

{

523

/* @todo other platforms */

524

}

525

#endif

526

527

/** @copydoc VBOXSERVICE::pfnInit */

528

static DECLCALLBACK(int) VBoxServicePageSharingInit(void)

529

{

530

VBoxServiceVerbose(3, "VBoxServicePageSharingInit\n");

531

532

int rc = RTSemEventMultiCreate(&g_PageSharingEvent);

533

AssertRCReturn(rc, rc);

534

535

#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)

536

g_pfnZwQuerySystemInformation = (PFNZWQUERYSYSTEMINFORMATION)RTLdrGetSystemSymbol("ntdll.dll", "ZwQuerySystemInformation");

537

538

rc = VbglR3GetSessionId(&g_idSession);

539

if (RT_FAILURE(rc))

540

{

541

if (rc == VERR_IO_GEN_FAILURE)

542

VBoxServiceVerbose(0, "PageSharing: Page sharing support is not available by the host\n");

543

else

544

VBoxServiceError("VBoxServicePageSharingInit: Failed with rc=%Rrc\n", rc);

545

546

rc = VERR_SERVICE_DISABLED;

547

548

RTSemEventMultiDestroy(g_PageSharingEvent);

549

g_PageSharingEvent = NIL_RTSEMEVENTMULTI;

550

551

}

552

#endif

553

554

return rc;

555

}

556

557

/** @copydoc VBOXSERVICE::pfnWorker */

558

DECLCALLBACK(int) VBoxServicePageSharingWorker(bool volatile *pfShutdown)

559

{

560

561

* Tell the control thread that it can continue

562

* spawning services.

563

564

RTThreadUserSignal(RTThreadSelf());

565

566

567

* Now enter the loop retrieving runtime data continuously.

568

569

for (;;)

570

{

571

BOOL fEnabled = VbglR3PageSharingIsEnabled();

572

573

VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: enabled=%d\n", fEnabled);

574

575

if (fEnabled)

576

VBoxServicePageSharingInspectGuest();

577

578

579

* Block for a minute.

580

581

* The event semaphore takes care of ignoring interruptions and it

582

* allows us to implement service wakeup later.

583

584

if (*pfShutdown)

585

break;

586

int rc = RTSemEventMultiWait(g_PageSharingEvent, 60000);

587

if (*pfShutdown)

588

break;

589

if (rc != VERR_TIMEOUT && RT_FAILURE(rc))

590

{

591

VBoxServiceError("VBoxServicePageSharingWorker: RTSemEventMultiWait failed; rc=%Rrc\n", rc);

592

break;

593

}

594

#if defined(RT_OS_WINDOWS) && !defined(TARGET_NT4)

595

uint64_t idNewSession = g_idSession;

596

rc = VbglR3GetSessionId(&idNewSession);

597

AssertRC(rc);

598

599

if (idNewSession != g_idSession)

600

{

601

bool fUnregister = false;

602

603

VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: VM was restored!!\n");

604

/* The VM was restored, so reregister all modules the next time. */

605

RTAvlPVDestroy(&g_pKnownModuleTree, VBoxServicePageSharingEmptyTreeCallback, &fUnregister);

606

g_pKnownModuleTree = NULL;

607

608

g_idSession = idNewSession;

609

}

610

#endif

611

}

612

613

RTSemEventMultiDestroy(g_PageSharingEvent);

614

g_PageSharingEvent = NIL_RTSEMEVENTMULTI;

615

616

VBoxServiceVerbose(3, "VBoxServicePageSharingWorker: finished thread\n");

617

return 0;

618

}

619

620

#ifdef RT_OS_WINDOWS

621

622

/**

623

* This gets control when VBoxService is launched with -pagefusionfork by

624

* VBoxServicePageSharingWorkerProcess().

625

626

* @returns RTEXITCODE_SUCCESS.

627

628

* @remarks It won't normally return since the parent drops the shutdown hint

629

* via RTProcTerminate().

630

631

RTEXITCODE VBoxServicePageSharingInitFork(void)

632

{

633

VBoxServiceVerbose(3, "VBoxServicePageSharingInitFork\n");

634

635

bool fShutdown = false;

636

VBoxServicePageSharingInit();

637

VBoxServicePageSharingWorker(&fShutdown);

638

639

return RTEXITCODE_SUCCESS;

640

}

641

642

/** @copydoc VBOXSERVICE::pfnWorker */

643

DECLCALLBACK(int) VBoxServicePageSharingWorkerProcess(bool volatile *pfShutdown)

644

{

645

RTPROCESS hProcess = NIL_RTPROCESS;

646

int rc;

647

648

649

* Tell the control thread that it can continue

650

* spawning services.

651

652

RTThreadUserSignal(RTThreadSelf());

653

654

655

* Now enter the loop retrieving runtime data continuously.

656

657

for (;;)

658

{

659

BOOL fEnabled = VbglR3PageSharingIsEnabled();

660

VBoxServiceVerbose(3, "VBoxServicePageSharingWorkerProcess: enabled=%d\n", fEnabled);

661

662

663

* Start a 2nd VBoxService process to deal with page fusion as we do

664

* not wish to dummy load dlls into this process. (First load with

665

* DONT_RESOLVE_DLL_REFERENCES, 2nd normal -> dll init routines not called!)

666

667

if ( fEnabled

668

&& hProcess == NIL_RTPROCESS)

669

{

670

char szExeName[256];

671

char *pszExeName = RTProcGetExecutablePath(szExeName, sizeof(szExeName));

672

if (pszExeName)

673

{

674

char const *papszArgs[3];

675

papszArgs[0] = pszExeName;

676

papszArgs[1] = "pagefusion";

677

papszArgs[2] = NULL;

678

rc = RTProcCreate(pszExeName, papszArgs, RTENV_DEFAULT, 0 /* normal child */, &hProcess);

679

if (RT_FAILURE(rc))

680

VBoxServiceError("VBoxServicePageSharingWorkerProcess: RTProcCreate %s failed; rc=%Rrc\n", pszExeName, rc);

681

}

682

}

683

684

685

* Block for a minute.

686

687

* The event semaphore takes care of ignoring interruptions and it

688

* allows us to implement service wakeup later.

689

690

if (*pfShutdown)

691

break;

692

rc = RTSemEventMultiWait(g_PageSharingEvent, 60000);

693

if (*pfShutdown)

694

break;

695

if (rc != VERR_TIMEOUT && RT_FAILURE(rc))

696

{

697

VBoxServiceError("VBoxServicePageSharingWorkerProcess: RTSemEventMultiWait failed; rc=%Rrc\n", rc);

698

break;

699

}

700

}

701

702

if (hProcess != NIL_RTPROCESS)

703

RTProcTerminate(hProcess);

704

705

RTSemEventMultiDestroy(g_PageSharingEvent);

706

g_PageSharingEvent = NIL_RTSEMEVENTMULTI;

707

708

VBoxServiceVerbose(3, "VBoxServicePageSharingWorkerProcess: finished thread\n");

709

return 0;

710

}

711

712

#endif /* RT_OS_WINDOWS */

713

714

/** @copydoc VBOXSERVICE::pfnStop */

715

static DECLCALLBACK(void) VBoxServicePageSharingStop(void)

716

{

717

RTSemEventMultiSignal(g_PageSharingEvent);

718

}

719

720

721

/**

722

* The 'pagesharing' service description.

723

724

VBOXSERVICE g_PageSharing =

725

{

726

/* pszName. */

727

"pagesharing",

728

/* pszDescription. */

729

"Page Sharing",

730

/* pszUsage. */

731

NULL,

732

/* pszOptions. */

733

NULL,

734

/* methods */

735

VBoxServiceDefaultPreInit,

736

VBoxServiceDefaultOption,

737

VBoxServicePageSharingInit,

738

#ifdef RT_OS_WINDOWS

739

VBoxServicePageSharingWorkerProcess,

740

#else

741

VBoxServicePageSharingWorker,

742

#endif

743

VBoxServicePageSharingStop,

744

VBoxServiceDefaultTerm

745

};

Older »