如何从Go编写的Wasm Guest端发起Wasm宿主函数调用

核心原理 #

Wasm Guest与宿主的调用边界基于「导入表匹配+线性内存共享」实现：Guest端不直接访问宿主内存，所有跨边界调用预先通过函数导入/导出表做符号匹配，非基础类型（字符串、结构体、数组）统一通过Wasm 32位线性内存传递偏移量（指针）与长度，返回值遵循相同规则。

本方案全程使用纯Go实现，无CGO依赖，可通用适配所有自定义宿主函数场景，包括Fastly Compute@Edge ABI。 #

具体实现步骤 #

1. 宿主侧：注册自定义函数到Wasm运行时 #

选用纯Go实现的wazero作为Wasm运行时（无外部依赖，符合纯Go要求），注册函数时需保证模块名、函数名、参数签名与ABI定义完全一致，所有Wasm侧传入的指针、长度参数统一使用uint32类型接收（匹配Wasm 1.0规范的32位线性内存地址空间）。
示例代码：

package main

import (
	"bytes"
	"context"
	"net/http"

	"github.com/tetratelabs/wazero"
	"github.com/tetratelabs/wazero/api"
)

func main() {
	ctx := context.Background()
	// 初始化纯Go Wasm运行时
	r := wazero.NewRuntime(ctx)
	defer r.Close(ctx)

	// 注册Fastly ABI对应的宿主模块，模块名必须与witx定义一致
	_, err := r.NewHostModuleBuilder("fastly_abi").
		// 注册send_req宿主函数，签名完全对齐witx定义
		NewFunctionBuilder().
		WithFunc(func(ctx context.Context, mod api.Module,
			methodPtr uint32, methodLen uint32,
			bodyPtr uint32, bodyLen uint32,
			respHandleOut uint32,
		) uint32 {
			mem := mod.Memory()

			// 从Wasm线性内存读取Guest传入的参数
			methodBytes, ok := mem.Read(methodPtr, methodLen)
			if !ok {
				return 1 // 返回ABI定义的参数错误码
			}
			bodyBytes, ok := mem.Read(bodyPtr, bodyLen)
			if !ok {
				return 1
			}

			// 执行宿主侧实际业务逻辑，示例为发起HTTP请求
			req, err := http.NewRequest(string(methodBytes), "https://example.com", bytes.NewReader(bodyBytes))
			if err != nil {
				return 2 // 返回业务错误码
			}
			resp, err := http.DefaultClient.Do(req)
			if err != nil {
				return 2
			}
			defer resp.Body.Close()

			// 将返回值写入Wasm线性内存，供Guest读取
			_ = mem.WriteUint32Le(respHandleOut, 1) // 示例返回句柄值为1
			return 0 // ABI定义的成功状态码
		}).
		Export("send_req"). // 导出函数名必须与witx定义完全一致
		Instantiate(ctx)
	if err != nil {
		panic(err)
	}

	// 后续加载并实例化编译好的Guest Wasm模块即可
}

2. Guest侧：声明导入函数并实现调用逻辑 #

使用Go编译Wasm Target（GOOS=wasip1 GOARCH=wasm）时，通过//go:wasmimport编译指令声明要导入的宿主函数，模块名、函数名、参数顺序必须与宿主侧注册的配置完全对齐。
跨边界传递非基础类型时，先获取数据在Wasm线性内存中的偏移指针，再以uint32类型传入，不要直接传递Go原生的切片、字符串、结构体指针。
示例代码：

package main

import (
	"fmt"
	"unsafe"
)

// 声明导入的宿主函数，签名与宿主侧、witx定义完全一致
//go:wasmimport fastly_abi send_req
func fastlySendReq(methodPtr uint32, methodLen uint32, bodyPtr uint32, bodyLen uint32, respHandleOut uint32) uint32

// 辅助函数：获取Go字节数组在Wasm线性内存中的指针与长度
func bytesToPtr(b []byte) (uint32, uint32) {
	if len(b) == 0 {
		return 0, 0
	}
	return uint32(uintptr(unsafe.Pointer(&b[0]))), uint32(len(b))
}

// 业务侧封装的可直接调用的请求方法
func SendRequest(method string, body []byte) (uint32, error) {
	mPtr, mLen := bytesToPtr(unsafe.Slice(unsafe.StringData(method), len(method)))
	bPtr, bLen := bytesToPtr(body)

	var respHandle uint32
	errCode := fastlySendReq(mPtr, mLen, bPtr, bLen, uint32(uintptr(unsafe.Pointer(&respHandle))))
	if errCode != 0 {
		return 0, fmt.Errorf("call host failed, err code: %d", errCode)
	}
	return respHandle, nil
}

func main() {
	// 业务逻辑调用
	handle, err := SendRequest("GET", nil)
	if err != nil {
		panic(err)
	}
	println("got resp handle:", handle)
}

通用适配注意点 #

• 所有符号（模块名、函数名）、参数顺序、类型长度、错误码定义必须严格匹配witx文档，任意一项不匹配都会导致导入失败或内存越界
• 跨边界传递结构体时，必须保证宿主与Guest侧的结构体内存对齐规则完全一致，建议优先用字节数组序列化后传递，避免对齐问题
• 适配Fastly Compute@Edge这类标准ABI时，可先批量将witx定义的所有函数转换为对应Go函数签名，再逐个实现宿主侧逻辑，无需修改上层业务调用代码，行为与官方运行时完全一致
• 若使用wasmtime-go等其他运行时，核心逻辑完全一致，仅API调用方式有区别，同样遵循导入表注册+线性内存传参的规则

内容的提问来源于stack exchange，提问作者Grokify