Can we lift the name length limitation on semaphores?

[poizan42]

Now that we have more-or-less gotten rid of the path length limitation (#645), could we also get rid of the semaphore name length restriction? The documentation for CreateSemaphore claims that the name is limited to MAX_PATH characters, however testing this shows that the documentation is wrong (at least on Windows 10):

using Microsoft.Win32.SafeHandles;
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace SemaphoreTest
{
    class Program
    {
        [DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, SetLastError = true)]
        private static extern SafeWaitHandle CreateSemaphore(IntPtr lpSecurityAttributes, int initialCount, int maximumCount, string name);
        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool CloseHandle(SafeHandle hObject);
        private static void TestCreateSemaphore(string longName)
        {
            var sem = CreateSemaphore(IntPtr.Zero, 0, 1, longName);
            if (sem.IsInvalid)
            {
                Console.WriteLine("Failed: " + new Win32Exception(Marshal.GetLastWin32Error()));
            }
            else
            {
                Console.WriteLine("OK: " + sem.DangerousGetHandle());
                CloseHandle(sem);
            }
        }
        static void Main(string[] args)
        {
            var longName =
                "!!!!!!!!!!012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + // 100
                "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + // 200
                "012345678901234567890123456789012345678901234567890123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN"; // 260,300
            TestCreateSemaphore(longName);
        }
    }
}

Running this prints OK followed by the handle. Setting a breakpoint before CloseHandle and inspecting the handles shows that the semaphore is indeed created with the full name:

Edit: It would be a good idea if I posted the same code that I ran when I took the screenshot :)

[joshfree]

/cc @JeremyKuhne @ericeil

[ericeil]

I think this would be nice, but am concerned about relying on undocumented OS behavior. Also, this doesn't seem as compelling to me as the long file paths work; file paths are user-visible, so there are good reasons for them to be long. Semaphore names are not visible, and so can be generated any number of ways, including the hashing scheme @poizan42 has already suggested.

[poizan42]

I understand the concern about undocumented behaviour. On the other hand this is a compatibility constraint. There is already going to be applications out there that will stop working if the length limit is enforced, and I don't really see a reason why it should be in the future.

Maybe one of you Microsoft insiders could ask the relevant team whether it's ok to rely on (and in that case the documentation could be updated)?.

[aevitas]

As an aside, while a direct call to CreateSemaphore does work, calling the .NET equivalent: new Semaphore(1,1, "Very long name here"); will indeed throw an ArgumentException if the name is more than 260 characters. Isn't this limitation imposed here by ValidateNewName simply arbitrary at this point if the platform invoked call does work for names longer than MAX_PATH (at least on Windows)?

[poizan42]

Yes that is my point. However the documentation for CreateSemaphore claims that is should have a limit of 260 characters even though that isn't enforced. The real limit is probably 2^15 - 30 or a bit less depending on whether it's a global or local semaphore and what the session id is.

[aevitas]

@poizan42 Agree, it's even more conspicuous that enforcing this limitation or not differs depending on how you create the Semaphore. It's a huge inconsitency at the very least.

[karelz]

We are fine with removing the 'artificial' MAX_PATH enforcement in .NET Core code and leave the limit check on underlying OS.
Just make sure (incl. tests) that the exception is same as it used to be with the MAX_PATH check.

[JeremyKuhne]

I'm fine with removing this as well. Just make sure there is a test that creates a semaphore with a length greater than MAX_PATH (1K would be a good choice) and add a comment that we're letting the API kick back names that are too long rather than pre-validating them.

If, for some reason, we get back an error that says the name is too long (say, with a 10K name or on Windows 7) we should make sure it maps to ArgumentException.

[stephentoub]

Fixed by dotnet/coreclr#18402
cc: @jkotas