Hello,

I'm writing a linux driver that reading the data of a page frame of an process. But when I use it, it make immediately freeze the system. Can you help me? Thank for reading my question!

system: Ubuntu 9.04, kernel 2.6.28.15, Intel Duo

static int read_addr(int pid, unsigned long linear_addr, unsigned int n_bytes, char* buff){
    /* 
    pid: id of process
    linear_addr: linear address of memory region to be read
    n_bytes: nombre bytes to be read
    buff: the buffer containing the result
    */
    
    struct task_struct *task;
       struct mm_struct *mm = NULL;

    pgd_t *pgd;
    pmd_t *pmd; 
    pte_t *pte; 
    unsigned long pteval;

    int ret = 0;    

    for_each_process(task) {
        if ( task->pid == pid) {
            mm = task->mm;
        }
    }
    if(mm == NULL)
        return 1;
 
    spin_lock(&mm->page_table_lock); 
    
    pgd = pgd_offset(mm, linear_addr); 
    if (pgd_none(*pgd)) { ret = 2; goto out; }
    
    pmd = pmd_offset(pgd, linear_addr); 
    if (pmd_none(*pmd)) { ret = 3; goto out; }
    
    pte = pte_offset_map(pmd, linear_addr);
    
    if (pte_present(*pte)){
        unsigned long pteid = pte_index(linear_addr);
        pteval = pte_val(*pte);
        memcpy(buff, pteval + pteid, n_bytes);     
    } else { 
        ret = 4;
        goto out;
    } 
    pte_unmap(pte);
    spin_unlock(&mm->page_table_lock);
    return 0; 

 out:
     printk("error: %d\n", ret); 
    spin_unlock(&mm->page_table_lock);
    return ret;        
}

I'm not a kernel programmer, but this seems like a deadlock; I'd be concerned about pte_offset_map trying to do the same lock you made earlier.

Thank Corona688.

I think that the problem does not locate at the pte_offset_map because it gives a positive result. In the code above, the command that make freeze the system is the memcpy

memcpy(buff, pteval + pteid, n_bytes);

But I don't know why.