ovr_sdk: f12a8f74fe1f LibOVR/Src/Kernel/OVR

306 SharedMemoryInternal* SharedMemoryInternal::AttemptCreateSharedMemory(const char* fileName, int minSize, bool openReadOnly, bool allowRemoteWrite)

307 {

308 // Prepare a SECURITY_ATTRIBUTES object

309 SECURITY_ATTRIBUTES security;

310 ZeroMemory(&security, sizeof(security));

311 security.nLength = sizeof(security);

312

313 // Security descriptor by DACL strings:

314 // ACE strings grant Allow(A), Object/Contains Inheritance (OICI) of:

315 // + Grant All (GA) to System (SY)

316 // + Grant All (GA) to Built-in Administrators (BA)

317 // + Grant Read-Only (GR) or Read-Write (GWGR) to Interactive Users (IU) - ie. games

318 static const char* DACLString_ReadOnly = "D:P(A;OICI;GA;;;SY)(A;OICI;GA;;;BA)(A;OICI;GR;;;IU)";

319 static const char* DACLString_ReadWrite = "D:P(A;OICI;GA;;;SY)(A;OICI;GA;;;BA)(A;OICI;GWGR;;;IU)";

320

321 // Select the remote process access mode

322 const char* remoteAccessString =

323 allowRemoteWrite ? DACLString_ReadWrite : DACLString_ReadOnly;

324

325 // Attempt to convert access string to security attributes

326 // Note: This will allocate the security descriptor with LocalAlloc() and must be freed later

327 BOOL bConvertOkay = ConvertStringSecurityDescriptorToSecurityDescriptorA(

328 remoteAccessString, SDDL_REVISION_1, &security.lpSecurityDescriptor, NULL);

329

330 // If conversion fails,

331 if (!bConvertOkay)

332 {

333 OVR_DEBUG_LOG(("[SharedMemory] FAILURE: Unable to convert access string, error code = %d", GetLastError()));

334 return NULL;

335 }

336

337 // Interpret the access mode as a page protection code

338 int pageProtectCode = openReadOnly ? PAGE_READONLY : PAGE_READWRITE;

339

340 // Attempt to create a file mapping

341 HANDLE hFileMapping = CreateFileMappingA(INVALID_HANDLE_VALUE, // From page file

342 &security, // Security attributes

343 pageProtectCode, // Read-only?

344 0, // High word for size = 0

345 minSize, // Low word for size

346 fileName); // Name of global shared memory file

347

348 // Free the security descriptor buffer

349 LocalFree(security.lpSecurityDescriptor);

350

351 // If mapping could not be created,

352 if (NULL == hFileMapping)

353 {

354 OVR_DEBUG_LOG(("[SharedMemory] FAILURE: Unable to create file mapping for %s error code = %d", fileName, GetLastError()));

355 return NULL;

356 }

357

358 #ifndef OVR_ALLOW_CREATE_FILE_MAPPING_IF_EXISTS

359 // If the file mapping already exists,

360 if (GetLastError() == ERROR_ALREADY_EXISTS)

361 {

362 CloseHandle(hFileMapping);

363

364 OVR_DEBUG_LOG(("[SharedMemory] FAILURE: File mapping at %s already exists", fileName));

365 return NULL;

366 }

367 #endif

368

369 // Map the file

370 return DoFileMap(hFileMapping, fileName, openReadOnly, minSize);

371 }

372

373 SharedMemoryInternal* SharedMemoryInternal::CreateSharedMemory(const SharedMemory::OpenParameters& params)

374 {

375 SharedMemoryInternal* retval = NULL;

376

377 // Construct the file mapping name in a Windows-specific way

378 OVR::String fileMappingName = params.globalName;

379 const char *fileName = fileMappingName.ToCStr();

380

381 // Is being opened read-only?

382 const bool openReadOnly = (params.accessMode == SharedMemory::AccessMode_ReadOnly);

383

384 // Try up to 3 times to reduce low-probability failures:

385 static const int ATTEMPTS_MAX = 3;

386 for (int attempts = 0; attempts < ATTEMPTS_MAX; ++attempts)

387 {

388 // If opening should be attempted first,

389 if (params.openMode != SharedMemory::OpenMode_CreateOnly)

390 {

391 // Attempt to open a shared memory map

392 retval = AttemptOpenSharedMemory(fileName, params.minSizeBytes, openReadOnly);

393

394 // If successful,

395 if (retval)

396 {

397 // Done!

398 break;

399 }

400 }

401

402 // If creating the shared memory is also acceptable,

403 if (params.openMode != SharedMemory::OpenMode_OpenOnly)

404 {

405 // Interpret create mode

406 const bool allowRemoteWrite = (params.remoteMode == SharedMemory::RemoteMode_ReadWrite);

407

408 // Attempt to create a shared memory map

409 retval = AttemptCreateSharedMemory(fileName, params.minSizeBytes, openReadOnly, allowRemoteWrite);

410

411 // If successful,

412 if (retval)

413 {

414 // Done!

415 break;

416 }

417 }

418 } // Re-attempt create/open

419

420 // Note: On Windows the initial contents of the region are guaranteed to be zero.

421 return retval;

422 }

423

424 #endif // OVR_OS_WIN32

425

426

427 #if (defined(OVR_OS_LINUX) || defined(OVR_OS_MAC)) && !defined(OVR_FAKE_SHAREDMEMORY)

428

429 // Hidden implementation class for OS-specific behavior

430 class SharedMemoryInternal

431 {

432 public:

433 int FileMapping;

434 void* FileView;

435 int FileSize;

436

437 SharedMemoryInternal(int fileMapping, void* fileView, int fileSize) :

438 FileMapping(fileMapping),

439 FileView(fileView),

440 FileSize(fileSize)

441 {

442 }

443

444 ~SharedMemoryInternal()

445 {

446 // If file view is set,

447 if (FileView)

448 {

449 munmap(FileView, FileSize);

450 FileView = MAP_FAILED;

451 }

452

453 // If file mapping is set,

454 if (FileMapping >= 0)

455 {

456 close(FileMapping);

457 FileMapping = -1;

458 }

459 }

460

461 static SharedMemoryInternal* DoFileMap(int hFileMapping, const char* fileName, bool openReadOnly, int minSize);

462 static SharedMemoryInternal* AttemptOpenSharedMemory(const char* fileName, int minSize, bool openReadOnly);

463 static SharedMemoryInternal* AttemptCreateSharedMemory(const char* fileName, int minSize, bool openReadOnly, bool allowRemoteWrite);

464 static SharedMemoryInternal* CreateSharedMemory(const SharedMemory::OpenParameters& params);

465 };

466

467 SharedMemoryInternal* SharedMemoryInternal::DoFileMap(int hFileMapping, const char* fileName, bool openReadOnly, int minSize)

468 {

469 // Calculate the required flags based on read/write mode

470 int prot = openReadOnly ? PROT_READ : (PROT_READ|PROT_WRITE);

471

472 // Map the file view

473 void* pFileView = mmap(NULL, minSize, prot, MAP_SHARED, hFileMapping, 0);

474

475 if (pFileView == MAP_FAILED)

476 {

477 close(hFileMapping);

478

479 OVR_DEBUG_LOG(("[SharedMemory] FAILURE: Unable to map view of file for %s error code = %d", fileName, errno));

480 OVR_UNUSED(fileName);

481 return NULL;

482 }

483

484 // Create internal representation

485 SharedMemoryInternal* pimple = new SharedMemoryInternal(hFileMapping, pFileView, minSize);

486

487 // If memory allocation fails,

488 if (!pimple)

489 {

490 munmap(pFileView, minSize);

491 close(hFileMapping);

492

493 OVR_DEBUG_LOG(("[SharedMemory] FAILURE: Out of memory"));

494 return NULL;

495 }

496

497 return pimple;

498 }

499

500 SharedMemoryInternal* SharedMemoryInternal::AttemptOpenSharedMemory(const char* fileName, int minSize, bool openReadOnly)

501 {

502 // Calculate permissions and flags based on read/write mode

503 int flags = openReadOnly ? O_RDONLY : O_RDWR;

504 int perms = openReadOnly ? S_IRUSR : (S_IRUSR | S_IWUSR);

505

506 // Attempt to open the shared memory file

507 int hFileMapping = shm_open(fileName, flags, perms);

508

509 // If file was not opened successfully,

510 if (hFileMapping < 0)

511 {

512 OVR_DEBUG_LOG(("[SharedMemory] WARNING: Unable to open file mapping for %s error code = %d (not necessarily bad)", fileName, errno));

513 return NULL;

514 }

515

516 // Map the file

517 return DoFileMap(hFileMapping, fileName, openReadOnly, minSize);

518 }

519

520 SharedMemoryInternal* SharedMemoryInternal::AttemptCreateSharedMemory(const char* fileName, int minSize, bool openReadOnly, bool allowRemoteWrite)

521 {

522 // Create mode

523 // Note: Cannot create the shared memory file read-only because then ftruncate() will fail.

524 int flags = O_CREAT | O_RDWR;

525

526 #ifndef OVR_ALLOW_CREATE_FILE_MAPPING_IF_EXISTS

527 // Require exclusive access when creating (seems like a good idea without trying it yet..)

528 if (shm_unlink(fileName) < 0)

529 {

530 OVR_DEBUG_LOG(("[SharedMemory] WARNING: Unable to unlink shared memory file %s error code = %d", fileName, errno));

531 }

532 flags |= O_EXCL;