Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-30b-a3b· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

帮我写一个arm64 linux内核读取指定pid虚拟地址的对应物理内存的内核模块

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    帮我写一个arm64 linux内核读取指定pid虚拟地址的对应物理内存的内核模块

  2. Qwen Assistant

    以下是一个用于 ARM64 Linux 内核 的模块,用于根据指定的 PID 和 虚拟地址 读取对应的 物理内存。该模块基于内核页表遍历机制,兼容普通页(4KB)、大页(2MB/1GB)等内存映射方式,并通过 /proc 接口与用户空间交互。


    📦 模块功能概述

    • 目标:根据 PID 和 虚拟地址,查找其对应的物理地址并读取物理内存内容。
    • 支持架构:ARM64
    • 支持内存类型:普通页(4KB)、2MB 大页、1GB 大页
    • 接口方式:通过 /proc/virt_phys_reader 与用户空间交互
    • 安全性:模块需以 root 权限加载,仅用于调试用途

    🧩 模块实现代码

    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/init.h>
    #include <linux/proc_fs.h>
    #include <linux/uaccess.h>
    #include <linux/sched.h>
    #include <linux/mm.h>
    #include <linux/pid.h>
    #include <linux/highmem.h>
    #include <asm/pgtable.h>
    #include <asm/io.h>
    
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("ARM64 Memory Reader");
    MODULE_DESCRIPTION("Read physical memory by PID and virtual address on ARM64");
    MODULE_VERSION("1.0");
    
    #define PROC_NAME "virt_phys_reader"
    #define MAX_BUFFER_SIZE 256
    
    // 用于 proc 接口的结构体
    struct mem_request {
        pid_t pid;
        unsigned long vaddr;
        size_t size;
    };
    
    // 用于 proc 接口的响应结构体
    struct mem_response {
        unsigned long paddr;
        int success;
        char data[64];
        size_t data_len;
    };
    
    // 通过页表遍历获取物理地址
    static unsigned long virt_to_phys_by_pid(pid_t pid, unsigned long vaddr)
    {
        struct task_struct *task;
        struct mm_struct *mm;
        pgd_t *pgd;
        p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
        unsigned long paddr = 0;
    
        rcu_read_lock();
        task = pid_task(find_vpid(pid), PIDTYPE_PID);
        if (!task) {
            rcu_read_unlock();
            printk(KERN_ERR "Process with PID %d not found\n", pid);
            return 0;
        }
    
        mm = get_task_mm(task);
        rcu_read_unlock();
    
        if (!mm) {
            printk(KERN_ERR "Cannot get mm_struct for PID %d\n", pid);
            return 0;
        }
    
        down_read(&mm->mmap_lock);
    
        struct vm_area_struct *vma = find_vma(mm, vaddr);
        if (!vma || vaddr < vma->vm_start) {
            printk(KERN_ERR "Address 0x%lx not in valid VMA for PID %d\n", vaddr, pid);
            goto out;
        }
    
        pgd = pgd_offset(mm, vaddr);
        if (pgd_none(*pgd) || pgd_bad(*pgd)) {
            printk(KERN_ERR "Invalid PGD for address 0x%lx\n", vaddr);
            goto out;
        }
    
        p4d = p4d_offset(pgd, vaddr);
        if (p4d_none(*p4d) || p4d_bad(*p4d)) {
            printk(KERN_ERR "Invalid P4D for address 0x%lx\n", vaddr);
            goto out;
        }
    
        pud = pud_offset(p4d, vaddr);
        if (pud_none(*pud)) {
            printk(KERN_ERR "Invalid PUD for address 0x%lx\n", vaddr);
            goto out;
        }
    
        if (pud_sect(*pud)) {
            paddr = (pud_val(*pud) & PUD_MASK) + (vaddr & ~PUD_MASK);
            printk(KERN_INFO "Found 1GB huge page: vaddr=0x%lx -> paddr=0x%lx\n", vaddr, paddr);
            goto out;
        }
    
        if (pud_bad(*pud)) {
            printk(KERN_ERR "Bad PUD for address 0x%lx\n", vaddr);
            goto out;
        }
    
        pmd = pmd_offset(pud, vaddr);
        if (pmd_none(*pmd)) {
            printk(KERN_ERR "Invalid PMD for address 0x%lx\n", vaddr);
            goto out;
        }
    
        if (pmd_sect(*pmd)) {
            paddr = (pmd_val(*pmd) & PMD_MASK) + (vaddr & ~PMD_MASK);
            printk(KERN_INFO "Found 2MB huge page: vaddr=0x%lx -> paddr=0x%lx\n", vaddr, paddr);
            goto out;
        }
    
        if (pmd_bad(*pmd)) {
            printk(KERN_ERR "Bad PMD for address 0x%lx\n", vaddr);
            goto out;
        }
    
        pte = pte_offset_map(pmd, vaddr);
        if (!pte) {
            printk(KERN_ERR "Cannot map PTE for address 0x%lx\n", vaddr);
            goto out;
        }
    
        if (!pte_present(*pte)) {
            printk(KERN_ERR "PTE not present for address 0x%lx\n", vaddr);
            pte_unmap(pte);
            goto out;
        }
    
        struct page *page = pte_page(*pte);
        paddr = page_to_phys(page) + (vaddr & ~PAGE_MASK);
    
        printk(KERN_INFO "Normal page: vaddr=0x%lx -> paddr=0x%lx\n", vaddr, paddr);
    
        pte_unmap(pte);
    
    out:
        up_read(&mm->mmap_lock);
        mmput(mm);
        return paddr;
    }
    
    // 读取物理内存内容
    static int read_physical_memory(unsigned long paddr, void *buffer, size_t size)
    {
        void __iomem *mapped_addr;
    
        if (size > 64) {
            size = 64;
        }
    
        mapped_addr = ioremap(paddr, size);
        if (!mapped_addr) {
            printk(KERN_ERR "Failed to ioremap physical address 0x%lx\n", paddr);
            return -ENOMEM;
        }
    
        memcpy_fromio(buffer, mapped_addr, size);
        iounmap(mapped_addr);
        return 0;
    }
    
    // proc 文件写入处理
    static ssize_t proc_write(struct file *file, const char __user *buffer,
                              size_t count, loff_t *pos)
    {
        char input[MAX_BUFFER_SIZE];
        struct mem_request req;
        struct mem_response resp;
        unsigned long paddr;
        int ret;
    
        if (count >= MAX_BUFFER_SIZE) {
            return -EINVAL;
        }
    
        if (copy_from_user(input, buffer, count)) {
            return -EFAULT;
        }
        input[count] = '\0';
    
        ret = sscanf(input, "%d,0x%lx,%zu", &req.pid, &req.vaddr, &req.size);
        if (ret != 3) {
            printk(KERN_ERR "Invalid input format. Use: pid,0xvaddr,size\n");
            return -EINVAL;
        }
    
        if (req.size > 64) {
            req.size = 64;
        }
    
        printk(KERN_INFO "Request: PID=%d, VAddr=0x%lx, Size=%zu\n",
               req.pid, req.vaddr, req.size);
    
        paddr = virt_to_phys_by_pid(req.pid, req.vaddr);
        if (paddr == 0) {
            printk(KERN_ERR "Failed to get physical address\n");
            return -EFAULT;
        }
    
        memset(&resp, 0, sizeof(resp));
        resp.paddr = paddr;
        ret = read_physical_memory(paddr, resp.data, req.size);
        if (ret == 0) {
            resp.success = 1;
            resp.data_len = req.size;
            printk(KERN_INFO "Successfully read %zu bytes from physical address 0x%lx\n",
                   req.size, paddr);
    
            int i;
            char hex_str[256] = {0};
            for (i = 0; i < req.size && i < 32; i++) {
                sprintf(hex_str + strlen(hex_str), "%02x ", (unsigned char)resp.data[i]);
            }
            printk(KERN_INFO "Data: %s\n", hex_str);
        } else {
            resp.success = 0;
            printk(KERN_ERR "Failed to read physical memory\n");
        }
    
        return count;
    }
    
    // proc 文件读取处理
    static ssize_t proc_read(struct file *file, char __user *buffer,
                             size_t count, loff_t *pos)
    {
        static char output[512];
        static int output_len = 0;
    
        if (*pos > 0) {
            return 0;
        }
    
        output_len = snprintf(output, sizeof(output),
            "ARM64 Virtual to Physical Memory Reader\n"
            "Usage: echo 'pid,0xvaddr,size' > /proc/%s\n"
            "Example: echo '1234,0x7fff12345000,16' > /proc/%s\n"
            "Check dmesg for results\n",
            PROC_NAME, PROC_NAME);
    
        if (count < output_len) {
            return -EINVAL;
        }
    
        if (copy_to_user(buffer, output, output_len)) {
            return -EFAULT;
        }
    
        *pos = output_len;
        return output_len;
    }
    
    static const struct proc_ops proc_fops = {
        .proc_read = proc_read,
        .proc_write = proc_write,
    };
    
    // 模块初始化
    static int __init mem_reader_init(void)
    {
        printk(KERN_INFO "ARM64 Memory Reader module loaded\n");
    
        proc_entry = proc_create(PROC_NAME, 0666, NULL, &proc_fops);
        if (!proc_entry) {
            printk(KERN_ERR "Failed to create /proc/%s\n", PROC_NAME);
            return -ENOMEM;
        }
    
        printk(KERN_INFO "Created /proc/%s\n", PROC_NAME);
        return 0;
    }
    
    // 模块清理
    static void __exit mem_reader_exit(void)
    {
        if (proc_entry) {
            proc_remove(proc_entry);
            printk(KERN_INFO "Removed /proc/%s\n", PROC_NAME);
        }
        printk(KERN_INFO "ARM64 Memory Reader module unloaded\n");
    }
    
    module_init(mem_reader_init);
    module_exit(mem_reader_exit);
    

    🛠️ 使用方法

    1. 编译模块

    创建 Makefile:

    obj-m += virt_to_phys_reader.o
    
    KDIR := /lib/modules/$(shell uname -r)/build
    PWD := $(shell pwd)
    
    all:
    	$(MAKE) -C $(KDIR) M=$(PWD) modules
    
    clean:
    	$(MAKE) -C $(KDIR) M=$(PWD) clean
    

    执行编译:

    make
    

    2. 加载模块

    sudo insmod virt_to_phys_reader.ko
    

    3. 使用模块

    # 示例:读取 PID 1234 的虚拟地址 0x7fff12345000 处的 16 字节数据
    echo "1234,0x7fff12345000,16" | sudo tee /proc/virt_phys_reader
    
    # 查看内核日志
    dmesg | tail -20
    

    4. 卸载模块

    sudo rmmod virt_to_phys_reader
    

    📌 注意事项

    • 权限要求:模块需以 root 权限加载。
    • 安全性:此模块仅用于调试用途,不建议在生产环境中使用。
    • 内存访问限制:部分内存区域可能因权限或保护机制无法访问。
    • 内核版本兼容性:本模块基于通用内核接口编写,适用于大多数 ARM64 系统,但可能存在版本差异。

    ✅ 总结

    本模块实现了在 ARM64 Linux 内核 中根据指定 PID 和 虚拟地址 获取其对应的 物理地址,并读取物理内存内容的功能。模块通过 /proc 接口与用户空间交互,支持普通页和大页(2MB/1GB)内存映射,适用于调试和学习用途。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.