From: "nobu (Nobuyoshi Nakada) via ruby-core" <ruby-core@...>
Date: 2023-11-27T03:08:33+00:00
Subject: [ruby-core:115481] [Ruby master Feature#20005] Add C API to return symbols of native extensions resolved from features

Issue #20005 has been updated by nobu (Nobuyoshi Nakada).


tagomoris (Satoshi Tagomori) wrote in #note-8:
> I noticed that `dln_sym` raises LoadError when the specified symbol is not found. But I expect this API to return NULL when the symbol is not found.
> Which one should be better?

`dln_sym` has been used only to resolve and call immediately `Init_xxx` functions, and it would be reasonable to split error handling.

> My expectation: libraries should raise LoadError under their own responsibility when this API returns NULL

What do you mean by "libraries" here?

```diff
diff --git a/dln.c b/dln.c
index bbed3af78ce..7c67fc2014f 100644
--- a/dln.c
+++ b/dln.c
@@ -419,32 +419,34 @@ dln_open(const char *file)
 static void *
 dln_sym(void *handle, const char *symbol)
 {
-    void *func;
-    const char *error;
-
 #if defined(_WIN32)
-    char message[1024];
+    return GetProcAddress(handle, symbol);
+#elif defined(USE_DLN_DLOPEN)
+    return dlsym(handle, symbol);
+#endif
+}
+
+static void *
+dln_sym_func(void *handle, const char *symbol)
+{
+    void *func = dln_sym(handle, symbol);
 
-    func = GetProcAddress(handle, symbol);
     if (func == NULL) {
+        const char *error;
+#if defined(_WIN32)
+        char message[1024];
         error = dln_strerror();
-        goto failed;
-    }
-
 #elif defined(USE_DLN_DLOPEN)
-    func = dlsym(handle, symbol);
-    if (func == NULL) {
         const size_t errlen = strlen(error = dln_strerror()) + 1;
         error = memcpy(ALLOCA_N(char, errlen), error, errlen);
-        goto failed;
-    }
 #endif
-
+        dln_loaderror("%s - %s", error, symbol);
+    }
     return func;
-
-  failed:
-    dln_loaderror("%s - %s", error, symbol);
 }
+
+#define dln_sym_call(rettype, argtype, handle, symbol) \
+    (*(rettype (*)argtype)dln_sym_func(handle, symbol))
 #endif
 
 #if defined(RUBY_DLN_CHECK_ABI) && defined(USE_DLN_DLOPEN)
@@ -464,9 +466,8 @@ dln_load(const char *file)
 
 #ifdef RUBY_DLN_CHECK_ABI
     typedef unsigned long long abi_version_number;
-    typedef abi_version_number abi_version_func(void);
-    abi_version_func *abi_version_fct = (abi_version_func *)dln_sym(handle, EXTERNAL_PREFIX "ruby_abi_version");
-    abi_version_number binary_abi_version = (*abi_version_fct)();
+    abi_version_number binary_abi_version =
+        dln_sym_call(abi_version_number, (void), handle, EXTERNAL_PREFIX "ruby_abi_version")();
     if (binary_abi_version != ruby_abi_version() && abi_check_enabled_p()) {
         dln_loaderror("incompatible ABI version of binary - %s", file);
     }
@@ -474,10 +475,9 @@ dln_load(const char *file)
 
     char *init_fct_name;
     init_funcname(&init_fct_name, file);
-    void (*init_fct)(void) = (void(*)(void))dln_sym(handle, init_fct_name);
 
     /* Call the init code */
-    (*init_fct)();
+    dln_sym_call(void, (void), handle, init_fct_name)();
 
     return handle;
 
```


----------------------------------------
Feature #20005: Add C API to return symbols of native extensions resolved from features
https://bugs.ruby-lang.org/issues/20005#change-105412

* Author: tagomoris (Satoshi Tagomori)
* Status: Open
* Priority: Normal
----------------------------------------
I want an API to resolve symbols of other native extensions by a feature name and a symbol name (just like `dlsym`).

(`rb_dln_resolve_symbol` is an example function name of this feature in the example below)
```c
// "a_client_open" is a function defined in "/..../a_client.so", that should be loaded in Ruby beforehand.

// in the extension to be "a.so"
VALUE (*a_client_open)(VALUE);

void Init_a(void)
{
  a_client_open = (VALUE(*)(VALUE))rb_dln_resolve_symbol("a_client", "a_client_open");
  // the return value may be NULL if the symbols is not found
}
```

This API is to replace direct reference of external symbols.

Currently, native extensions have to just call the function of other extensions directly on the assumption of:
* The dependency native extension is already loaded
* The symbol is defined correctly in the dependency (the version of dependency is correct&expected)
Otherwise, it crashes.

This API provides a way for developers to raise exceptions if the resolved symbol is `NULL`, and these exceptions can display meaningful messages and instructions to the users of extensions.




-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/