...
Run Format

Source file src/plugin/plugin_dlopen.go

Documentation: plugin

     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)
   163  

View as plain text