Why Assembly.Location is not available in a Native AOT shared library?

[ceztko]

I verified that Assembly.Location is not available for a Native AOT compiled shared library. In other words, it doesn't look like it's possibile to know the location of the shared library from code within it. The attached code below is able to identify the path for running shared library in the three major platforms (.dll/win, .dylib/mac, .so/linux), which is available as an extension to the Assemby class and can be retrieve with the call Assembly.GetExecutingAssembly().GuessNativeModuleLocation(), so the question is: are the methods to retrieve the native library location considered unreliable? Does the .NET SDK already provide any method similar to the proposed code below?

static class Extensions
{
    /// <summary>
    /// Try to get the native shared library path
    /// </summary>
    public static string GuessNativeModuleLocation(this Assembly assembly)
    {
        string? path;
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            path = getNativeLibraryLocationWindows(assembly);
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            path = getNativeLibraryLocationApple(assembly);
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            path = getNativeModuleLocationLinux(assembly);
        else
            throw new NotSupportedException($"Unsupported platform {RuntimeInformation.OSDescription}");

        if (path == null)
            throw new Exception("Unable to retrieve the library path");

        return path;
    }

    private static nint getNativeHandle(Assembly assembly)
    {
        var sharedLibraryName = Path.GetFileNameWithoutExtension(assembly.GetName().Name!);
        return NativeLibrary.Load(sharedLibraryName, assembly, null);
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static string getNativeLibraryLocationWindows(Assembly assembly)
    {
        IntPtr handle = IntPtr.Zero;
        try
        {
            handle = getNativeHandle(assembly);
            var fileName = new StringBuilder(255);
            GetModuleFileName(handle, fileName, 255);
            return fileName.ToString();
        }
        finally
        {
            NativeLibrary.Free(handle);
        }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static unsafe string? getNativeLibraryLocationApple(Assembly assembly)
    {
        var mainProgramHandle = NativeLibrary.GetMainProgramHandle();
        var _dyld_image_count = (delegate* unmanaged[Cdecl]<uint>)NativeLibrary.GetExport(mainProgramHandle, "_dyld_image_count");
        var _dyld_get_image_name = (delegate* unmanaged[Cdecl]<uint, IntPtr>)NativeLibrary.GetExport(mainProgramHandle, "_dyld_get_image_name");
        var dlopen = (delegate* unmanaged[Cdecl]<IntPtr, int, IntPtr>)NativeLibrary.GetExport(mainProgramHandle, "dlopen");
        var dlclose = (delegate* unmanaged[Cdecl]<IntPtr, int>)NativeLibrary.GetExport(mainProgramHandle, "dlclose");

        uint count = _dyld_image_count();
        if (count == 0)
            return null;

        for (int i = (int)count - 1; i >= 0; i--)
        {
            IntPtr namePtr = _dyld_get_image_name((uint)i);
            if (namePtr == IntPtr.Zero)
                continue;

            const int RTLD_LAZY = 0x1;
            // Probe by dlopen the image name (this returns an existing handle if already loaded).
            var probeHandle = dlopen(namePtr, RTLD_LAZY);
            if (probeHandle == IntPtr.Zero)
                continue;

            dlclose(probeHandle);
            string? imageName = Marshal.PtrToStringUTF8(namePtr);
            if (!string.IsNullOrEmpty(imageName))
            {
                if (Path.GetFileNameWithoutExtension(imageName) == assembly.GetName()?.Name)
                    return imageName;
            }
        }

        return null;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static unsafe string? getNativeModuleLocationLinux(Assembly assembly)
    {
        IntPtr handle = IntPtr.Zero;
        try
        {
            handle = getNativeHandle(assembly);
            // RTLD_DI_LINKMAP is a GNU extension; value is 2 on glibc.
            const int RTLD_DI_LINKMAP = 2;
            link_map* linkMapPtr;
            var dlinfo = (delegate* unmanaged[Cdecl]<IntPtr, int, link_map**, int>)NativeLibrary.GetExport(NativeLibrary.GetMainProgramHandle(), "dlinfo");
            int rc = dlinfo(handle, RTLD_DI_LINKMAP, &linkMapPtr);
            if (rc != 0 || linkMapPtr == null)
                return null;

            if (linkMapPtr->l_name == IntPtr.Zero)
                return null;

            string? path = Marshal.PtrToStringUTF8(linkMapPtr->l_name);
            return string.IsNullOrWhiteSpace(path) ? null : path!;
        }
        finally
        {
            NativeLibrary.Free(handle);
        }
    }

    // Minimal managed representation of `struct link_map` from <link.h>.
    [StructLayout(LayoutKind.Sequential)]
    struct link_map
    {
        public IntPtr l_addr;   // base address
        public IntPtr l_name;   // char *
        public IntPtr l_ld;     // ElfW(Dyn) *
        public IntPtr l_next;   // struct link_map *
        public IntPtr l_prev;   // struct link_map *
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    static extern uint GetModuleFileName([In] IntPtr hModule, [Out] StringBuilder lpFilename, [In] uint nSize);
}

[huoyaoyuan]

I verified that Assembly.Location is not available for a Native AOT compiled shared library.

It is intentional because assemblies does not map to files after NativeAOT compiling. A native executable or shared library always consists of multiple assemblies. Assembly.Location always returns null under NativeAOT.

so the question is: are the methods to retrieve the native library location considered unreliable

The attached code is incorrect. Although it's a convention that the generated native object matches the name of your entry assembly, it can't match other assemblies used. For example it can never deal with typeof(object).Assembly.

[huoyaoyuan]

If you know other possible failing scenarios feel free to specify them.

The question should be "what scenario such path would work". In NativeAOT you can't do assembly loading etc.

[ceztko]

what scenario such path would work

NativeLibrary.Load() with dependency located relatively to this Native AOT compiled library.

[huoyaoyuan]

In this case, you shouldn't take Assembly in the first place. Since the feature would only run under AOT, you can directly take the OS native API.

[ceztko]

The use of Assembly was basically just to retrieve the alleged shared library name. Probably use of GetModuleHandleEx in windows, or dladdr in posix, passing the address of a [UnmanagedCallersOnly] decorated method would be a more reliable strategy to retrieve the path of the underlying native library, but consider that in some scenarios such entry points are generated (eg. in node-api-dotnet) so it's not always a viable solution.

[ceztko]

I wrote a proof of concept code to determine the shared library path using GetModuleHandleEx in windows, or dladdr in unix on an exported method here.

[ceztko]

Within a Native AOT shared library, a more reliable way to determine the path of the library is to infer it from any exported symbol, even a dummy one. It follows the proof of concept code:

using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace NativeLibraryAOT;

public class Native
{
    [UnmanagedCallersOnly(EntryPoint = "Foo", CallConvs = new[] { typeof(CallConvCdecl) })]
    public unsafe static void Foo()
    {
        var ptr = (delegate* unmanaged[Cdecl]<void>)&Foo;
        var shardLibraryPath = Utils.GetNativeModuleLocation(ptr);
        Console.WriteLine($"Path: {shardLibraryPath}");
    }
}

static class Utils
{
    /// <summary>
    /// Get the native shared library path where this function was exported
    /// </summary>
    public unsafe static string GetNativeModuleLocation(void *funcAddr)
    {
        string? path;
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            path = getNativeLibraryLocationWindows(funcAddr);
        else
            path = getNativeLibraryLocationUnix(funcAddr);

        if (path == null)
            throw new Exception("Unable to retrieve the library path");

        return path;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static unsafe string? getNativeLibraryLocationWindows(void* funcAddr)
    {
        const int MAX_PATH = 260;
        const uint GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 0x00000004;
        const uint GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 0x00000002;

        IntPtr hModule;
        if (!GetModuleHandleEx(
                GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                (IntPtr)funcAddr,
                out hModule))
        {
            throw new Win32Exception(Marshal.GetLastWin32Error(),
                "Can't get the module from the address");
        }

        char* buffer = stackalloc char[MAX_PATH];
        uint rc = GetModuleFileName(hModule, buffer, MAX_PATH);
        if (rc == 0 || rc == MAX_PATH)
        {
            throw new Win32Exception(Marshal.GetLastWin32Error(),
                "Can't get module file name");
        }

        return new string(buffer, 0, (int)rc);
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static unsafe string? getNativeLibraryLocationUnix(void* funcAddr)
    {
        Dl_info dl_info;
        var dladdr = (delegate* unmanaged[Cdecl]<void*, Dl_info*, int>)NativeLibrary.GetExport(NativeLibrary.GetMainProgramHandle(), "dladdr");
        if (dladdr(funcAddr, &dl_info) == 0)
            return null;
        
        return Marshal.PtrToStringUTF8(dl_info.dli_fname);
    }

    [StructLayout(LayoutKind.Sequential)]
    struct Dl_info
    {
        public IntPtr dli_fname;
        public IntPtr dli_fbase;
        public IntPtr dli_sname;
        public IntPtr dli_saddr;
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool GetModuleHandleEx(
        uint dwFlags,
        IntPtr lpModuleName,
        out IntPtr phModule);

    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    private unsafe static extern uint GetModuleFileName(
        IntPtr hModule,
        char* lpFilename,
        uint nSize);
}