libgo/go/plugin/plugin_dlopen.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build linux,cgo darwin,cgo
   6
   7 package plugin
   8
   9 /*
  10 #cgo linux LDFLAGS: -ldl
  11 #include <dlfcn.h>
  12 #include <limits.h>
  13 #include <stdlib.h>
  14 #include <stdint.h>
  15
  16 #include <stdio.h>
  17
  18 static uintptr_t pluginOpen(const char* path, char** err) {
  19         void* h = dlopen(path, RTLD_NOW|RTLD_GLOBAL);
  20         if (h == NULL) {
  21                 *err = (char*)dlerror();
  22         }
  23         return (uintptr_t)h;
  24 }
  25
  26 static void* pluginLookup(uintptr_t h, const char* name, char** err) {
  27         void* r = dlsym((void*)h, name);
  28         if (r == NULL) {
  29                 *err = (char*)dlerror();
  30         }
  31         return r;
  32 }
  33 */
  34 import "C"
  35
  36 import (
  37         "errors"
  38         "sync"
  39         "unsafe"
  40 )
  41
  42 // avoid a dependency on strings
  43 func lastIndexByte(s string, c byte) int {
  44         for i := len(s) - 1; i >= 0; i-- {
  45                 if s[i] == c {
  46                         return i
  47                 }
  48         }
  49         return -1
  50 }
  51
  52 func open(name string) (*Plugin, error) {
  53         cPath := make([]byte, C.PATH_MAX+1)
  54         cRelName := make([]byte, len(name)+1)
  55         copy(cRelName, name)
  56         if C.realpath(
  57                 (*C.char)(unsafe.Pointer(&cRelName[0])),
  58                 (*C.char)(unsafe.Pointer(&cPath[0]))) == nil {
  59                 return nil, errors.New(`plugin.Open("` + name + `"): realpath failed`)
  60         }
  61
  62         filepath := C.GoString((*C.char)(unsafe.Pointer(&cPath[0])))
  63
  64         pluginsMu.Lock()
  65         if p := plugins[filepath]; p != nil {
  66                 pluginsMu.Unlock()
  67                 if p.err != "" {
  68                         return nil, errors.New(`plugin.Open("` + name + `"): ` + p.err + ` (previous failure)`)
  69                 }
  70                 <-p.loaded
  71                 return p, nil
  72         }
  73         var cErr *C.char
  74         h := C.pluginOpen((*C.char)(unsafe.Pointer(&cPath[0])), &cErr)
  75         if h == 0 {
  76                 pluginsMu.Unlock()
  77                 return nil, errors.New(`plugin.Open("` + name + `"): ` + C.GoString(cErr))
  78         }
  79         // TODO(crawshaw): look for plugin note, confirm it is a Go plugin
  80         // and it was built with the correct toolchain.
  81         if len(name) > 3 && name[len(name)-3:] == ".so" {
  82                 name = name[:len(name)-3]
  83         }
  84         if plugins == nil {
  85                 plugins = make(map[string]*Plugin)
  86         }
  87         pluginpath, syms, errstr := lastmoduleinit()
  88         if errstr != "" {
  89                 plugins[filepath] = &Plugin{
  90                         pluginpath: pluginpath,
  91                         err:        errstr,
  92                 }
  93                 pluginsMu.Unlock()
  94                 return nil, errors.New(`plugin.Open("` + name + `"): ` + errstr)
  95         }
  96         // This function can be called from the init function of a plugin.
  97         // Drop a placeholder in the map so subsequent opens can wait on it.
  98         p := &Plugin{
  99                 pluginpath: pluginpath,
 100                 loaded:     make(chan struct{}),
 101         }
 102         plugins[filepath] = p
 103         pluginsMu.Unlock()
 104
 105         initStr := make([]byte, len(pluginpath)+6)
 106         copy(initStr, pluginpath)
 107         copy(initStr[len(pluginpath):], ".init")
 108
 109         initFuncPC := C.pluginLookup(h, (*C.char)(unsafe.Pointer(&initStr[0])), &cErr)
 110         if initFuncPC != nil {
 111                 initFuncP := &initFuncPC
 112                 initFunc := *(*func())(unsafe.Pointer(&initFuncP))
 113                 initFunc()
 114         }
 115
 116         // Fill out the value of each plugin symbol.
 117         updatedSyms := map[string]interface{}{}
 118         for symName, sym := range syms {
 119                 isFunc := symName[0] == '.'
 120                 if isFunc {
 121                         delete(syms, symName)
 122                         symName = symName[1:]
 123                 }
 124
 125                 fullName := pluginpath + "." + symName
 126                 cname := make([]byte, len(fullName)+1)
 127                 copy(cname, fullName)
 128
 129                 p := C.pluginLookup(h, (*C.char)(unsafe.Pointer(&cname[0])), &cErr)
 130                 if p == nil {
 131                         return nil, errors.New(`plugin.Open("` + name + `"): could not find symbol ` + symName + `: ` + C.GoString(cErr))
 132                 }
 133                 valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&sym))
 134                 if isFunc {
 135                         (*valp)[1] = unsafe.Pointer(&p)
 136                 } else {
 137                         (*valp)[1] = p
 138                 }
 139                 // we can't add to syms during iteration as we'll end up processing
 140                 // some symbols twice with the inability to tell if the symbol is a function
 141                 updatedSyms[symName] = sym
 142         }
 143         p.syms = updatedSyms
 144
 145         close(p.loaded)
 146         return p, nil
 147 }
 148
 149 func lookup(p *Plugin, symName string) (Symbol, error) {
 150         if s := p.syms[symName]; s != nil {
 151                 return s, nil
 152         }
 153         return nil, errors.New("plugin: symbol " + symName + " not found in plugin " + p.pluginpath)
 154 }
 155
 156 var (
 157         pluginsMu sync.Mutex
 158         plugins   map[string]*Plugin
 159 )
 160
 161 // lastmoduleinit is defined in package runtime
 162 func lastmoduleinit() (pluginpath string, syms map[string]interface{}, errstr string)