X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fforeign.lisp;h=f46b03d76fd9b8ffd952a31a1997f7030a69a751;hb=82cd148d729c241e79c8df04b700beec1b7c55de;hp=fc4a3b822a8365db43ca838ec0a60ef1998dca3d;hpb=192731b882467a9014b64b1eb097c8000441da31;p=sbcl.git diff --git a/src/code/foreign.lisp b/src/code/foreign.lisp index fc4a3b8..f46b03d 100644 --- a/src/code/foreign.lisp +++ b/src/code/foreign.lisp @@ -1,5 +1,4 @@ -;;;; support for dynamically loading foreign object files and -;;;; resolving symbols therein +;;;; Foreign symbol linkage ;;;; This software is part of the SBCL system. See the README file for ;;;; more information. @@ -10,129 +9,167 @@ ;;;; provided with absolutely no warranty. See the COPYING and CREDITS ;;;; files for more information. -(in-package "SB-ALIEN") ; (SB-ALIEN, not SB!ALIEN, since we're in warm load.) - -;;; On any OS where we don't support foreign object file loading, any -;;; query of a foreign symbol value is answered with "no definition -;;; known", i.e. NIL. -#-(or linux sunos FreeBSD OpenBSD NetBSD darwin) -(defun get-dynamic-foreign-symbol-address (symbol) - (declare (type simple-string symbol) (ignore symbol)) - nil) - -;;; dlsym()-based implementation of GET-DYNAMIC-FOREIGN-SYMBOL-ADDRESS -;;; and functions (e.g. LOAD-FOREIGN) which affect it. This should -;;; work on any ELF system with dlopen(3) and dlsym(3) -;;; It also works on OpenBSD, which isn't ELF, but is otherwise modern -;;; enough to have a fairly well working dlopen/dlsym implementation. -(macrolet ((define-unsupported-fun (fun-name &optional (error-message "unsupported on this system")) - `(defun ,fun-name (&rest rest) - ,error-message - (declare (ignore rest)) - (error 'unsupported-operator :name ',fun-name)))) - #-(or linux sunos FreeBSD OpenBSD NetBSD darwin) - (define-unsupported-fun load-shared-object) - #+(or linux sunos FreeBSD OpenBSD NetBSD darwin) - (progn - - (define-unsupported-fun load-foreign "Unsupported as of SBCL 0.8.13.") - (define-unsupported-fun load-1-foreign "Unsupported as of SBCL 0.8.13. Please use LOAD-SHARED-OBJECT.") - -;;; a list of handles returned from dlopen(3) (or possibly some -;;; bogus value temporarily during initialization) - (defvar *handles-from-dlopen* nil) - -;;; Dynamically loaded stuff isn't there upon restoring from a save. -;;; Clearing the variable this way was originally done primarily for -;;; Irix, which resolves tzname at runtime, resulting in -;;; *HANDLES-FROM-DLOPEN* (which was then called *TABLES-FROM-DLOPEN*) -;;; being set in the saved core image, resulting in havoc upon -;;; restart; but it seems harmless and tidy for other OSes too. -;;; -;;; Of course, it can be inconvenient that dynamically loaded stuff -;;; goes away when we save and restore. However, -;;; (1) trying to avoid it by system programming here could open a -;;; huge can of worms, since e.g. now we would need to worry about -;;; libraries possibly being in different locations (file locations -;;; or memory locations) at restore time than at save time; and -;;; (2) by the time the application programmer is so deep into the -;;; the use of hard core extension features as to be doing -;;; dynamic loading of foreign files and saving/restoring cores, -;;; he probably has the sophistication to write his own after-save -;;; code to reload the libraries without much difficulty. - -;;; dan 2001.05.10 suspects that objection (1) is bogus for -;;; dlsym()-enabled systems - - (push (lambda () (setq *handles-from-dlopen* nil)) - *after-save-initializations*) - - (sb-alien:define-alien-routine dlopen system-area-pointer - (file sb-alien:c-string) (mode sb-alien:int)) - (sb-alien:define-alien-routine dlsym system-area-pointer - (lib system-area-pointer) - (name sb-alien:c-string)) - (sb-alien:define-alien-routine dlerror sb-alien:c-string) - -;;; Ensure that we've opened our own binary so we can dynamically resolve -;;; symbols in the C runtime. -;;; -;;; Old comment: This used to happen only in -;;; GET-DYNAMIC-FOREIGN-SYMBOL-ADDRESS, and only if no libraries were -;;; dlopen()ed already, but that didn't work if something was -;;; dlopen()ed before any problem global vars were used. So now we do -;;; this in any function that can add to the *HANDLES-FROM-DLOPEN*, as -;;; well as in GET-DYNAMIC-FOREIGN-SYMBOL-ADDRESS. -;;; -;;; FIXME: It would work just as well to do it once at startup, actually. -;;; Then at least we know it's done. -dan 2001.05.10 - (defun ensure-runtime-symbol-table-opened () - (unless *handles-from-dlopen* - ;; Prevent recursive call if dlopen() isn't defined. - (setf *handles-from-dlopen* (int-sap 0)) - (setf *handles-from-dlopen* (list (dlopen nil rtld-lazy))) - (when (zerop (sb-sys:sap-int (first *handles-from-dlopen*))) - (error "can't open our own binary's symbol table: ~S" (dlerror))))) - - (defun load-shared-object (file) - "Load a shared library/dynamic shared object file/general - dlopenable alien container. - - To use LOAD-SHARED-OBJECT, at the Unix command line do this: - echo 'int summish(int x, int y) { return 1 + x + y; }' > /tmp/ffi-test.c - make /tmp/ffi-test.o # i.e. cc -c -o /tmp/ffi-test.o /tmp/ffi-test.c - ld -shared -o /tmp/ffi-test.so /tmp/ffi-test.o - then in SBCL do this: - (LOAD-SHARED-OBJECT \"/tmp/ffi-test.so\") - (DEFINE-ALIEN-ROUTINE SUMMISH INT (X INT) (Y INT)) - Now running (SUMMISH 10 20) should return 31. -" - (ensure-runtime-symbol-table-opened) - ;; Note: We use RTLD-GLOBAL so that it can find all the symbols - ;; previously loaded. We use RTLD-NOW so that dlopen() will fail if - ;; not all symbols are defined. - (let* ((real-file (or (unix-namestring file) file)) - (sap (dlopen real-file (logior rtld-now rtld-global)))) - (if (zerop (sap-int sap)) - (error "can't open object ~S: ~S" real-file (dlerror)) - (pushnew sap *handles-from-dlopen* :test #'sap=))) - (values)) - - (defun get-dynamic-foreign-symbol-address (symbol) - (ensure-runtime-symbol-table-opened) - ;; Find the symbol in any of the loaded object files. Search in - ;; reverse order of loading, so that later loadings take precedence. - ;; - ;; FIXME: The way that we use PUSHNEW SAP in LOAD-SHARED-OBJECT means - ;; that the list isn't guaranteed to be in reverse order of loading, - ;; at least not if a file is loaded more than once. Is this the - ;; right thing? (In what cases does it matter?) - (dolist (handle (reverse *handles-from-dlopen*)) - ;; KLUDGE: We implicitly exclude the possibility that the variable - ;; could actually be NULL, but the man page for dlsym(3) - ;; recommends doing a more careful test. -- WHN 20000825 - (let ((possible-result (sap-int (dlsym handle symbol)))) - (unless (zerop possible-result) - (return possible-result))))) - - )) ; PROGN, MACROLET +(in-package "SB!IMPL") + +#!-(or elf mach-o win32) +(error "Not an ELF, Mach-O, or Win32 platform?") + +(defun extern-alien-name (name) + (handler-case + (coerce name 'base-string) + (error () + (error "invalid external alien name: ~S" name)))) + +;;; *STATIC-FOREIGN-SYMBOLS* are static as opposed to "dynamic" (not +;;; as opposed to C's "extern"). The table contains symbols known at +;;; the time that the program was built, but not symbols defined in +;;; object files which have been loaded dynamically since then. +#!-sb-dynamic-core +(declaim (type hash-table *static-foreign-symbols*)) +#!-sb-dynamic-core +(defvar *static-foreign-symbols* (make-hash-table :test 'equal)) + +(declaim + (ftype (sfunction (string hash-table) (or integer null)) find-foreign-symbol-in-table)) +(defun find-foreign-symbol-in-table (name table) + (let ((extern (extern-alien-name name))) + (values + (or (gethash extern table) + (gethash (concatenate 'base-string "ldso_stub__" extern) table))))) + +(defun find-foreign-symbol-address (name) + "Returns the address of the foreign symbol NAME, or NIL. Does not enter the +symbol in the linkage table, and never returns an address in the linkage-table." + (or #!-sb-dynamic-core + (find-foreign-symbol-in-table name *static-foreign-symbols*) + (find-dynamic-foreign-symbol-address name))) + +(defun foreign-symbol-address (name &optional datap) + "Returns the address of the foreign symbol NAME. DATAP must be true if the +symbol designates a variable (used only on linkage-table platforms). Returns a +secondary value that is true if DATAP was true and the symbol is a dynamic +foreign symbol. + +On linkage-table ports the returned address is always static: either direct +address of a static symbol, or the linkage-table address of a dynamic one. +Dynamic symbols are entered into the linkage-table if they aren't there already. + +On non-linkage-table ports signals an error if the symbol isn't found." + (declare (ignorable datap)) + #!+sb-dynamic-core + (values (ensure-foreign-symbol-linkage name datap) t) + #!-sb-dynamic-core + (let ((static (find-foreign-symbol-in-table name *static-foreign-symbols*))) + (if static + (values static nil) + #!+os-provides-dlopen + (progn + #-sb-xc-host + (values #!-linkage-table + (ensure-dynamic-foreign-symbol-address name) + #!+linkage-table + (ensure-foreign-symbol-linkage name datap) + t) + #+sb-xc-host + (error 'undefined-alien-error :name name)) + #!-os-provides-dlopen + (error 'undefined-alien-error :name name)))) + +(defun foreign-symbol-sap (symbol &optional datap) + "Returns a SAP corresponding to the foreign symbol. DATAP must be true if the +symbol designates a variable (used only on linkage-table platforms). May enter +the symbol into the linkage-table. On non-linkage-table ports signals an error +if the symbol isn't found." + (declare (ignorable datap)) + #!-linkage-table + (int-sap (foreign-symbol-address symbol)) + #!+linkage-table + (multiple-value-bind (addr sharedp) + (foreign-symbol-address symbol datap) + #+sb-xc-host #!-sb-dynamic-core (aver (not sharedp)) () + ;; If the address is from linkage-table and refers to data + ;; we need to do a bit of juggling. It is not the address of the + ;; variable, but the address where the real address is stored. + (if (and sharedp datap) + (int-sap (sap-ref-word (int-sap addr) 0)) + (int-sap addr)))) + +#-sb-xc-host +(defun foreign-reinit () + #!+os-provides-dlopen + (reopen-shared-objects) + #!+linkage-table + ;; Don't warn about undefined aliens on startup. The same core can + ;; reasonably be expected to work with different versions of the + ;; same library. + (handler-bind ((style-warning #'muffle-warning)) + (update-linkage-table))) + +;;; Cleanups before saving a core +#-sb-xc-host +(defun foreign-deinit () + #!+(and os-provides-dlopen (not linkage-table)) + (when (dynamic-foreign-symbols-p) + (warn "~@" (list-dynamic-foreign-symbols))) + #!+os-provides-dlopen + (close-shared-objects)) + +(declaim (maybe-inline sap-foreign-symbol)) +(defun sap-foreign-symbol (sap) + (declare (ignorable sap)) + #-sb-xc-host + (let ((addr (sap-int sap))) + (declare (ignorable addr)) + #!+linkage-table + (when (<= sb!vm:linkage-table-space-start + addr + sb!vm:linkage-table-space-end) + (dohash ((name-and-datap table-addr) *linkage-info* :locked t) + (when (and (<= table-addr addr) + (< addr (+ table-addr sb!vm:linkage-table-entry-size))) + (return-from sap-foreign-symbol (car name-and-datap))))) + #!+os-provides-dladdr + (with-alien ((info (struct dl-info + (filename c-string) + (base unsigned) + (symbol c-string) + (symbol-address unsigned))) + (dladdr (function unsigned unsigned (* (struct dl-info))) + :extern "dladdr")) + (let ((err (without-gcing + ;; On eg. Darwin GC can could otherwise interrupt + ;; the call while dladdr is holding a lock. + (alien-funcall dladdr addr (addr info))))) + (if (zerop err) + nil + (slot info 'symbol)))) + ;; FIXME: Even in the absence of dladdr we could search the + ;; static foreign symbols (and *linkage-info*, for that matter). + )) + +;;; How we learn about foreign symbols and dlhandles initially +(defvar *!initial-foreign-symbols*) + +#-sb-xc-host +(defun !foreign-cold-init () + #!-sb-dynamic-core + (dolist (symbol *!initial-foreign-symbols*) + (setf (gethash (car symbol) *static-foreign-symbols*) (cdr symbol))) + #!+sb-dynamic-core + (loop for table-address from sb!vm::linkage-table-space-start + by sb!vm::linkage-table-entry-size + and reference in sb!vm::*required-runtime-c-symbols* + do (setf (gethash reference *linkage-info*) table-address)) + #!+os-provides-dlopen + (setf *runtime-dlhandle* (dlopen-or-lose)) + #!+os-provides-dlopen + (setf *shared-objects* nil)) + +#!-os-provides-dlopen +(define-unsupported-fun load-shared-object)