Go语言中通过unsafe包实现mmap内存区域的32位读写

package main

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

const (
    // exampleMemoryOffset 是我们希望进行32位操作的起始偏移量
    exampleMemoryOffset = 8
    // exampleMemoryLength 是模拟的mmap区域的总长度，确保足够容纳32位操作
    exampleMemoryLength = 32
)

func main() {
    // --- 模拟 mmap 区域 ---
    // 在实际的 /dev/mem 场景中，你会执行以下操作：
    // 1. 打开 /dev/mem 文件：
    //    fd, err := syscall.Open("/dev/mem", syscall.O_RDWR|syscall.O_SYNC, 0)
    //    if err != nil {
    //        fmt.Fprintf(os.Stderr, "failed to open /dev/mem: %v\n", err)
    //        return
    //    }
    //    defer syscall.Close(fd)
    //
    // 2. 使用 syscall.Mmap 映射物理地址区域：
    //    // 假设 physicalAddress 是你的硬件寄存器基地址
    //    // length 是你希望映射的区域大小
    //    // 注意：mmap的地址和长度通常需要页对齐
    //    physicalAddress := int64(0x10000000) // 示例物理地址
    //    length := int(4096)                   // 示例映射长度，通常是页大小
    //    
    //    // 为了正确mmap，需要计算页对齐的偏移和长度
    //    pageSize := int64(os.Getpagesize())
    //    offsetInPage := physicalAddress % pageSize
    //    mmapBaseAddr := physicalAddress - offsetInPage
    //    mmapLen := length + int(offsetInPage)
    //
    //    mmapRegion, err := syscall.Mmap(
    //        fd,
    //        mmapBaseAddr,
    //        mmapLen,
    //        syscall.PROT_READ|syscall.PROT_WRITE,
    //        syscall.MAP_SHARED,
    //    )
    //    if err != nil {
    //        fmt.Fprintf(os.Stderr, "failed to mmap /dev/mem: %v\n", err)
    //        return
    //    }
    //    defer syscall.Munmap(mmapRegion)
    //
    //    // 实际操作的切片将是 mmapRegion[offsetInPage : offsetInPage+length]
    //    // 在本示例中，我们使用一个普通的[]byte切片来模拟这个结果，
    //    // 以便专注于 unsafe 包的使用。
    //    a := mmapRegion[offsetInPage : offsetInPage+length]

    // 为了简化示例，我们使用一个普通的字节切片来模拟 mmap 返回的内存区域。
    // 假设 'a' 就是 syscall.Mmap 返回的 []byte。
    a := make([]byte, exampleMemoryLength)
    fmt.Printf("原始字节切片: %v\n", a)

    // --- 执行 32 位写入操作 ---
    // 1. 获取切片中指定偏移量的字节地址。&a[exampleMemoryOffset] 返回 *byte。
    // 2. 将 *byte 转换为 unsafe.Pointer。
    // 3. 将 unsafe.Pointer 转换为 *uint32。
    p := (*uint32)(unsafe.Pointer(&a[exampleMemoryOffset]))

    // 现在 'p' 是一个指向内存中 exampleMemoryOffset 处 32 位无符号整数的指针。
    // 我们可以直接通过解引用 'p' 来执行 32 位写入。
    valueToWrite := uint32(0xabcd0123)
    *p = valueToWrite
    fmt.Printf("在偏移量 %d 处写入 0x%x (32位访问)\n", exampleMemoryOffset, valueToWrite)
    fmt.Printf("写入后的字节切片: %v\n", a)

    // --- 执行 32 位读取操作 ---
    // 同样，直接解引用 'p' 即可读取 32 位值。
    readVal := *p
    fmt.Printf("从偏移量 %d 处读取 0x%x (32位访问)\n", exampleMemoryOffset, readVal)

    // 验证字节级别的表示（注意系统字节序）
    fmt.Println("\n验证写入区域的字节级别表示:")
    // 在小端序系统上，0xabcd0123 将存储为 [0x23, 0x01, 0xcd, 0xab]
    // 在大端序系统上，0xabcd0123 将存储为 [0xab, 0xcd, 0x01, 0x23]
    for i := 0; i < exampleMemoryLength; i++ {
        if i >= exampleMemoryOffset && i < exampleMemoryOffset+4 {
            fmt.Printf("a[%d]: 0x%02x (32位值的一部分)\n", i, a[i])
        } else {
            fmt.Printf("a[%d]: 0x%02x\n", i, a[i])
        }
    }
}

// 实际的 mmap /dev/mem 辅助函数示例 (仅供参考，未在主函数中调用)
func mmapDevMem(physicalAddress, size int64) ([]byte, error) {
    fd, err := syscall.Open("/dev/mem", syscall.O_RDWR|syscall.O_SYNC, 0)
    if err != nil {
        return nil, fmt.Errorf("failed to open /dev/mem: %w", err)
    }
    defer syscall.Close(fd)

    // mmap 要求地址和长度页对齐
    pageSize := int64(os.Getpagesize())
    offsetInPage := physicalAddress % pageSize
    mmapBaseAddr := physicalAddress - offsetInPage
    mmapLen := size + offsetInPage

    // 确保映射长度是页大小的整数倍，且至少为一页
    if mmapLen < pageSize {
        mmapLen = pageSize
    } else if mmapLen%pageSize != 0 {
        mmapLen = (mmapLen/pageSize + 1) * pageSize
    }

    mmapRegion, err := syscall.Mmap(
        fd,
        mmapBaseAddr,
        int(mmapLen),
        syscall.PROT_READ|syscall.PROT_WRITE,
        syscall.MAP_SHARED,
    )
    if err != nil {
        return nil, fmt.Errorf("failed to mmap /dev/mem at 0x%x with length 0x%x: %w", mmapBaseAddr, mmapLen, err)
    }

    // 返回指向所需物理地址范围的切片
    return mmapRegion[offsetInPage : offsetInPage+size], nil
}

// 如何使用 mmapDevMem 辅助函数：
/*
func main() {
    regBaseAddr := int64(0xFE000000) // 示例：一个PCI设备内存区域的基地址
    regSize := int64(0x1000)         // 示例：该区域的大小

    mappedMem, err := mmapDevMem(regBaseAddr, regSize)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error mapping device memory: %v\n", err)
        return
    }
    defer syscall.Munmap(mappedMem) // 确保解除映射

    // 现在 mappedMem 是一个 []byte，代表了物理内存中的寄存器块。
    // 可以使用 unsafe 对其中的特定寄存器进行 32 位访问。
    registerOffset := 0x4 // 示例：一个 32 位寄存器的偏移量
    if registerOffset+4 > len(mappedMem) {
        fmt.Fprintf(os.Stderr, "Register offset out of bounds\n")
        return
    }

    regPtr := (*uint32)(unsafe.Pointer(&mappedMem[registerOffset]))

    // 写入寄存器
    newValue := uint32(0xDEADBEEF)
    *regPtr = newValue
    fmt.Printf("写入寄存器 (偏移量 0x%x): 0x%x\n", registerOffset, newValue)

    // 从寄存器读取
    readValue := *regPtr
    fmt.Printf("从寄存器读取 (偏移量 0x%x): 0x%x\n", registerOffset, readValue)
}
*/