Add the CurrentUserOnly and CurrentSessionOnly options for named Mutex, Semaphore, and EventWaitHandle (#112213)

- In `Mutex`, `Semaphore`, and `EventWaitHandle`, added overloads for methods with a `name` argument to also include a `NamedWaitHandleOptions options` argument. The `CurrentUserOnly` option indicates whether the object should be limited in access to the current user. The `CurrentSessionOnly` option indicates whether the object object is intended to be used only within the current session (an alternative to the name prefixes, such as `Global\`). The default value for `NamedWaitHandleOptions` has `CurrentUserOnly=true` and `CurrentSessionOnly=true`.
- On Unixes, named semaphores and events are not supported. Named mutexes are have a functional implementation on Unixes in CoreCLR. NativeAOT and Mono on Unixes use an incomplete/temporary implementation where named mutexes are just process-local mutexes stored in a dictionary keyed by the name and can't be used to synchronize between processes. This change only briefly extends the NativeAOT/Mono implementation to add another prefix to the name when `CurrentUserOnly=true`. Sharing the CoreCLR Unix named mutex implementation with NativeAOT/Mono is left to a separate change. Most of what is described below when `CurrentUserOnly=true` on Unixes refers to the CoreCLR implementation.
- The plan is to also deprecate the APIs with a `name` argument but without an `options` argument in a separate change
- API review: #102682 (comment)

### Windows with `CurrentUserOnly=true`

When creating a named mutex, a security descriptor is created and assigned to the object.

- The owner and group are set to the current user
- The DACL has two ACEs:
  - One ACE allows the current user the relevant access rights
  - Another ACE allows the `BUILTIN\Administrators` group the `READ_CONTROL` access right to enable reading the security info for diagnostic purposes
- The SACL has a mandatory label ACE
  - The access policy prevents principals with an integrity level lower than the object from opening the object
  - The integrity level assigned to the object is the same as what would be assigned by the system by default
- When opening a named mutex, the owner and DACL are verified to see if they are as expected, and if not, a `WaitHandleCannotBeOpenedException` is thrown
- Access controls are set when creating an object and checked when opening an object. Once a handle to the object is obtained, typical synchronization operations may not do further access checks. It's up to the caller to be careful about how the handle to the object is passed around.

### Unixes with `CurrentUserOnly=true`

- Files relevant to named mutexes (shared memory and lock files) go under `/tmp/.dotnet-uidN/` where `N` is the effective user ID
  - `/tmp/` (or equivalent) was chosen mainly for the automatic cleanup, as the number of files can add up in cases where mutexes are not disposed, particularly when randomly generated names are used upon each invocation of a process. Due to the use of a global location `/tmp/` or equivalent, it would be possible for a user to deny access to the `.dotnet-uidN` directory of a different user if the directory hadn't been created yet. An alternative considered was to use the home directory and introduce some kind of periodic cleanup strategy, but there are also other tradeoffs.
- `/tmp/` or equivalent must either have the sticky bit, or it must be owned by the current user and without write access for any other user. Otherwise, an exception is thrown.
- Permissions of the `/tmp/.dotnet-uidN/` directory and files/directories under it are limited in access to the current user
- When opening a named mutex, the owner and permissions of relevant files/directories are verified to see if they are as expected, and if not, an exception is thrown
- Access controls are set when creating an object and checked when opening an object. Once a handle to the object is obtained, typical synchronization operations may not do further access checks. It's up to the caller to be careful about how the handle to the object is passed around.

### Namespaces

  - On Windows, there is no namespace for kernel objects for each user. `CurrentSessionOnly=true` is close, but it is possible for multiple users to be running code simultaneously in the same session. There is a global namespace, and a namespace per session. When `CurrentUserOnly=true`, callers may need to ensure that the name used is distinguished for different users.
  - On Unixes, a different directory tree is used when `CurrentUserOnly=true`, so each user has a separate namespace for objects, including for session-scoped and session-unscoped objects.

Author: kouvel

src/coreclr/System.Private.CoreLib/src/System/Threading/Mutex.CoreCLR.Unix.cs

@@ -14,9 +14,40 @@ namespace System.Threading
     /// </summary>
     public sealed partial class Mutex : WaitHandle
     {
-        private void CreateMutexCore(bool initiallyOwned, string? name, out bool createdNew)
+        private unsafe void CreateMutexCore(bool initiallyOwned)
         {
-            SafeWaitHandle mutexHandle = CreateMutexCore(initiallyOwned, name, out int errorCode, out string? errorDetails);
+            SafeWaitHandle handle =
+                CreateMutex(
+                    initiallyOwned,
+                    name: null,
+                    currentUserOnly: false,
+                    systemCallErrors: null,
+                    systemCallErrorsBufferSize: 0);
+            if (handle.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+                handle.SetHandleAsInvalid();
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode);
+            }
+
+            SafeWaitHandle = handle;
+        }
+
+        private void CreateMutexCore(
+            bool initiallyOwned,
+            string? name,
+            NamedWaitHandleOptionsInternal options,
+            out bool createdNew)
+        {
+            bool currentUserOnly = false;
+            if (!string.IsNullOrEmpty(name) && options.WasSpecified)
+            {
+                name = options.GetNameWithSessionPrefix(name);
+                currentUserOnly = options.CurrentUserOnly;
+            }
+
+            SafeWaitHandle mutexHandle =
+                CreateMutexCore(initiallyOwned, name, currentUserOnly, out int errorCode, out string? errorDetails);
             if (mutexHandle.IsInvalid)
             {
                 mutexHandle.SetHandleAsInvalid();
@@ -33,16 +64,26 @@ private void CreateMutexCore(bool initiallyOwned, string? name, out bool created
             SafeWaitHandle = mutexHandle;
         }
 
-        private static OpenExistingResult OpenExistingWorker(string name, out Mutex? result)
+        private static OpenExistingResult OpenExistingWorker(
+            string name,
+            NamedWaitHandleOptionsInternal options,
+            out Mutex? result)
         {
             ArgumentException.ThrowIfNullOrEmpty(name);
 
+            bool currentUserOnly = false;
+            if (options.WasSpecified)
+            {
+                name = options.GetNameWithSessionPrefix(name);
+                currentUserOnly = options.CurrentUserOnly;
+            }
+
             result = null;
             // To allow users to view & edit the ACL's, call OpenMutex
             // with parameters to allow us to view & edit the ACL.  This will
             // fail if we don't have permission to view or edit the ACL's.
             // If that happens, ask for less permissions.
-            SafeWaitHandle myHandle = OpenMutexCore(name, out int errorCode, out string? errorDetails);
+            SafeWaitHandle myHandle = OpenMutexCore(name, currentUserOnly, out int errorCode, out string? errorDetails);
 
             if (myHandle.IsInvalid)
             {
@@ -86,11 +127,13 @@ public void ReleaseMutex()
         private static unsafe SafeWaitHandle CreateMutexCore(
             bool initialOwner,
             string? name,
+            bool currentUserOnly,
             out int errorCode,
             out string? errorDetails)
         {
             byte* systemCallErrors = stackalloc byte[SystemCallErrorsBufferSize];
-            SafeWaitHandle mutexHandle = CreateMutex(initialOwner, name, systemCallErrors, SystemCallErrorsBufferSize);
+            SafeWaitHandle mutexHandle =
+                CreateMutex(initialOwner, name, currentUserOnly, systemCallErrors, SystemCallErrorsBufferSize);
 
             // Get the error code even if the handle is valid, as it could be ERROR_ALREADY_EXISTS, indicating that the mutex
             // already exists and was opened
@@ -100,10 +143,10 @@ private static unsafe SafeWaitHandle CreateMutexCore(
             return mutexHandle;
         }
 
-        private static unsafe SafeWaitHandle OpenMutexCore(string name, out int errorCode, out string? errorDetails)
+        private static unsafe SafeWaitHandle OpenMutexCore(string name, bool currentUserOnly, out int errorCode, out string? errorDetails)
         {
             byte* systemCallErrors = stackalloc byte[SystemCallErrorsBufferSize];
-            SafeWaitHandle mutexHandle = OpenMutex(name, systemCallErrors, SystemCallErrorsBufferSize);
+            SafeWaitHandle mutexHandle = OpenMutex(name, currentUserOnly, systemCallErrors, SystemCallErrorsBufferSize);
             errorCode = mutexHandle.IsInvalid ? Marshal.GetLastPInvokeError() : Interop.Errors.ERROR_SUCCESS;
             errorDetails = mutexHandle.IsInvalid ? GetErrorDetails(systemCallErrors) : null;
             return mutexHandle;
@@ -127,9 +170,9 @@ private static unsafe SafeWaitHandle OpenMutexCore(string name, out int errorCod
         }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "PAL_CreateMutexW", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
-        private static unsafe partial SafeWaitHandle CreateMutex([MarshalAs(UnmanagedType.Bool)] bool initialOwner, string? name, byte* systemCallErrors, uint systemCallErrorsBufferSize);
+        private static unsafe partial SafeWaitHandle CreateMutex([MarshalAs(UnmanagedType.Bool)] bool initialOwner, string? name, [MarshalAs(UnmanagedType.Bool)] bool currentUserOnly, byte* systemCallErrors, uint systemCallErrorsBufferSize);
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "PAL_OpenMutexW", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
-        private static unsafe partial SafeWaitHandle OpenMutex(string name, byte* systemCallErrors, uint systemCallErrorsBufferSize);
+        private static unsafe partial SafeWaitHandle OpenMutex(string name, [MarshalAs(UnmanagedType.Bool)] bool currentUserOnly, byte* systemCallErrors, uint systemCallErrorsBufferSize);
     }
 }

src/coreclr/pal/inc/pal.h

@@ -854,6 +854,7 @@ PALAPI
 PAL_CreateMutexW(
     IN BOOL bInitialOwner,
     IN LPCWSTR lpName,
+    IN BOOL bCurrentUserOnly,
     IN LPSTR lpSystemCallErrors,
     IN DWORD dwSystemCallErrorsBufferSize);
 
@@ -875,6 +876,7 @@ HANDLE
 PALAPI
 PAL_OpenMutexW(
        IN LPCWSTR lpName,
+       IN BOOL bCurrentUserOnly,
        IN LPSTR lpSystemCallErrors,
        IN DWORD dwSystemCallErrorsBufferSize);
 

src/coreclr/pal/inc/pal_error.h

@@ -147,7 +147,6 @@
 #define ERROR_PALINIT_TLS 65295L
 #define ERROR_PALINIT_ENV 65296L
 #define ERROR_PALINIT_DBG_CHANNELS 65297L
-#define ERROR_PALINIT_SHARED_MEMORY_MANAGER 65298L
 #define ERROR_PALINIT_SHM 65299L
 #define ERROR_PALINIT_MODULE_MANAGER 65300L
 

src/coreclr/pal/src/include/pal/mutex.hpp

@@ -37,6 +37,7 @@ namespace CorUnix
         LPSECURITY_ATTRIBUTES lpMutexAttributes,
         BOOL bInitialOwner,
         LPCSTR lpName,
+        BOOL bCurrentUserOnly,
         HANDLE *phMutex
         );
 
@@ -51,6 +52,7 @@ namespace CorUnix
         SharedMemorySystemCallErrors *errors,
         CPalThread *pThread,
         LPCSTR lpName,
+        BOOL bCurrentUserOnly,
         HANDLE *phMutex
         );
 
@@ -216,10 +218,10 @@ class NamedMutexProcessData : public SharedMemoryProcessDataBase
     bool m_hasRefFromLockOwnerThread;
 
 public:
-    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, bool acquireLockIfCreated, bool *createdRef);
-    static SharedMemoryProcessDataHeader *Open(SharedMemorySystemCallErrors *errors, LPCSTR name);
+    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, bool isUserScope, bool acquireLockIfCreated, bool *createdRef);
+    static SharedMemoryProcessDataHeader *Open(SharedMemorySystemCallErrors *errors, LPCSTR name, bool isUserScope);
 private:
-    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, bool createIfNotExist, bool acquireLockIfCreated, bool *createdRef);
+    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, bool isUserScope, bool createIfNotExist, bool acquireLockIfCreated, bool *createdRef);
 
 public:
     NamedMutexProcessData(

src/coreclr/pal/src/include/pal/sharedmemory.h

@@ -27,27 +27,26 @@
 #define SHARED_MEMORY_MAX_FILE_NAME_CHAR_COUNT (_MAX_FNAME - 1)
 #define SHARED_MEMORY_MAX_NAME_CHAR_COUNT (STRING_LENGTH("Global\\") + SHARED_MEMORY_MAX_FILE_NAME_CHAR_COUNT)
 
-#define SHARED_MEMORY_RUNTIME_TEMP_DIRECTORY_NAME ".dotnet"
-#define SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_NAME ".dotnet/shm"
-#define SHARED_MEMORY_LOCK_FILES_DIRECTORY_NAME ".dotnet/lockfiles"
-static_assert_no_msg(ARRAY_SIZE(SHARED_MEMORY_LOCK_FILES_DIRECTORY_NAME) >= ARRAY_SIZE(SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_NAME));
+#define SHARED_MEMORY_USER_UNSCOPED_RUNTIME_TEMP_DIRECTORY_NAME ".dotnet"
+#define SHARED_MEMORY_USER_SCOPED_RUNTIME_TEMP_DIRECTORY_NAME_PREFIX ".dotnet-uid"
+#define SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_NAME "shm"
+#define SHARED_MEMORY_LOCK_FILES_DIRECTORY_NAME "lockfiles"
+static_assert_no_msg(STRING_LENGTH(SHARED_MEMORY_LOCK_FILES_DIRECTORY_NAME) >= STRING_LENGTH(SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_NAME));
 
 #define SHARED_MEMORY_GLOBAL_DIRECTORY_NAME "global"
 #define SHARED_MEMORY_SESSION_DIRECTORY_NAME_PREFIX "session"
-static_assert_no_msg(ARRAY_SIZE(SHARED_MEMORY_SESSION_DIRECTORY_NAME_PREFIX) >= ARRAY_SIZE(SHARED_MEMORY_GLOBAL_DIRECTORY_NAME));
 
-#define SHARED_MEMORY_UNIQUE_TEMP_NAME_TEMPLATE ".coreclr.XXXXXX"
-
-#define SHARED_MEMORY_MAX_SESSION_ID_CHAR_COUNT (10)
+#define SHARED_MEMORY_UNIQUE_TEMP_NAME_TEMPLATE ".dotnet.XXXXXX"
 
 // Note that this Max size does not include the prefix folder path size which is unknown (in the case of sandbox) until runtime
 #define SHARED_MEMORY_MAX_FILE_PATH_CHAR_COUNT \
     ( \
+        STRING_LENGTH(SHARED_MEMORY_USER_SCOPED_RUNTIME_TEMP_DIRECTORY_NAME_PREFIX) + \
+        11 /* user ID, path separator */ + \
         STRING_LENGTH(SHARED_MEMORY_LOCK_FILES_DIRECTORY_NAME) + \
         1 /* path separator */ + \
         STRING_LENGTH(SHARED_MEMORY_SESSION_DIRECTORY_NAME_PREFIX) + \
-        SHARED_MEMORY_MAX_SESSION_ID_CHAR_COUNT + \
-        1 /* path separator */ + \
+        11 /* session ID, path separator */ + \
         SHARED_MEMORY_MAX_FILE_NAME_CHAR_COUNT \
     )
 
@@ -98,12 +97,17 @@ class SharedMemorySystemCallErrors
     void Append(LPCSTR format, ...);
 };
 
+class SharedMemoryId;
+
 class SharedMemoryHelpers
 {
 private:
-    static const mode_t PermissionsMask_CurrentUser_ReadWriteExecute;
+    static const mode_t PermissionsMask_OwnerUser_ReadWrite;
+    static const mode_t PermissionsMask_OwnerUser_ReadWriteExecute;
+    static const mode_t PermissionsMask_NonOwnerUsers_Write;
     static const mode_t PermissionsMask_AllUsers_ReadWrite;
     static const mode_t PermissionsMask_AllUsers_ReadWriteExecute;
+    static const mode_t PermissionsMask_Sticky;
 public:
     static const UINT32 InvalidProcessId;
     static const SIZE_T InvalidThreadId;
@@ -114,17 +118,14 @@ class SharedMemoryHelpers
     static SIZE_T AlignUp(SIZE_T value, SIZE_T alignment);
 
     static void *Alloc(SIZE_T byteCount);
-
-    template<SIZE_T SuffixByteCount> static void BuildSharedFilesPath(PathCharString& destination, const char (&suffix)[SuffixByteCount]);
-    static void BuildSharedFilesPath(PathCharString& destination, const char *suffix, int suffixByteCount);
     static bool AppendUInt32String(PathCharString& destination, UINT32 value);
 
-    static bool EnsureDirectoryExists(SharedMemorySystemCallErrors *errors, const char *path, bool isGlobalLockAcquired, bool createIfNotExist = true, bool isSystemDirectory = false);
+    static bool EnsureDirectoryExists(SharedMemorySystemCallErrors *errors, const char *path, const SharedMemoryId *id, bool isGlobalLockAcquired, bool createIfNotExist = true, bool isSystemDirectory = false);
 private:
     static int Open(SharedMemorySystemCallErrors *errors, LPCSTR path, int flags, mode_t mode = static_cast<mode_t>(0));
 public:
     static int OpenDirectory(SharedMemorySystemCallErrors *errors, LPCSTR path);
-    static int CreateOrOpenFile(SharedMemorySystemCallErrors *errors, LPCSTR path, bool createIfNotExist = true, bool *createdRef = nullptr);
+    static int CreateOrOpenFile(SharedMemorySystemCallErrors *errors, LPCSTR path, const SharedMemoryId *id, bool createIfNotExist = true, bool *createdRef = nullptr);
     static void CloseFile(int fileDescriptor);
 
     static int ChangeMode(LPCSTR path, mode_t mode);
@@ -150,19 +151,24 @@ class SharedMemoryId
     LPCSTR m_name;
     SIZE_T m_nameCharCount;
     bool m_isSessionScope; // false indicates global scope
+    bool m_isUserScope;
+    uid_t m_userScopeUid;
 
 public:
     SharedMemoryId();
-    SharedMemoryId(LPCSTR name, SIZE_T nameCharCount, bool isSessionScope);
-    SharedMemoryId(LPCSTR name);
+    SharedMemoryId(LPCSTR name, bool isUserScope);
 
 public:
     LPCSTR GetName() const;
     SIZE_T GetNameCharCount() const;
+    void ReplaceNamePtr(LPCSTR name);
     bool IsSessionScope() const;
-    bool Equals(SharedMemoryId *other) const;
+    bool IsUserScope() const;
+    uid_t GetUserScopeUid() const;
+    bool Equals(const SharedMemoryId *other) const;
 
 public:
+    bool AppendRuntimeTempDirectoryName(PathCharString& path) const;
     bool AppendSessionDirectoryName(PathCharString& path) const;
 };
 
@@ -222,22 +228,22 @@ class SharedMemoryProcessDataHeader
     SharedMemoryProcessDataHeader *m_nextInProcessDataHeaderList;
 
 public:
-    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, SharedMemorySharedDataHeader requiredSharedDataHeader, SIZE_T sharedDataByteCount, bool createIfNotExist, bool *createdRef);
+    static SharedMemoryProcessDataHeader *CreateOrOpen(SharedMemorySystemCallErrors *errors, LPCSTR name, bool isUserScope, SharedMemorySharedDataHeader requiredSharedDataHeader, SIZE_T sharedDataByteCount, bool createIfNotExist, bool *createdRef);
 
 public:
     static SharedMemoryProcessDataHeader *PalObject_GetProcessDataHeader(CorUnix::IPalObject *object);
     static void PalObject_SetProcessDataHeader(CorUnix::IPalObject *object, SharedMemoryProcessDataHeader *processDataHeader);
     static void PalObject_Close(CorUnix::CPalThread *thread, CorUnix::IPalObject *object, bool isShuttingDown);
 
 private:
-    SharedMemoryProcessDataHeader(SharedMemoryId *id, int fileDescriptor, SharedMemorySharedDataHeader *sharedDataHeader, SIZE_T sharedDataTotalByteCount);
+    SharedMemoryProcessDataHeader(const SharedMemoryId *id, int fileDescriptor, SharedMemorySharedDataHeader *sharedDataHeader, SIZE_T sharedDataTotalByteCount);
 public:
-    static SharedMemoryProcessDataHeader *New(SharedMemoryId *id, int fileDescriptor, SharedMemorySharedDataHeader *sharedDataHeader, SIZE_T sharedDataTotalByteCount);
+    static SharedMemoryProcessDataHeader *New(const SharedMemoryId *id, int fileDescriptor, SharedMemorySharedDataHeader *sharedDataHeader, SIZE_T sharedDataTotalByteCount);
     ~SharedMemoryProcessDataHeader();
     void Close();
 
 public:
-    SharedMemoryId *GetId();
+    const SharedMemoryId *GetId() const;
     SharedMemoryProcessDataBase *GetData() const;
     void SetData(SharedMemoryProcessDataBase *data);
     SharedMemorySharedDataHeader *GetSharedDataHeader() const;
@@ -256,8 +262,24 @@ class SharedMemoryManager
     static CRITICAL_SECTION s_creationDeletionProcessLock;
     static int s_creationDeletionLockFileDescriptor;
 
-    static PathCharString* s_runtimeTempDirectoryPath;
-    static PathCharString* s_sharedMemoryDirectoryPath;
+    struct UserScopeUidAndFileDescriptor
+    {
+        uid_t userScopeUid;
+        int fileDescriptor;
+
+        UserScopeUidAndFileDescriptor() : userScopeUid((uid_t)0), fileDescriptor(-1)
+        {
+        }
+
+        UserScopeUidAndFileDescriptor(uid_t userScopeUid, int fileDescriptor)
+            : userScopeUid(userScopeUid), fileDescriptor(fileDescriptor)
+        {
+        }
+    };
+
+    static UserScopeUidAndFileDescriptor *s_userScopeUidToCreationDeletionLockFDs;
+    static int s_userScopeUidToCreationDeletionLockFDsCount;
+    static int s_userScopeUidToCreationDeletionLockFDsCapacity;
 
 private:
     static SharedMemoryProcessDataHeader *s_processDataHeaderListHead;
@@ -269,17 +291,16 @@ class SharedMemoryManager
 #endif // _DEBUG
 
 public:
-    static bool StaticInitialize();
+    static void StaticInitialize();
     static void StaticClose();
 
 public:
     static void AcquireCreationDeletionProcessLock();
     static void ReleaseCreationDeletionProcessLock();
-    static void AcquireCreationDeletionFileLock(SharedMemorySystemCallErrors *errors);
-    static void ReleaseCreationDeletionFileLock();
-
-public:
-    static bool CopySharedMemoryBasePath(PathCharString& destination);
+    static void AcquireCreationDeletionFileLock(SharedMemorySystemCallErrors *errors, const SharedMemoryId *id);
+    static void ReleaseCreationDeletionFileLock(const SharedMemoryId *id);
+    static void AddUserScopeUidCreationDeletionLockFD(uid_t userScopeUid, int creationDeletionLockFD);
+    static int FindUserScopeCreationDeletionLockFD(uid_t userScopeUid);
 
 #ifdef _DEBUG
 public:
@@ -290,7 +311,7 @@ class SharedMemoryManager
 public:
     static void AddProcessDataHeader(SharedMemoryProcessDataHeader *processDataHeader);
     static void RemoveProcessDataHeader(SharedMemoryProcessDataHeader *processDataHeader);
-    static SharedMemoryProcessDataHeader *FindProcessDataHeader(SharedMemoryId *id);
+    static SharedMemoryProcessDataHeader *FindProcessDataHeader(const SharedMemoryId *id);
 };
 
 #endif // !_PAL_SHARED_MEMORY_H_

src/coreclr/pal/src/include/pal/sharedmemory.inl

@@ -410,12 +410,7 @@ Initialize(
             // we use large numbers of threads or have many open files.
         }
 
-        if (!SharedMemoryManager::StaticInitialize())
-        {
-            ERROR("Shared memory static initialization failed!\n");
-            palError = ERROR_PALINIT_SHARED_MEMORY_MANAGER;
-            goto CLEANUP1;
-        }
+        SharedMemoryManager::StaticInitialize();
 
         //
         // Initialize global process data