IKVM.Runtime.JNI.JNINativeLoader Class Reference

Static Public Member Functions
static long	LoadLibrary (string filename, RuntimeJavaType fromClass)
	Initiates a load of the given JNI library by the specified class loader.
static void	UnloadLibrary (long handle, RuntimeJavaType fromClass)
	Initiates an unload of the given native library for the specified class loader.

Static Public Attributes
static readonly object	SyncRoot = new object()

Detailed Description

Manages the set of loaded native JNI libraries.

Definition at line 38 of file JNINativeLoader.cs.

Member Function Documentation

LoadLibrary()

static long IKVM.Runtime.JNI.JNINativeLoader.LoadLibrary ( string filename, RuntimeJavaType fromClass )

static

Initiates a load of the given JNI library by the specified class loader.

Parameters

filename
fromClass

Returns

Definition at line 53 of file JNINativeLoader.cs.

        {
            JVM.Context.Diagnostics.GenericJniInfo($"loadLibrary: '{filename}' fromClass '{fromClass}'");
 
            lock (SyncRoot)
            {
                nint p = 0;
 
                try
                {
                    // attempt to load the native library
                    if ((p = LibJvm.Instance.JVM_LoadLibrary(filename)) == 0)
                    {
                        JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', message = {"NULL handle returned."}");
                        return 0;
                    }
 
                    // find whether the native library was already loaded
                    foreach (var h in fromClass.ClassLoader.GetNativeLibraries())
                    {
                        if (h == p)
                        {
                            LibJvm.Instance.JVM_UnloadLibrary(p);
                            JVM.Context.Diagnostics.GenericJniWarning("Library was already loaded, returning same reference");
                            return p;
                        }
                    }
 
                    // library was loaded by another classloader, that's a link error
                    if (loaded.Contains(p))
                    {
                        var msg = $"Native library '{filename}' already loaded in another classloader.";
                        JVM.Context.Diagnostics.GenericJniError($"UnsatisfiedLinkError: {msg}");
                        throw new java.lang.UnsatisfiedLinkError(msg);
                    }
 
                    JVM.Context.Diagnostics.GenericJniInfo($"Library loaded: {filename}, handle = 0x{p:X}");
 
                    try
                    {
                        var onload = LibJvm.Instance.JVM_FindLibraryEntry(p, NativeLibrary.MangleExportName("JNI_OnLoad", sizeof(nint) + sizeof(nint)));
                        if (onload != 0)
                        {
                            JVM.Context.Diagnostics.GenericJniInfo($"Calling JNI_OnLoad on: {filename}");
                            var f = new JNIFrame();
                            int v;
                            var w = f.Enter(ikvm.@internal.CallerID.create(fromClass.ClassObject, fromClass.ClassObject.getClassLoader()));
                            try
                            {
                                v = Marshal.GetDelegateForFunctionPointer<JNI_OnLoadFunc>(onload)(JavaVM.pJavaVM, null);
                                JVM.Context.Diagnostics.GenericJniInfo($"JNI_OnLoad returned: 0x{v:X8}");
                            }
                            finally
                            {
                                f.Leave();
                            }
 
                            if (JNIVM.IsSupportedJNIVersion(v) == false)
                            {
                                var msg = $"Unsupported JNI version 0x{v:X} required by {filename}";
                                JVM.Context.Diagnostics.GenericJniError($"UnsatisfiedLinkError: {msg}");
                                throw new java.lang.UnsatisfiedLinkError(msg);
                            }
                        }
                    }
                    catch (EntryPointNotFoundException)
                    {
                        // JNI_OnLoad entry point doesn't exist and isn't required
                    }
 
                    // record addition of native library
                    loaded.Add(p);
                    fromClass.ClassLoader.RegisterNativeLibrary(p);
                    return p;
                }
                catch (DllNotFoundException e)
                {
                    JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', error = DllNotFoundException, message = {e.Message}");
                    return 0;
                }
                catch (Exception e)
                {
                    JVM.Context.Diagnostics.GenericJniInfo($"Failed to load library: path = '{filename}', error = Exception, message = {e.Message}");
                    LibJvm.Instance.JVM_UnloadLibrary(p);
                    throw;
                }
            }
        }

UnloadLibrary()

static void IKVM.Runtime.JNI.JNINativeLoader.UnloadLibrary ( long handle, RuntimeJavaType fromClass )

static

Initiates an unload of the given native library for the specified class loader.

Parameters

handle
loader

Definition at line 147 of file JNINativeLoader.cs.

        {
            var p = (nint)handle;
 
            lock (SyncRoot)
            {
                JVM.Context.Diagnostics.GenericJniInfo($"Unloading library: handle = 0x{handle:X}, class = {fromClass}");
 
                try
                {
                    var onunload = LibJvm.Instance.JVM_FindLibraryEntry(p, NativeLibrary.MangleExportName("JNI_OnUnload", sizeof(nint) + sizeof(nint)));
                    if (onunload != 0)
                    {
                        JVM.Context.Diagnostics.GenericJniInfo($"Calling JNI_OnUnload on: handle = 0x{handle:X}");
 
                        var f = new JNIFrame();
                        var w = f.Enter(ikvm.@internal.CallerID.create(fromClass.ClassObject, fromClass.ClassObject.getClassLoader()));
                        try
                        {
                            Marshal.GetDelegateForFunctionPointer<JNI_OnUnloadFunc>(onunload)(JavaVM.pJavaVM, null);
                        }
                        finally
                        {
                            f.Leave();
                        }
                    }
                }
                catch (EntryPointNotFoundException)
                {
                    // JNI_OnUnload entry point doesn't exist and isn't required
                }
 
                // remove record of native library
                loaded.Remove(p);
                fromClass.ClassLoader.UnregisterNativeLibrary(p);
                LibJvm.Instance.JVM_UnloadLibrary(p);
            }
        }

Member Data Documentation

SyncRoot

readonly object IKVM.Runtime.JNI.JNINativeLoader.SyncRoot = new object()

static

Definition at line 44 of file JNINativeLoader.cs.

---

The documentation for this class was generated from the following file:

• src/IKVM.Runtime/JNI/JNINativeLoader.cs