nopage () method implementation

Question

Any one know about how virtual address is translated to physical address in no page method. with reference to Device Drivers book the nopage method is given as ,

struct page *simple_vma_nopage(struct vm_area_struct *vma,
                unsigned long address, int *type)
{
    struct page *pageptr;
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
    unsigned long physaddr = address - vma->vm_start + offset;
    unsigned long pageframe = physaddr >> PAGE_SHIFT;

    if (!pfn_valid(pageframe))
        return NOPAGE_SIGBUS;
    pageptr = pfn_to_page(pageframe);
    get_page(pageptr);
    if (type)
        *type = VM_FAULT_MINOR;
    return pageptr;
}

page_shift is the number of bits used to reperesent offset for Virtual and physical memory address. But what is the offset variable ? How a physical address is calculated from arithmetic operations on virtual address variables like address and vm_start ?

Answer 1

I feel the documentation of vm_pgoff is not very clear. This is the offset of the first page of the memory region in RAM. So if our RAM begins at 0x00000000, and our memory region begins at 0x0000A000, then vm_pgoff = 10. If you consider/ revisit the mmap system call then you can see that the "offset" which we pass is the offset of the starting byte in the file from which "length" bytes will be mapped on to the memory region. This offset can be converted to address by left shifting it to PAGE_SHIFT value which is 12 (i.e. 4KB per page size)

Now, irrespective of whether the cr3 register is used in linear address to physical address translation or not, when we say that "address - vm_start" then this gives the size of portion between the addresses. example: vm_start = 0xc0080000 address = 0xc0090000

address - vm_start = 0x00010000
physaddr    = (address - vma->vm_start) + offset;
            = 0x00010000 + (10 << PAGE_SHIFT)
            = offset_to_page_that_fault + start_addr_of_memoryRegion_in_RAM  
            = 0x00010000 + 0x0000A000
            = 0x0001A000

Now since this is the physical address therefore we need to convert to page frame number by right shifting by PAGE_SHIFT value i.e 0x0001A000 >> 12 = 0x1A = 26 (decimal) Therefore the 26th page-frame must be loaded with the data from the file which is being mapped. Hence data is retrieved from the disk by using the inode's struct address_sapce which contains the information of the location of page on the disk (swap space). Once the data is brought in we return the struct page which represents this data in the page_frame for which this page fault occurred. We return this to the user.

This is my understanding of the latest but I haven't tested it.

Answer 2

"simple_region_start" is the offset from the starting of physical memory out of which our sub-region needs to be mapped

Example: off = start of the physical memory (page aligned)= 0xd000 8000 simple_region_start = 0x1000 therefore the physical address of the start of the sub region we want to map is = 0xd000 8000 + 0x1000 = 0xd000 9000

now virtual size is the portion that needs to be mapped from the physical memory available. This must be defined properly by the user.

simple_region_size = physical address pointing to last of the portion that we need to map.

So if we wanted 8KBs to be mapped from the physical memory available then following is how the calculation goes

simple_region_size = physical address just beyond the last of our portion
simple_region_size = 0xd000 9000 + 0x2000 (for the 8KBs)    
simple_region_size = 0xd000 B000

So our 8KBs of portion will range from physical addresses [0xd000 B000 to 0xd000 9000] Hence physical size i.e. psize = 0x2000

We perform the sanity check i.e If the size of our portion of physical memory is smaller than what the user tries to map using the full length virtual address range of this memory region, then we raise an exception. i.e say for ex. vsize = 0x3000

Otherwise we use the API "remap_pfn_range" to map the portion of the physical memory passing in the the physical address and not the page frame number as was done previously since this is the IO memory. I feel it should have been the API "io_remap_page_range" here the aforementioned.

So it will map the portion of physical memory starting from the physical address 0xd000 9000 on the the user linear address starting from vma->vm_start of vsize.

N.B As before I have yet to test this out !

Answer 3

No, the statement in the book is correct, because As aforementioned, "physical" is just the address Of starting of your region/portion that you want To map out of the physical memory which starts From "off" physical address till the "simple_region_size" The "simple_region_size" value is decided by the user. Similarly "simple_region_start" is decided by the user.

simple_region_start >= off

So the maximum physical memory that user can map Is decided by: psize = simple_region_size - off I.e from start of physical memory till end of the portion.

But actually how much will be mapped with this memory region is given by "vma->vm_end - vma->vm_start" and is represented by vsize. Hence the need existed to perform the sanity check since User can get more than what it intended.

Kind regards,
Sanjeev Ranot