diff options
author | David Crawshaw <crawshaw@golang.org> | 2016-08-26 08:50:50 -0400 |
---|---|---|
committer | David Crawshaw <crawshaw@golang.org> | 2016-09-16 17:54:40 +0000 |
commit | 0cbb12f0bbaeb3893b3d011fdb1a270291747ab0 (patch) | |
tree | 27aad9e8d195e1bc06a2f93b14cdec6839474d62 /src/plugin | |
parent | c87528d7761e3f133fe238937019a18bf7cf0d3c (diff) | |
download | go-0cbb12f0bbaeb3893b3d011fdb1a270291747ab0.tar.gz go-0cbb12f0bbaeb3893b3d011fdb1a270291747ab0.zip |
plugin: new package for loading plugins
Includes a linux implementation.
Change-Id: Iacc2ed7da760ae9deebc928adf2b334b043b07ec
Reviewed-on: https://go-review.googlesource.com/27823
Run-TryBot: David Crawshaw <crawshaw@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Diffstat (limited to 'src/plugin')
-rw-r--r-- | src/plugin/plugin.go | 70 | ||||
-rw-r--r-- | src/plugin/plugin_dlopen.go | 125 | ||||
-rw-r--r-- | src/plugin/plugin_stubs.go | 17 |
3 files changed, 212 insertions, 0 deletions
diff --git a/src/plugin/plugin.go b/src/plugin/plugin.go new file mode 100644 index 0000000000..66cf2f98d4 --- /dev/null +++ b/src/plugin/plugin.go @@ -0,0 +1,70 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package plugin implements loading and symbol resolution of Go plugins. +// +// Currently plugins only work on Linux. +// +// A plugin is a Go main package with exported functions and variables that +// has been built with: +// +// go build -buildmode=plugin +// +// When a plugin is first opened, the init functions of all packages not +// already part of the program are called. The main function is not run. +// A plugin is only initialized once, and cannot be closed. +package plugin + +// Plugin is a loaded Go plugin. +type Plugin struct { + name string + loaded chan struct{} // closed when loaded + syms map[string]interface{} +} + +// Open opens a Go plugin. +func Open(path string) (*Plugin, error) { + return open(path) +} + +// Lookup searches for a symbol named symName in plugin p. +// A symbol is any exported variable or function. +// It reports an error if the symbol is not found. +func (p *Plugin) Lookup(symName string) (Symbol, error) { + return lookup(p, symName) +} + +// A Symbol is a pointer to a variable or function. +// +// For example, a plugin defined as +// +// package main +// +// // // No C code needed. +// import "C" +// +// import "fmt" +// +// var V int +// +// func F() { fmt.Println("Hello, number %d", V) } +// +// may be loaded with the Open function and then the exported package +// symbols V and F can be accessed +// +// p, err := plugin.Open("plugin_name.so") +// if err != nil { +// panic(err) +// } +// v, err := p.Lookup("V") +// if err != nil { +// panic(err) +// } +// f, err := p.Lookup("F") +// if err != nil { +// panic(err) +// } +// *v.(*int) = 7 +// f.(func())() // prints "Hello, number 7" +type Symbol interface{} diff --git a/src/plugin/plugin_dlopen.go b/src/plugin/plugin_dlopen.go new file mode 100644 index 0000000000..5a9421efcf --- /dev/null +++ b/src/plugin/plugin_dlopen.go @@ -0,0 +1,125 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build linux,cgo + +package plugin + +/* +#cgo linux LDFLAGS: -ldl +#include <dlfcn.h> +#include <limits.h> +#include <stdlib.h> +#include <stdint.h> + +static uintptr_t pluginOpen(const char* path, char** err) { + void* h = dlopen(path, RTLD_NOW|RTLD_GLOBAL); + if (h == NULL) { + *err = dlerror(); + } + return (uintptr_t)h; +} + +static void* pluginLookup(uintptr_t h, const char* name, char** err) { + void* r = dlsym((void*)h, name); + if (r == NULL) { + *err = dlerror(); + } + return r; +} +*/ +import "C" + +import ( + "errors" + "sync" + "unsafe" +) + +func open(name string) (*Plugin, error) { + pluginsMu.Lock() + cRelName := C.CString(name) + cPath := C.realpath(cRelName, nil) + C.free(unsafe.Pointer(cRelName)) + defer C.free(unsafe.Pointer(cPath)) + path := C.GoString(cPath) + if p := plugins[path]; p != nil { + pluginsMu.Unlock() + <-p.loaded + return p, nil + } + var cErr *C.char + h := C.pluginOpen(cPath, &cErr) + if h == 0 { + pluginsMu.Unlock() + return nil, errors.New("plugin.Open: " + C.GoString(cErr)) + } + // TODO(crawshaw): look for plugin note, confirm it is a Go plugin + // and it was built with the correct toolchain. + // TODO(crawshaw): get full plugin name from note. + if len(name) > 3 && name[len(name)-3:] == ".so" { + name = name[:len(name)-3] + } + syms := lastmoduleinit() + if plugins == nil { + plugins = make(map[string]*Plugin) + } + // This function can be called from the init function of a plugin. + // Drop a placeholder in the map so subsequent opens can wait on it. + p := &Plugin{ + name: name, + loaded: make(chan struct{}), + syms: syms, + } + plugins[path] = p + pluginsMu.Unlock() + + initStr := C.CString(name + ".init") + initFuncPC := C.pluginLookup(h, initStr, &cErr) + C.free(unsafe.Pointer(initStr)) + if initFuncPC != nil { + initFuncP := &initFuncPC + initFunc := *(*func())(unsafe.Pointer(&initFuncP)) + initFunc() + } + + // Fill out the value of each plugin symbol. + for symName, sym := range syms { + isFunc := symName[0] == '.' + if isFunc { + delete(syms, symName) + symName = symName[1:] + } + + cname := C.CString(name + "." + symName) + p := C.pluginLookup(h, cname, &cErr) + C.free(unsafe.Pointer(cname)) + if p == nil { + return nil, errors.New("plugin.Open: could not find symbol " + symName + ": " + C.GoString(cErr)) + } + valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&sym)) + if isFunc { + (*valp)[1] = unsafe.Pointer(&p) + } else { + (*valp)[1] = p + } + syms[symName] = sym + } + close(p.loaded) + return p, nil +} + +func lookup(p *Plugin, symName string) (Symbol, error) { + if s := p.syms[symName]; s != nil { + return s, nil + } + return nil, errors.New("plugin: symbol " + symName + " not found in plugin " + p.name) +} + +var ( + pluginsMu sync.Mutex + plugins map[string]*Plugin +) + +func lastmoduleinit() map[string]interface{} // in package runtime diff --git a/src/plugin/plugin_stubs.go b/src/plugin/plugin_stubs.go new file mode 100644 index 0000000000..1b935bffa9 --- /dev/null +++ b/src/plugin/plugin_stubs.go @@ -0,0 +1,17 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build !linux !cgo + +package plugin + +import "errors" + +func lookup(p *Plugin, symName string) (interface{}, error) { + return nil, errors.New("plugin: not implemented") +} + +func open(name string) (*Plugin, error) { + return nil, errors.New("plugin: not implemented") +} |