Add "Footgun API"

staticfloat · staticfloat · commit 6551d7ed48cb · 2021-02-19T22:10:42.000-08:00
This adds the `lbt_set_forward()` and `lbt_get_forward()` APIs, which
allow directly setting the BLAS API functions that a user might be
interested in wrapping.

It also adds `lbt_set_default_function` and provides a fairly useless
(but at least not fatal) default value for the default function so that
if users don't want to seqfault when calling an uninitialized function,
they won't.
diff --git a/src/deepbindless_surrogates.c b/src/deepbindless_surrogates.c
@@ -2,24 +2,18 @@
 
 #ifdef LBT_DEEPBINDLESS
 
-int find_symbol_idx(const char * name) {
-    for (int symbol_idx=0; exported_func_names[symbol_idx] != NULL; ++symbol_idx) {
-        if (strcmp(exported_func_names[symbol_idx], "lsame_") == 0) {
-            return symbol_idx;
-        }
-    }
-
-    // This is fatal as it signifies a configuration error in our trampoline symbol list
-    fprintf(stderr, "Error: Unable to find %s in our symbol list?!\n", name);
-    exit(1);
-}
-
 int lsame_idx = -1;
 const void *old_lsame32 = NULL, *old_lsame64 = NULL;
 void push_fake_lsame() {
     // Find `lsame_` in our symbol list (if we haven't done so before)
-    if (lsame_idx == -1)
+    if (lsame_idx == -1) {
         lsame_idx = find_symbol_idx("lsame_");
+        if (lsame_idx == -1) {
+            // This is fatal as it signifies a configuration error in our trampoline symbol list
+            fprintf(stderr, "Error: Unable to find lsame_ in our symbol list?!\n");
+            exit(1);
+        }
+    }
     
     // Save old values of `lsame_` and `lsame_64_` to our swap location
     old_lsame32 = (*exported_func32_addrs[lsame_idx]);
diff --git a/src/libblastrampoline.c b/src/libblastrampoline.c
@@ -10,10 +10,138 @@
 #define DEEPBINDLESS_INTERFACE_ILP64_LOADED   0x02
 uint8_t deepbindless_interfaces_loaded      = 0x00;
 
+
+int32_t find_symbol_idx(const char * name) {
+    for (int32_t symbol_idx=0; exported_func_names[symbol_idx] != NULL; ++symbol_idx) {
+        if (strcmp(exported_func_names[symbol_idx], name) == 0) {
+            return symbol_idx;
+        }
+    }
+    return -1;
+}
+
+
+LBT_DLLEXPORT void lbt_default_func_print_error() {
+    fprintf(stderr, "Error: no BLAS/LAPACK library loaded!\n");
+}
+const void * default_func = (const void *)&lbt_default_func_print_error;
+LBT_DLLEXPORT const void * lbt_get_default_func() {
+    return default_func;
+}
+
+LBT_DLLEXPORT void lbt_set_default_func(const void * addr) {
+    default_func = addr;
+}
+
+/*
+ * Force a forward to a particular value.
+ */
+int32_t set_forward_by_index(int32_t symbol_idx, const void * addr, int32_t interface, int32_t f2c, int32_t verbose) {
+    // Quit out immediately if this is not a interface setting
+    if (interface != LBT_INTERFACE_LP64 && interface != LBT_INTERFACE_ILP64) {
+        return -1;
+    }
+
+    // NULL is a special value that means our "default address"... which may itself be `NULL`!
+    if (addr == NULL) {
+        addr = default_func;
+    }
+
+    if (interface == LBT_INTERFACE_LP64) {
+        (*exported_func32_addrs[symbol_idx]) = addr;
+    } else {
+        (*exported_func64_addrs[symbol_idx]) = addr;
+
+        // If we're on an RTLD_DEEPBINDless system and our workaround is activated,
+        // we take over our own 32-bit symbols as well.
+        if (deepbindless_interfaces_loaded & DEEPBINDLESS_INTERFACE_ILP64_LOADED) {
+            (*exported_func32_addrs[symbol_idx]) = addr;
+        }
+    }
+
+#ifdef F2C_AUTODETECTION
+    if (f2c == LBT_F2C_REQUIRED) {
+        // Check to see if this symbol is one of the f2c functions
+        int f2c_symbol_idx = 0;
+        for (f2c_symbol_idx=0; f2c_func_idxs[f2c_symbol_idx] != -1; ++f2c_symbol_idx) {
+            // Jump through the f2c_func_idxs layer of indirection to find the `exported_func*_addrs` offsets
+            // Skip any symbols that aren't ours
+            if (f2c_func_idxs[f2c_symbol_idx] != symbol_idx)
+                continue;
+
+            if (verbose) {
+                char exported_name[MAX_SYMBOL_LEN];
+                sprintf(exported_name, "%s%s", exported_func_names[symbol_idx], interface == LBT_INTERFACE_ILP64 ? "64_" : "");
+                printf(" - [%04d] f2c(%s)\n", symbol_idx, exported_name);
+            }
+
+            // Override these addresses with our f2c wrappers
+            if (interface == LBT_INTERFACE_LP64) {
+                // Save "true" symbol address in `f2c_$(name)_addr`, then set our exported `$(name)` symbol
+                // to call `f2c_$(name)`, which will bounce into the true symbol, but fix the return value.
+                (*f2c_func32_addrs[f2c_symbol_idx]) = (*exported_func32_addrs[symbol_idx]);
+                (*exported_func32_addrs[symbol_idx]) = f2c_func32_wrappers[f2c_symbol_idx];
+            } else {
+                (*f2c_func64_addrs[f2c_symbol_idx]) = (*exported_func64_addrs[symbol_idx]);
+                (*exported_func64_addrs[symbol_idx]) = f2c_func64_wrappers[f2c_symbol_idx];
+            }
+        }
+    }
+#endif // F2C_AUTODETECTION
+    return 0;
+}
+
+LBT_DLLEXPORT const void * lbt_get_forward(const char * symbol_name, int32_t interface, int32_t f2c) {
+    // Search symbol list for `symbol_name`, then sub off to `set_forward_by_index()`
+    int32_t symbol_idx = find_symbol_idx(symbol_name);
+    if (symbol_idx == -1)
+        return (const void *)-1;
+    
+#ifdef F2C_AUTODETECTION
+    if (f2c == LBT_F2C_REQUIRED) {
+        // Check to see if this symbol is one of the f2c functions
+        int f2c_symbol_idx = 0;
+        for (f2c_symbol_idx=0; f2c_func_idxs[f2c_symbol_idx] != -1; ++f2c_symbol_idx) {
+            // Skip any symbols that aren't ours
+            if (f2c_func_idxs[f2c_symbol_idx] != symbol_idx)
+                continue;
+
+            // If we find it, return the "true" address, but only if the currently-exported
+            // address is actually our f2c wrapper; if it's not then do nothing.
+            if (interface == LBT_INTERFACE_LP64) {
+                if (*exported_func32_addrs[symbol_idx] == f2c_func32_wrappers[f2c_symbol_idx]) {
+                    return (const void *)(*f2c_func32_addrs[f2c_symbol_idx]);
+                }
+            } else {
+                if (*exported_func64_addrs[symbol_idx] == f2c_func64_wrappers[f2c_symbol_idx]) {
+                    return (const void *)(*f2c_func64_addrs[f2c_symbol_idx]);
+                }
+            }
+        }
+    }
+#endif
+
+    // If we're not in f2c-hell, we can just return our interface's address directly.
+    if (interface == LBT_INTERFACE_LP64) {
+        return (const void *)(*exported_func32_addrs[symbol_idx]);
+    } else {
+        return (const void *)(*exported_func64_addrs[symbol_idx]);
+    }
+}
+
+LBT_DLLEXPORT int32_t lbt_set_forward(const char * symbol_name, const void * addr, int32_t interface, int32_t f2c, int32_t verbose) {
+    // Search symbol list for `symbol_name`, then sub off to `set_forward_by_index()`
+    int32_t symbol_idx = find_symbol_idx(symbol_name);
+    if (symbol_idx == -1)
+        return -1;
+
+    return set_forward_by_index(symbol_idx, addr, interface, f2c, verbose);
+}
+
 /*
  * Load `libname`, clearing previous mappings if `clear` is set.
  */
-LBT_DLLEXPORT int lbt_forward(const char * libname, int clear, int verbose) {
+LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose) {
     if (verbose) {
         printf("Generating forwards to %s\n", libname);
     }
@@ -131,67 +259,25 @@ LBT_DLLEXPORT int lbt_forward(const char * libname, int clear, int verbose) {
     }
 
     // Finally, re-export its symbols:
-    int nforwards = 0;
-    int symbol_idx = 0;
+    int32_t nforwards = 0;
+    int32_t symbol_idx = 0;
     char symbol_name[MAX_SYMBOL_LEN];
     for (symbol_idx=0; exported_func_names[symbol_idx] != NULL; ++symbol_idx) {
         // If `clear` is set, zero out all symbols that may have been set so far
         if (clear) {
-            (*exported_func32_addrs[symbol_idx]) = NULL;
-            (*exported_func64_addrs[symbol_idx]) = NULL;
+            (*exported_func32_addrs[symbol_idx]) = default_func;
+            (*exported_func64_addrs[symbol_idx]) = default_func;
         }
 
         // Look up this symbol in the given library, if it is a valid symbol, set it!
         sprintf(symbol_name, "%s%s", exported_func_names[symbol_idx], lib_suffix);
         void *addr = lookup_symbol(handle, symbol_name);
         if (addr != NULL) {
-            if (verbose) {
-                char exported_name[MAX_SYMBOL_LEN];
-                sprintf(exported_name, "%s%s", exported_func_names[symbol_idx], interface == LBT_INTERFACE_ILP64 ? "64_" : "");
-                printf(" - [%04d] %s -> %s [%p]\n", symbol_idx, exported_name, symbol_name, addr);
-            }
-            if (interface == LBT_INTERFACE_LP64) {
-                (*exported_func32_addrs[symbol_idx]) = addr;
-            } else {
-                (*exported_func64_addrs[symbol_idx]) = addr;
-
-                // If we're on an RTLD_DEEPBINDless system and our workaround is activated,
-                // we take over our own 32-bit symbols as well.
-                if (deepbindless_interfaces_loaded & DEEPBINDLESS_INTERFACE_ILP64_LOADED) {
-                    (*exported_func32_addrs[symbol_idx]) = addr;
-                }
-            }
+            set_forward_by_index(symbol_idx,  addr, interface, f2c, verbose);
             nforwards++;
         }
     }
 
-#ifdef F2C_AUTODETECTION
-    if (f2c == LBT_F2C_REQUIRED) {
-        int f2c_symbol_idx = 0;
-        for (f2c_symbol_idx=0; f2c_func_idxs[f2c_symbol_idx] != -1; ++f2c_symbol_idx) {
-            // Jump through the f2c_func_idxs layer of indirection to find the `exported_func*_addrs` offsets
-            symbol_idx = f2c_func_idxs[f2c_symbol_idx];
-
-            if (verbose) {
-                char exported_name[MAX_SYMBOL_LEN];
-                sprintf(exported_name, "%s%s", exported_func_names[symbol_idx], interface == LBT_INTERFACE_ILP64 ? "64_" : "");
-                printf(" - [%04d] f2c(%s)\n", symbol_idx, exported_name);
-            }
-
-            // Override these addresses with our f2c wrappers
-            if (interface == LBT_INTERFACE_LP64) {
-                // Save "true" symbol address in `f2c_$(name)_addr`, then set our exported `$(name)` symbol
-                // to call `f2c_$(name)`, which will bounce into the true symbol, but fix the return value.
-                (*f2c_func32_addrs[f2c_symbol_idx]) = (*exported_func32_addrs[symbol_idx]);
-                (*exported_func32_addrs[symbol_idx]) = f2c_func32_wrappers[f2c_symbol_idx];
-            } else {
-                (*f2c_func64_addrs[f2c_symbol_idx]) = (*exported_func64_addrs[symbol_idx]);
-                (*exported_func64_addrs[symbol_idx]) = f2c_func64_wrappers[f2c_symbol_idx];
-            }
-        }
-    }
-#endif
-
     record_library_load(libname, handle, lib_suffix, interface, f2c);
     if (verbose) {
         printf("Processed %d symbols; forwarded %d symbols with %d-bit interface and mangling to a suffix of \"%s\"\n", symbol_idx, nforwards, interface, lib_suffix);
@@ -200,6 +286,7 @@ LBT_DLLEXPORT int lbt_forward(const char * libname, int clear, int verbose) {
     return nforwards;
 }
 
+
 __attribute__((constructor)) void init(void) {
     // Initialize config structures
     init_config();
diff --git a/src/libblastrampoline.h b/src/libblastrampoline.h
@@ -90,14 +90,14 @@ typedef struct {
  *
  * If `verbose` is set to a non-zero value, it will print out debugging information.
  */
-int lbt_forward(const char * libname, int clear, int verbose);
+LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose);
 
 /*
  * Returns a structure describing the currently-loaded libraries as well as the build configuration
  * of this `libblastrampoline` instance.  See the definition of `lbt_config_t` in this header file
  * for more details.
  */
-const lbt_config_t * lbt_get_config();
+LBT_DLLEXPORT const lbt_config_t * lbt_get_config();
 
 /*
  * Returns the number of threads configured by the underlying BLAS library.  In the event that
@@ -106,7 +106,7 @@ const lbt_config_t * lbt_get_config();
  * for the `lbt_register_thread_interface()` function, although many common functions (such as
  * those for `OpenBLAS`, `MKL` and `BLIS`) are already registered by default.
  */
-int32_t lbt_get_num_threads();
+LBT_DLLEXPORT int32_t lbt_get_num_threads();
 
 /*
  * Sets the number of threads in the underlying BLAS library.  In the event that multiple
@@ -115,7 +115,7 @@ int32_t lbt_get_num_threads();
  * `lbt_register_thread_interface()` function, although many common functions (such as those
  * for `OpenBLAS`, `MKL` and `BLIS`) are already registered by default.
  */
-void lbt_set_num_threads(int32_t num_threads);
+LBT_DLLEXPORT void lbt_set_num_threads(int32_t num_threads);
 
 /*
  * Register a new `get_num_threads()`/`set_num_threads()` pair.  These functions are assumed to be
@@ -130,7 +130,48 @@ void lbt_set_num_threads(int32_t num_threads);
  * name for this functionality, they must register those getter/setter functions here to have them
  * automatically called whenever `lbt_{get,set}_num_threads()` is called.
  */
-void lbt_register_thread_interface(const char * getter, const char * setter);
+LBT_DLLEXPORT void lbt_register_thread_interface(const char * getter, const char * setter);
+
+/*
+ * Function that simply prints out to `stderr` that someone called an uninitialized function.
+ * This is the default default function, see `lbt_set_default_func()` for how to override it.
+ */
+LBT_DLLEXPORT void lbt_default_func_print_error();
+
+/*
+ * Returns the currently-configured default function that gets called if no mapping has been set
+ * for an exported symbol.  Can return `NULL` if it was set as the default function.
+ */
+LBT_DLLEXPORT const void * lbt_get_default_func();
+
+/*
+ * Sets the default function that gets called if no mapping has been set for an exported symbol.
+ * `NULL` is a valid address, if a segfault upon calling an uninitialized function is desirable.
+ * Note that this will not be retroactively applied to already-set pointers, so you should call
+ * this function immediately before calling `lbt_forward()` with `clear` set.
+ */
+LBT_DLLEXPORT void lbt_set_default_func(const void * addr);
+
+/*
+ * Returns the currently-configured forward target for the given `symbol_name`, according to the
+ * requested `interface`.  If `f2c` is set to `LBT_F2C_REQUIRED`, then if there is an f2c
+ * workaround shim in effect for this symbol, this method will thread through that to return the
+ * "true" symbol address.  If `f2c` is set to any other value, then if there is an f2c workaround
+ * shim in effect, the address of the shim will be returned.  (This allows passing this address
+ * to a 3rd party library which does not want to have to deal with f2c conversion, for instance).
+ * If this is not an f2c-capable LBT build, `f2c` is ignored completely.
+ */
+LBT_DLLEXPORT const void * lbt_get_forward(const char * symbol_name, int32_t interface, int32_t f2c);
+
+/*
+ * Allows directly setting a symbol to be forwarded to a particular address, for the given
+ * interface.  If `f2c` is set to `LBT_F2C_REQUIRED` and this is an f2c-capable LBT build, an
+ * f2c wrapper function will be interposed between the exported symbol and the targeted address.
+ * If `verbose` is set to a non-zero value, status messages will be printed out to `stdout`.
+ * If `addr` is set to `NULL` it will be set as the default function, see `lbt_set_default_func()`
+ * for how to set the default function pointer.
+ */
+LBT_DLLEXPORT int32_t lbt_set_forward(const char * symbol_name, const void * addr, int32_t interface, int32_t f2c, int32_t verbose);
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/src/libblastrampoline_internal.h b/src/libblastrampoline_internal.h
@@ -46,6 +46,9 @@ extern const void ** exported_func64_addrs[];
 // The config type you get back from lbt_get_config()
 #define MAX_TRACKED_LIBS        31
 
+// Functions in `libblastrampoline.c`
+int32_t find_symbol_idx(const char * name);
+
 // Functions in `config.c`
 void init_config();
 void clear_loaded_libraries();
diff --git a/test/direct.jl b/test/direct.jl
diff --git a/test/utils.jl b/test/utils.jl
