version: 1.10

package plugin

import "plugin"

Overview

Package plugin implements loading and symbol resolution of Go plugins.

A plugin is a Go main package with exported functions and variables that has been built with:

  1. 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.

Currently plugins are only supported on Linux and macOS. Please report any issues.

Index

Package files

plugin.go plugin_dlopen.go

type Plugin 

  1. type Plugin struct {
  2.     // contains filtered or unexported fields
  3. }

Plugin is a loaded Go plugin.

func Open 

  1. func Open(path string) (*Plugin, error)

Open opens a Go plugin. If a path has already been opened, then the existing *Plugin is returned. It is safe for concurrent use by multiple goroutines.

func (*Plugin) Lookup 

  1. func (p *Plugin) Lookup(symName string) (Symbol, error)

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. It is safe for concurrent use by multiple goroutines.

type Symbol 

  1. type Symbol interface{}

A Symbol is a pointer to a variable or function.

For example, a plugin defined as

  1. package main
  3. import "fmt"
  5. var V int
  7. func F() { fmt.Printf("Hello, number %d\n", V) }

may be loaded with the Open function and then the exported package symbols V and F can be accessed

  1. p, err := plugin.Open("plugin_name.so")
  2. if err != nil {
  3.     panic(err)
  4. }
  5. v, err := p.Lookup("V")
  6. if err != nil {
  7.     panic(err)
  8. }
  9. f, err := p.Lookup("F")
  10. if err != nil {
  11.     panic(err)
  12. }
  13. *v.(*int) = 7
  14. f.(func())() // prints "Hello, number 7"