C 虚拟到物理地址映射

Question

I am beginner in C, I am trying to convert virtual addresses to physical.

My code so far, but don't know how to the translation.

I am using 4Kb pages.

The conversion I know is: for givin address: 0x12C000, the last three numbers won't be changed 000 and the remaining 12C will be converted, and then combine the fixed numbers with the converted. correct me if wrong, and how do I do taht in code?

#include <stdio.h>

int main() {

    uint page_table[512] = { 0 };
    page_table[200] = 0x1234;
    page_table[300] = 0x2345 ;
    page_table[511] = 0x8000 ;

    uint page_table_size = (sizeof(array)/sizeof(array[0]));
    uint page_size_bits 12 // // 2^12 = 4KB;
    uint mask_offset ((1<<page_size_bits)-1);

    // example of correct outputs:

    uint log_addr = 0x12C000;

    /* should be 0x2345000 */
    uint correctoutput; 

    log_addr = 0x12CFFF;

    /* should be 0x2345FFF */
    correctoutput; 

    log_addr = 0x1FF84A;

    /* should be 0x800084A */
    correctoutput; 

}

Answer 1

Unless you are running in a privileged mode of the CPU, which usually means you are in the kernel you can't. The OS + CPU team up to prevent you from accessing the page tables, and the only way you could do this is by accessing the page tables.

If you did have access to them, and you were a 32bit 386 program running without PAE, it would look something like this:

extern void *mapphys(unsigned pa);
extern unsigned getcr3(void);
unsigned vtop(unsigned va) {
       unsigned *pt, t;
       pt = mapphys(getcr3());
       t = pdir[va>>22];
       unmapphys(pt);
       if (t & 1) {
            pt = mapphys(t & ~ 0xfff);
            t  = pt[(va >> 12) & 0x3ff];
            unmapphys(pt);
            if (t & 1) {
                return (t &~ 0xfff) | (va & 0xfff);
            }
            error("page table entry undefined for %#x\n", va);
            return -1;
       } else {
            error("page directory entry undefined for %#x\n", va);
            return -2;
       }
}

where maphys, unmapphys provide and remove a usable pointer to the given physical address, and getcr3() returns the page table base register from the 386. That said, there are ways of constructing these sorts of page tables so that you can indirectly address them. For example, if you made the last (index 1023) entry in the page directory table point at the page directory table, then you can using the high 4M-4K of address space as a sort of page table map; and the final 4K of address space is a map of the page directory itself. With this setup, I can instead:

unsigned vtop(unsigned va) {
      unsigned *pmap = (unsigned *)0xff800000;
      unsigned *pdmap = (unsigned *)0xfffff000;
      if (pdmap[va>>22] & 1) {
          if (pmap[va>>12] & 1) {
               return (pmap[va>>12]&~0xfff) | (va & 0xfff);
          }
          error("page table entry undefined for %#x\n, va);
          return -1;
      }
      error("page dir entry undefined for %#x\n", va);
      return -2;
}

It is worth noting that in this recursive page table, which index you choose is not important, and the mechanism is generally applicable to any page table definition which is the interior and leaf nodes have compatible layouts.

Answer 2

You need to calculate two values: The index into the physical memory (page_table) and the offset to add to the page_table entries address.

page_table_index = log_address >> 12;
page_offset = log_address & 0xfff;
physical = (page_table[page_table_index] << 12) | page_offset;

The lower 12 bits are the offset. You keep that part of the address. You shift these 12 bits off and you are left with the page number in the page_table array. You can then look up the page_table to obtain the base address, make space for the 12 bits in that address and insert the offset.