How to read /proc/<pid>/pagemap in a kernel driver?

Question

I am trying to read /proc//pagemap in a kernel driver like this:

    uint64_t page;
    uint64_t va = 0x7FFD1BF46530;`
    loff_t pos = va / PAGE_SIZE * sizeof(uint64_t);
    struct file * filp = filp_open("/proc/19030/pagemap", O_RDONLY, 0);
    ssize_t nread = kernel_read(filp, &page, sizeof(page), &pos);

I get error -22 in nread (EINVAL, invalid argument) and "kernel read not supported for file /19030/pagemap (pid: 19030 comm: tester)" in dmesg.

0x7FFD1BF46530 is a virtual address in a user space process pid 19030 (tester). I assume that pos is the offset into the file like in lseek64.

Doing the precise same thing as sudo with same values in a user space process, i.e. reading /proc/19030/pagemap works fine and produces a correct physical address.

The actual thing I am trying to do here is to find the physical address of a user space virtual address. I need the physical address for a device DMA transfer operation and a user space app needs to access this memory. This app allocates 1GB DMA memory with anonymous mmap from THP (Transparent Huge Pages). And I am trying to avoid the need for sudo by reading /proc//pagemap in a kernel driver via ioctl instead.

I would be happy to allocate huge page DMA memory in the driver but don't know how to do that. dma_alloc_coherent is limited to max 4MB allocations. Is there a way to get those allocated as continuous physical memory? I need hundreds of MB or many GB of DMA memory.

Problem with anonymous mmap is that it can only allocate max 1GB huge page as physically continuous memory. Allocating more works but the memory is not physically continuous and unusable for DMA.

Any good ideas or alternative ways of allocating huge pages as DMA memory?

Tried reading file /proc//pagemap in a kernel driver. Expected same results as when reading the file in a user space application which works ok.

Answer 1

You can use vfs_read instead of kernel_read. kernel version 5.10 read_write.c

ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos){
/*
 * Also fail if ->read_iter and ->read are both wired up as that
 * implies very convoluted semantics.
 */
if (unlikely(!file->f_op->read_iter || file->f_op->read))
    return warn_unsupported(file, "read");}

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos){
if (file->f_op->read)
    ret = file->f_op->read(file, buf, count, pos);
else if (file->f_op->read_iter)
    ret = new_sync_read(file, buf, count, pos);
else
    ret = -EINVAL;}

Any f_op->read or f_op->read_iter is not null, vfs_read can read the file; kernel_read is used for sync read.

As writing kernel buffer, maybe the error code -EFAULT(-14) is returned. so add this code before calling vfs_read

#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)
    old_fs = get_fs();
    set_fs( get_ds() );
#elif LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
    old_fs = get_fs();
    set_fs( KERNEL_DS ); 
#else
    old_fs = force_uaccess_begin();
#endif

and after

#if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
    set_fs(old_fs);
#else
    force_uaccess_end(old_fs);
#endif

If the setting data segment state is unavailable, you can malloc user space memory for reading out to bypass buffer data segment checking.

Answer 2

"kernel read not supported for file …"

Indeed, as we see in __kernel_read()

    if (unlikely(!file->f_op->read_iter || file->f_op->read))
        return warn_unsupported(file, "read");

it fails if f_op->read_iter isn't or f_op->read is wired up (implemented), which is both the case for a pagemap file.

You could try pagemap_read() instead. – not feasible for reasons in the comments

When I had the problem of getting the physical address for a virtual address in a driver, I included and copied some kernel code (not that I recommend this, but I saw no other solution); here's an extract.

static pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr
                                                  , unsigned long sz)
{ return NULL; }

void p4d_clear_bad(p4d_t *p4d) { p4d_ERROR(*p4d); p4d_clear(p4d); }
#include "mm/pagewalk.c"

static int pte(pte_t *pte, unsigned long addr
                         , unsigned long next, struct mm_walk *walk)
{
    *(pte_t **)walk->private = pte;
    return 1;
}

/* Scan the real Linux page tables and return a PTE pointer for
 * a virtual address in a context.
 * Returns true (1) if PTE was found, zero otherwise.  The pointer to
 * the PTE pointer is unmodified if PTE is not found.
 */
int
get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep, pmd_t **pmdp)
{
    struct mm_walk walk = { .pte_entry = pte, .mm = mm, .private = ptep };
    return walk_page_range(addr, addr+PAGE_SIZE, &walk);
}

/* Find physical address for this virtual address.  Normally used by
 * I/O functions, but anyone can call it.
 */
static inline unsigned long iopa(unsigned long addr)
{
    unsigned long pa;

    /* I don't know why this won't work on PMacs or CHRP.  It
     * appears there is some bug, or there is some implicit
     * mapping done not properly represented by BATs or in page
     * tables.......I am actively working on resolving this, but
     * can't hold up other stuff.  -- Dan
     */
    pte_t *pte;
    struct mm_struct *mm;

#if 0
    /* Check the BATs */
    phys_addr_t v_mapped_by_bats(unsigned long va);
    pa = v_mapped_by_bats(addr);
    if (pa)
        return pa;
#endif

    /* Allow mapping of user addresses (within the thread)
     * for DMA if necessary.
     */
    if (addr < TASK_SIZE)
        mm = current->mm;
    else
        mm = &init_mm;
 ATTENTION: I needed the current address space.
            You'd have to use mm = file->private_data instead.

    pa = 0;
    if (get_pteptr(mm, addr, &pte, NULL))
        pa = (pte_val(*pte) & PAGE_MASK) | (addr & ~PAGE_MASK);
    return(pa);
}