Protection

• Memory protection in a paged environment is accomplished by protection bits associated with each frame. Normay, these bits are kept in the page table. One bit can define a page to be read-write or read-only.
• Every reference to memory goes through the page table to find the correct frame number. At the same time that the physical address is being computed, the protection bits can be checked to verify that no writes are being made to a read-only page.
• An attempt to write to a read-only page causes a hardware trap to the operating system (or memory-protection violation).
• One additional bit is generally attached to each entry in the page table: a valid-invalid bit.
  • When this bit is set to ``valid'', the associated page is in the process's logical address space and is thus a legal (or valid) page.
  • When the bit is set to ``invalid'', the page is not in the process's logical address space.
• Illegal addresses are trapped by use of the valid-invalid bit. The OS sets this bit for each page to allow or disallow access to the page.
• Suppose, for example, that in a system with a 14-bit address space (0 to 16383), we have a program that should use only addresses 0 to 10468.
  • Given a page size of 2 KB (with 6 pages $2048*6=12288$).
  • item Addresses in pages 0, 1, 2, 3, 4, and 5 are mapped normally through the page table.
  • Any attempt to generate an address in pages 6 or 7, however, will find that the valid-invalid bit is set to invalid, and the computer will trap to the OS (invalid page reference).

  Figure 9: Valid (v) or invalid (i) bit in a page table.

  
• Notice that this scheme has created a problem. Because the program extends to only address 10468, any reference beyond that address is illegal.
• However, references to page 5 are classified as valid, so accesses to addresses up to 12287 are valid. Only the addresses from 12288 to 16383 are invalid.
• This problem is a result of the 2-KB page size and reflects the internal fragmentation of paging.