Merging internal commits for release/9.0

eng/Versions.props

@@ -227,7 +227,7 @@
     <!-- ICU -->
     <MicrosoftNETCoreRuntimeICUTransportVersion>9.0.0-rtm.26509.1</MicrosoftNETCoreRuntimeICUTransportVersion>
     <!-- MsQuic -->
-    <MicrosoftNativeQuicMsQuicSchannelVersion>2.5.10</MicrosoftNativeQuicMsQuicSchannelVersion>
+    <MicrosoftNativeQuicMsQuicSchannelVersion>2.5.12</MicrosoftNativeQuicMsQuicSchannelVersion>
     <!-- Mono LLVM -->
     <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>19.1.0-alpha.1.26505.5</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
     <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>19.1.0-alpha.1.26505.5</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>

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

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -14,9 +15,15 @@ namespace System.Threading
     /// </summary>
     public sealed partial class Mutex : WaitHandle
     {
+        [FeatureSwitchDefinition("System.Threading.Mutex.UnsafeDefaultMutexScopeGlobal")]
+        private static bool UnsafeDefaultMutexScopeGlobal { get; } =
+            AppContext.TryGetSwitch("System.Threading.Mutex.UnsafeDefaultMutexScopeGlobal", out bool enabled) && enabled;
+
         private void CreateMutexCore(bool initiallyOwned, string? name, out bool createdNew)
         {
-            SafeWaitHandle mutexHandle = CreateMutexCore(initiallyOwned, name, out int errorCode, out string? errorDetails);
+            bool isUserScope = !string.IsNullOrEmpty(name) && !UnsafeDefaultMutexScopeGlobal;
+            SafeWaitHandle mutexHandle =
+                CreateMutexCore(initiallyOwned, name, isUserScope, out int errorCode, out string? errorDetails);
             if (mutexHandle.IsInvalid)
             {
                 mutexHandle.SetHandleAsInvalid();
@@ -42,7 +49,8 @@ private static OpenExistingResult OpenExistingWorker(string name, out Mutex? res
             // 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, isUserScope: !UnsafeDefaultMutexScopeGlobal, out int errorCode, out string? errorDetails);
 
             if (myHandle.IsInvalid)
             {
@@ -86,11 +94,13 @@ public void ReleaseMutex()
         private static unsafe SafeWaitHandle CreateMutexCore(
             bool initialOwner,
             string? name,
+            bool isUserScope,
             out int errorCode,
             out string? errorDetails)
         {
             byte* systemCallErrors = stackalloc byte[SystemCallErrorsBufferSize];
-            SafeWaitHandle mutexHandle = CreateMutex(initialOwner, name, systemCallErrors, SystemCallErrorsBufferSize);
+            SafeWaitHandle mutexHandle =
+                CreateMutex(initialOwner, name, isUserScope, 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 +110,14 @@ 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 isUserScope,
+            out int errorCode,
+            out string? errorDetails)
         {
             byte* systemCallErrors = stackalloc byte[SystemCallErrorsBufferSize];
-            SafeWaitHandle mutexHandle = OpenMutex(name, systemCallErrors, SystemCallErrorsBufferSize);
+            SafeWaitHandle mutexHandle = OpenMutex(name, isUserScope, systemCallErrors, SystemCallErrorsBufferSize);
             errorCode = mutexHandle.IsInvalid ? Marshal.GetLastPInvokeError() : Interop.Errors.ERROR_SUCCESS;
             errorDetails = mutexHandle.IsInvalid ? GetErrorDetails(systemCallErrors) : null;
             return mutexHandle;
@@ -127,9 +141,18 @@ 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 isUserScope,
+            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 isUserScope,
+            byte* systemCallErrors,
+            uint systemCallErrorsBufferSize);
     }
 }

src/coreclr/pal/inc/pal.h

@@ -932,6 +932,7 @@ PALAPI
 PAL_CreateMutexW(
     IN BOOL bInitialOwner,
     IN LPCWSTR lpName,
+    IN BOOL bCurrentUserOnly,
     IN LPSTR lpSystemCallErrors,
     IN DWORD dwSystemCallErrorsBufferSize);
 
@@ -953,6 +954,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
         );
 
@@ -76,8 +78,13 @@ Design
   find any other sync object with a timed wait with the necessary properties, so polling is done for timed waits.
 
 Shared memory files
-- Session-scoped mutexes (name not prefixed, or prefixed with Local) go in /tmp/.dotnet/shm/session<sessionId>/<mutexName>
-- Globally-scoped mutexes (name prefixed with Global) go in /tmp/.dotnet/shm/global/<mutexName>
+- Session-scoped mutexes (name not prefixed, or prefixed with Local) go in
+  <system base>/{.dotnet|.dotnet-uid}/shm/session<sessionId>/<mutexName>
+- Globally-scoped mutexes (name prefixed with Global) go in
+  <system base>/{.dotnet|.dotnet-uid}/shm/global/<mutexName>
+- User-unscoped mutexes use the global shared-files base. User-scoped mutexes use a user-specific system base.
+- In an Apple application-group container, user-scoped mutexes use .dotnet-uid in parallel to the .dotnet directory used by
+  user-unscoped mutexes, preserving the distinction between the scopes within the already-user-specific container.
 - Contains shared state, and is mmap'ped into the process, see SharedMemorySharedDataHeader and NamedMutexSharedData for data
   stored
 - Creation and deletion is synchronized using an exclusive file lock on the shm directory
@@ -94,7 +101,7 @@ Shared memory files
 Lock files when using file locks:
 - In addition to the shared memory file, we need another file for the actual synchronization file lock, since a file lock on the
   shared memory file is used for lifetime purposes.
-- These files go in /tmp/.dotnet/lockfiles/session<sessionId>|global/<mutexName>
+- These files go in <system base>/{.dotnet|.dotnet-uid}/lockfiles/session<sessionId>|global/<mutexName>
 - The file is empty, and is only used for file locks
 
 Process data
@@ -216,10 +223,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(