如何“将 Go 指针传递给 Cgo”？

Go 指针传递给 Cgo 时，Go 会固定指针以防止其被垃圾回收。当 Go 指针转换为 C 类型（如 `uintptr` 或 `*c.char`）时，Go 会检查该值是否指向 Go 分配的内存，如果指向，则会进行固定。然而，如果 C 函数签名中使用 `void*` 参数，则 Go 无法确定该参数是否指向 Go 指针，因此不会进行固定。因此，在传递 Go 指针时，建议使用 `unsafe.pointer` 类型，它允许直接传递 Go 指针而不进行任何类型转换。

我对将 go 指针（据我理解，包括所有指针类型以及 unsafe.pointer）传递给 cgo 感到困惑。当使用 cgo 调用 c 函数时，我仅提供 c 端已知类型的变量，或者 unsafe.pointer（如果它与 c 函数签名中的 void* 类型参数匹配）。因此，当“传递给 c 的 go 指针在调用的生命周期内固定”时，如果我被迫将其强制转换为 c.some_wide_enough_uint_type 或 c.some_c_pointer_type，go 如何知道我传递的实际上是一个 go 指针预先？当它被转换的那一刻，它是一个 go 指针的信息不是丢失了，并且我面临着 gc 改变指针的风险吗？ （我至少可以看到当 go 端保留指针类型引用时如何防止释放）

我们有一个项目，其中包含大量可运行的 cgo 代码，但对其可靠性零信心。我希望看到一个“这里是如何正确执行此操作”的示例，它不会通过使用 c.malloc() 等来规避 go 的内存模型，不幸的是，大多数示例都这样做。

因此，无论“在调用的生命周期内固定指针”实际上意味着什么，我都看到了一个问题：

1. 如果这意味着 go 将固定整个程序中的所有指针，我会在将 go 指针转换为 c 类型与实际执行的 cgo 调用之间的时间间隔中看到竞争条件调用。
2. 如果这意味着go只会固定那些正在传递的go指针，那么当调用时它们只能是c类型时，它如何知道它们是go指针？

我已经阅读了半天的 go 问题，开始觉得我只是错过了一些简单的东西。任何指针表示赞赏。

编辑：我将尝试通过提供示例来澄清问题。

考虑一下：

/*
#include 
void mycfunc(void* ptr) {
    printf((char*)ptr);
}
*/
import "c"
import "unsafe"

func callmycfunc() {
    gopointer := []byte("abc123\n\x00")
    c.mycfunc(unsafe.pointer(&gopointer[0]))
}

在这里，go 的 unsafe.pointer 类型毫不费力地转换为 c 的 void* 类型，所以我们对 c 端的事情感到高兴，我们也应该在 go 端：指针明确指向 go - 分配的内存，因此 go 应该很容易弄清楚它应该在调用期间固定该指针，尽管它是一个不安全指针。 是这样吗？如果是这样，无需进一步研究，我会认为这是将 go 指针传递给 cgo 的首选方式。 是吗？

然后，考虑一下：

/*
#include 
void mycfunc(unsigned long long int stupidlytypedpointervariable) {
    char* pointertohopefullystillthesamememory = (char*)stupidlytypedpointervariable;
    printf(pointertohopefullystillthesamememory);
}
*/
import "c"
import "unsafe"

func callmycfunc() {
    gopointer := []byte("abc123\n\x00")
    c.mycfunc(c.ulonglong(uintptr(unsafe.pointer(&gopointer[0]))))
}

在这里，我希望 go 不会对某些 c.ulonglong 类型的变量是否实际上意味着包含 go 指针的地址进行任何猜测。 但是我对吗？

我的困惑很大程度上源于这样一个事实：实际上不可能编写一些代码来可靠地测试它。

最后，这个怎么样：

/*
#include 
void cFuncOverWhichIHaveNoControl(char* ptr) {
    printf(ptr);
}
*/
import "C"
import "unsafe"

func callMyCFunc() {
    goPointer := []byte("abc123\n\x00")
    C.cFuncOverWhichIHaveNoControl((*C.char)(unsafe.Pointer(&goPointer[0])))
}

如果我出于某种原因无法更改 c 函数的签名，我必须强制转换为 *c.char。 当该值已经是 c 指针类型时，go 还会检查该值是否是 go 指针吗？

解决方案

查看 the section on passing pointers in the current cgo documentation，（感谢 peterso）我们发现

go指针一词是指指向go分配的内存的指针

还有

指针类型可以保存 go 指针或 c 指针

因此，使用 uintptr 和其他整数（即：非指针）类型将使我们失去 go 固定指针的保证。

uintptr 是一个整数，而不是一个引用。将指针转换为 uintptr 会创建一个没有指针语义的整数值。即使 uintptr 保存了某个对象的地址，如果该对象移动，垃圾收集器也不会更新该 uintptr 的值，该 uintptr 也不会阻止该对象被回收。

来源：https://golang.org/pkg/unsafe/#Pointer

关于 *char/*c.char 等 c 指针类型，只有当指向的数据本身不包含指向 go 分配的其他内存的指针时，这些才是安全的。这实际上可以是通过尝试触发 go 的 cgo 调试机制来显示，该机制不允许将 go 指针传递给（或传入）本身包含另一个 go 指针的值：

package main

import (
    "fmt"
    "unsafe"

    /*
    #include 

    void cfuncchar(char* ptr) {
        printf("%s\n", ptr);
    }

    void cfuncvoid(void* ptr) {
        printf("%s\n", (char*)ptr);
    }
    */
    "c"
)

type mystruct struct {
    distraction [2]byte
    dangerous *mystruct
}

func main() {
    bypassdetection()
    triggerdetection()
}

func bypassdetection() {
    fmt.println("=== bypass detection ===")
    ms := &mystruct{[2]byte{'a', 0}, &mystruct{[2]byte{0, 0}, nil}}
    c.cfuncchar((*c.char)(unsafe.pointer(ms)))
}

func triggerdetection() {
    fmt.println("=== trigger detection ===")
    ms := &mystruct{[2]byte{'b', 0}, &mystruct{[2]byte{0, 0}, nil}}
    c.cfuncvoid(unsafe.pointer(ms))
}

这将打印以下内容：

=== Bypass Detection ===
A
=== Trigger Detection ===
panic: runtime error: cgo argument has Go pointer to Go pointer

使用*c.char绕过了检测。 仅使用 unsafe.pointer 才能检测 go 指针到 go 指针的情况。不幸的是，这意味着我们必须在 c 函数的签名中偶尔出现模糊的 void* 参数。

为了清楚起见，添加：go 很可能会固定 *c.char 等指向的值，这是可以安全传递的；它只是（合理地）不会努力找出它是否可能包含其他指向 go 分配的内存的指针。转换为 unsafe.pointer 实际上是安全的；铸造来自这可能是危险的。

理论要掌握，实操不能落！以上关于《如何“将 Go 指针传递给 Cgo”？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！