从 C 调用 Go 函数

Question

我正在尝试创建一个用 Go 编写的静态对象来与 C 程序（例如，内核模块或其他东西）交互。

我找到了有关从 Go 调用 C 函数的文档，但我还没有找到太多关于如何使用其他方法的文档。我发现这是可能的，但很复杂。

这是我发现的：

关于 C 和 Go 之间回调的博客文章

Cgo 文档

Golang 邮件列表帖子

有人有这方面的经验吗？简而言之，我正在尝试创建一个完全用 Go 编写的 PAM 模块。

Answer 1

您可以从 C 调用 Go 代码。不过，这是一个令人困惑的命题。

您链接到的博客文章中概述了该过程。但我可以看出这并没有多大帮助。这是一个简短的片段，没有任何不必要的部分。它应该让事情变得更清楚一些。

package foo

// extern int goCallbackHandler(int, int);
//
// static int doAdd(int a, int b) {
//     return goCallbackHandler(a, b);
// }
import "C"

//export goCallbackHandler
func goCallbackHandler(a, b C.int) C.int {
    return a + b
}

// This is the public function, callable from outside this package.
// It forwards the parameters to C.doAdd(), which in turn forwards
// them back to goCallbackHandler(). This one performs the addition
// and yields the result.
func MyAdd(a, b int) int {
   return int( C.doAdd( C.int(a), C.int(b)) )
}

所有内容的调用顺序如下：

foo.MyAdd(a, b) ->
  C.doAdd(a, b) ->
    C.goCallbackHandler(a, b) ->
      foo.goCallbackHandler(a, b)

这里要记住的关键是，回调函数必须在 Go 端使用 //export 注释进行标记，并且标记为 extern 在 C 侧。这意味着您希望使用的任何回调都必须在包内定义。

为了允许您的包的用户提供自定义回调函数，我们使用与上面完全相同的方法，但我们提供用户的自定义处理程序（这只是一个常规的 Go 函数）作为传递到 C 的参数侧面为 void*。然后它被我们包中的回调处理程序接收并调用。

让我们使用我目前正在使用的一个更高级的示例。在本例中，我们有一个 C 函数来执行一项相当繁重的任务：它从 USB 设备读取文件列表。这可能需要一段时间，因此我们希望我们的应用程序能够收到进度通知。我们可以通过传入我们在程序中定义的函数指针来做到这一点。它只是在被调用时向用户显示一些进度信息。由于它具有众所周知的签名，因此我们可以为其分配自己的类型：

type ProgressHandler func(current, total uint64, userdata interface{}) int

该处理程序获取一些进度信息（当前接收的文件数和文件总数）以及一个 interface{} 值，该值可以保存用户需要的任何内容抓住。

现在我们需要编写 C 和 Go 管道来允许我们使用这个处理程序。幸运的是，我希望从库中调用的 C 函数允许我们传入 void* 类型的用户数据结构。这意味着它可以容纳我们想要它容纳的任何内容，无需提出任何问题，我们将按原样将其带回 Go 世界。为了使这一切顺利进行，我们不直接从 Go 调用库函数，而是为其创建一个 C 包装器，将其命名为 goGetFiles()。正是这个包装器实际上向 C 库提供了我们的 Go 回调以及用户数据对象。

package foo

// #include <somelib.h>
// extern int goProgressCB(uint64_t current, uint64_t total, void* userdata);
// 
// static int goGetFiles(some_t* handle, void* userdata) {
//    return somelib_get_files(handle, goProgressCB, userdata);
// }
import "C"
import "unsafe"

请注意，goGetFiles() 函数不将任何回调函数指针作为参数。相反，我们的用户提供的回调被打包在一个自定义结构中，该结构保存该处理程序和用户自己的用户数据值。我们将其作为 userdata 参数传递给 goGetFiles()。

// This defines the signature of our user's progress handler,
type ProgressHandler func(current, total uint64, userdata interface{}) int 

// This is an internal type which will pack the users callback function and userdata.
// It is an instance of this type that we will actually be sending to the C code.
type progressRequest struct {
   f ProgressHandler  // The user's function pointer
   d interface{}      // The user's userdata.
}

//export goProgressCB
func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) C.int {
    // This is the function called from the C world by our expensive 
    // C.somelib_get_files() function. The userdata value contains an instance
    // of *progressRequest, We unpack it and use it's values to call the
    // actual function that our user supplied.
    req := (*progressRequest)(userdata)
    
    // Call req.f with our parameters and the user's own userdata value.
    return C.int( req.f( uint64(current), uint64(total), req.d ) )
}

// This is our public function, which is called by the user and
// takes a handle to something our C lib needs, a function pointer
// and optionally some user defined data structure. Whatever it may be.
func GetFiles(h *Handle, pf ProgressFunc, userdata interface{}) int {
   // Instead of calling the external C library directly, we call our C wrapper.
   // We pass it the handle and an instance of progressRequest.

   req := unsafe.Pointer(&progressequest{ pf, userdata })
   return int(C.goGetFiles( (*C.some_t)(h), req ))
}

这就是我们的 C 绑定。用户的代码现在非常简单：

package main

import (
    "foo"
    "fmt"
)

func main() {
    handle := SomeInitStuff()
    
    // We call GetFiles. Pass it our progress handler and some
    // arbitrary userdata (could just as well be nil).
    ret := foo.GetFiles( handle, myProgress, "Callbacks rock!" )

    ....
}

// This is our progress handler. Do something useful like display.
// progress percentage.
func myProgress(current, total uint64, userdata interface{}) int {
    fc := float64(current)
    ft := float64(total) * 0.01

    // print how far along we are.
    // eg: 500 / 1000 (50.00%)
    // For good measure, prefix it with our userdata value, which
    // we supplied as "Callbacks rock!".
    fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc / ft)
    return 0
}

这一切看起来比实际复杂得多。与之前的示例相比，调用顺序没有改变，但我们在链的末尾得到了两个额外的调用：

顺序如下：

foo.GetFiles(....) ->
  C.goGetFiles(...) ->
    C.somelib_get_files(..) ->
      C.goProgressCB(...) ->
        foo.goProgressCB(...) ->
           main.myProgress(...)

Answer 2

如果您使用 gccgo，这并不是一个令人困惑的命题。这在这里工作：

foo.go

package main

func Add(a, b int) int {
    return a + b
}

bar.c

#include <stdio.h>

extern int go_add(int, int) __asm__ ("example.main.Add");

int main() {
  int x = go_add(2, 3);
  printf("Result: %d\n", x);
}

Makefile

all: main

main: foo.o bar.c
    gcc foo.o bar.c -o main

foo.o: foo.go
    gccgo -c foo.go -o foo.o -fgo-prefix=example

clean:
    rm -f main *.o

Answer 3

随着 Go 1.5 的发布，答案发生了变化

我前段时间提出的这个问题根据 1.5 添加的功能再次解决了这个问题

在现有 C 项目中使用 Go 代码

Answer 4

就我而言，这是不可能的：

注意：如果您使用的是，则不能在序言中定义任何 C 函数
出口。

来源：https://github.com/golang/go/wiki/cgo