Virtual Addresses

A 32-bit virtual address can be divided into a 20-bit page number and a 12-bit page offset (or just offset), like this:

               31               12 11        0
              +-------------------+-----------+
              |    Page Number    |   Offset  |
              +-------------------+-----------+
                       Virtual Address

Macros and Functions

Work with Virtual Addresses

Header threads/vaddr.h defines these functions and macros for working with virtual addresses:

  • Macro: PGSHIFT
  • Macro: PGBITS
    • The bit index (0) and number of bits (12) of the offset part of a virtual address, respectively.
  • Macro: PGMASK
    • A bit mask with the bits in the page offset set to 1, the rest set to 0 (0xfff).
  • Macro: PGSIZE
    • The page size in bytes (4,096).
  • Function: unsigned pg_ofs (const void *va)
    • Extracts and returns the page offset in virtual address va.
  • Function: uintptr_t pg_no (const void *va)
    • Extracts and returns the page number in virtual address va.
  • Function: void *pg_round_down (const void *va)
    • Returns the start of the virtual page that va points within, that is, va with the page offset set to 0.
  • Function: void *pg_round_up (const void *va)
    • Returns va rounded up to the nearest page boundary.

Work with User/Kernel Virtual Memory Boundary

Virtual memory in Pintos is divided into two regions: user virtual memory and kernel virtual memory. The boundary between them is PHYS_BASE:

  • Macro: PHYS_BASE
    • Base address of kernel virtual memory.
    • It defaults to 0xc0000000 (3 GB), but it may be changed to any multiple of 0x10000000 from 0x80000000 to 0xf0000000.
    • User virtual memory ranges from virtual address 0 up to PHYS_BASE. Kernel virtual memory occupies the rest of the virtual address space, from PHYS_BASE up to 4 GB.
  • Function: bool is_user_vaddr (const void *va)
  • Function: bool is_kernel_vaddr (const void *va)
    • Returns true if va is a user or kernel virtual address, respectively, false otherwise.

Work with Mapping Kernel VM One-to-One to PM

The 80x86 doesn’t provide any way to directly access memory given a physical address. This ability is often necessary in an operating system kernel, so Pintos works around it by mapping kernel virtual memory one-to-one to physical memory.

  • That is, virtual address PHYS_BASE accesses physical address 0, virtual address PHYS_BASE + 0x1234 accesses physical address 0x1234, and so on up to the size of the machine’s physical memory.
  • Thus, adding** PHYS_BASE to a physical address obtains a kernel virtual address that accesses that address; conversely, subtracting PHYS_BASE **from a kernel virtual address obtains the corresponding physical address.

Header threads/vaddr.h provides a pair of functions to do these translations:

  • Function: void *ptov (uintptr_t pa)
    • Returns the kernel virtual address corresponding to physical address pa, which should be between 0 and the number of bytes of physical memory.
  • Function: uintptr_t vtop (void *va)
    • Returns the physical address corresponding to va, which must be a kernel virtual address.