Go语言中通过unsafe实现/dev/mem内存映射区域的32位访问

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 1. 创建一个字节切片，模拟mmap'd的内存区域
    // 在实际应用中，mmapRegion 会是 syscall.Mmap("/dev/mem", ...) 的返回值
    mmapRegion := make([]byte, 32) // 创建一个32字节的切片

    fmt.Printf("原始切片内容 (前16字节): %x\n", mmapRegion[:16])

    // 2. 假设我们要在偏移量 8 处写入一个 32 位值 (0xABCD0123)
    // 获取切片中索引 8 处的字节地址
    byteAddr := &mmapRegion[8]

    // 将字节地址转换为 unsafe.Pointer
    // unsafe.Pointer 可以看作是任何类型的指针，用于在不同指针类型之间转换
    genericPtr := unsafe.Pointer(byteAddr)

    // 将通用指针转换为 *uint32 类型指针
    // 现在 uint32Ptr 指向了 mmapRegion[8] 开始的4个字节，并将其解释为 uint32
    uint32Ptr := (*uint32)(genericPtr)

    // 通过解引用 *uint32 指针来写入 32 位值
    valueToWrite := uint32(0xABCD0123)
    *uint32Ptr = valueToWrite
    fmt.Printf("在偏移量 8 处写入 32 位值: 0x%x\n", valueToWrite)

    // 3. 验证写入结果
    // 再次打印切片内容，可以看到偏移量 8 处的值已改变
    // 注意：输出的字节顺序取决于系统的字节序 (endianness)
    fmt.Printf("写入后切片内容 (前16字节): %x\n", mmapRegion[:16])

    // 4. 假设我们从偏移量 0 处读取一个 32 位值
    // 同样地，获取地址，转换指针，然后解引用读取
    readPtr := (*uint32)(unsafe.Pointer(&mmapRegion[0]))
    readValue := *readPtr
    fmt.Printf("从偏移量 0 处读取 32 位值: 0x%x\n", readValue)

    // 5. 再次写入一个不同的值，例如在偏移量 4 处写入 0xDEADBEEF
    secondUint32Ptr := (*uint32)(unsafe.Pointer(&mmapRegion[4]))
    secondValueToWrite := uint32(0xDEADBEEF)
    *secondUint32Ptr = secondValueToWrite
    fmt.Printf("在偏移量 4 处写入 32 位值: 0x%x\n", secondValueToWrite)
    fmt.Printf("再次写入后切片内容 (前16字节): %x\n", mmapRegion[:16])
}

package main

import (
    "fmt"
    "syscall"
    "unsafe"
    "os"
)

// 假设的硬件寄存器地址和大小
const (
    PCI_REGISTER_BASE_ADDR = 0x10000000 // 假设的物理基地址
    MAP_SIZE               = 4096       // 映射大小，通常是页对齐的
    REGISTER_OFFSET        = 0x100      // 假设寄存器相对于基地址的偏移量
)

func main() {
    // 1. 打开 /dev/mem 文件
    fd, err := syscall.Open("/dev/mem", syscall.O_RDWR|syscall.O_SYNC, 0)
    if err != nil {
        fmt.Fprintf(os.Stderr, "无法打开 /dev/mem: %v\n", err)
        return
    }
    defer syscall.Close(fd) // 确保文件描述符被关闭

    // 2. 内存映射指定区域
    // offset参数是文件偏移量，对于/dev/mem通常是物理地址
    mmapRegion, err := syscall.Mmap(fd, PCI_REGISTER_BASE_ADDR, MAP_SIZE, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Mmap 失败: %v\n", err)
        return
    }
    defer syscall.Munmap(mmapRegion) // 确保内存映射被解除

    fmt.Printf("成功映射 /dev/mem 区域，大小: %d 字节\n", len(mmapRegion))

    // 3. 对映射区域进行 32 位读写
    // 获取寄存器在 mmapRegion 中的实际偏移量
    // 注意：如果 PCI_REGISTER_BASE_ADDR 不是页对齐的，mmap的第二个参数可能需要调整
    // 并且 mmapRegion[0] 对应的是 mmap 的第二个参数的地址
    // 这里的 REGISTER_OFFSET 应该相对于 mmapRegion 的起始地址
    targetOffset := REGISTER_OFFSET // 假设寄存器在映射区域内的偏移量

    if targetOffset+4 > len(mmapRegion) {
        fmt.Fprintf(os.Stderr, "目标偏移量超出映射区域范围\n")
        return
    }

    // 获取目标寄存器的 32 位指针
    regPtr := (*uint32)(unsafe.Pointer(&mmapRegion[targetOffset]))

    // 读取当前寄存器值
    currentValue := *regPtr
    fmt.Printf("从偏移量 0x%x 处读取原始 32 位值: 0x%x\n", targetOffset, currentValue)

    // 写入新的 32 位值
    newValue := uint32(0xFEEDFACE)
    *regPtr = newValue
    fmt.Printf("向偏移量 0x%x 处写入新的 32 位值: 0x%x\n", targetOffset, newValue)

    // 再次读取验证
    verifiedValue := *regPtr
    fmt.Printf("从偏移量 0x%x 处验证写入的 32 位值: 0x%x\n", targetOffset, verifiedValue)
}