Tablas de páginas y sus bits

1. Qué es una entrada de tabla (PTE)

La tabla de páginas es un array de entradas (PTE, page table entry). Cada entrada corresponde a una página virtual y contiene:

• El número de marco (f) donde está la página en la RAM (si está presente).
• Bits de control que indican el estado y los permisos de la página.

En x86-64, cada PTE ocupa 8 bytes (64 bits). Con páginas de 4 KiB y un espacio virtual de 256 TiB, la tabla plana tendría 2³⁶ entradas (64 GiB), por eso se usan tablas multinivel (tema 22).

2. Los bits principales

Los bits más importantes de una PTE en x86 (y similares en otras arquitecturas) son:

Estos bits son la base de la protección y de la memoria virtual. El hardware los consulta y modifica en cada acceso; el SO los lee y modifica al gestionar las páginas.

3. Otros bits: NX, global, PAT

4. Cómo se usa para proteger

La MMU comprueba los bits en cada acceso:

1. Presente: si es 0, se lanza un fallo de página (no hay acceso a la RAM).
2. R/W: si es 0 y el acceso es de escritura, se lanza una excepción de protección.
3. U/S: si es 0 y el proceso es de usuario, se lanza una excepción.
4. NX: si es 1 y el acceso es de ejecución, se lanza una excepción.

Esto permite, por ejemplo, que el código sea r-x (R/W=0, NX=0) y los datos rw- (R/W=1, NX=1). Un intento de escribir en el código o de ejecutar datos provoca SIGSEGV.

5. Cómo se usa para memoria virtual

El bit presente es la base de la paginación por demanda:

• Cuando un proceso se crea, sus páginas se marcan como no presentes (P=0). No se carga nada en la RAM.
• Al acceder a una página no presente, la MMU lanza un fallo de página.
• El sistema operativo carga la página en un marco libre, actualiza la PTE (P=1, marco=f) y reanuda la instrucción.
• Si no hay marcos libres, se reemplaza una página (tema 34).

Los bits accessed y dirty ayudan al sistema a decidir qué página reemplazar (LRU aproximado) y si hay que escribirla al disco.

6. Ejemplo numérico

Una PTE de 8 bytes en x86-64 con los siguientes bits:

La PTE completa (simplificada) sería: 0x1A3F200000000007 (marco en los bits altos, bits de control en los bajos).

7. Experimento en C

El programa siguiente simula una PTE y muestra cómo se interpretan los bits:

#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint64_t marco : 40;
    uint64_t reservado : 11;
    uint64_t nx : 1;
    uint64_t g : 1;
    uint64_t ps : 1;
    uint64_t d : 1;
    uint64_t a : 1;
    uint64_t pcd : 1;
    uint64_t pwt : 1;
    uint64_t us : 1;
    uint64_t rw : 1;
    uint64_t p : 1;
} PTE;

int main(void)
{
    PTE e = { .marco = 0x1A3F2, .p = 1, .rw = 1, .us = 1, .a = 1, .d = 0, .nx = 1 };
    printf("Presente: %d\\n", e.p);
    printf("R/W: %d (%s)\\n", e.rw, e.rw ? "rw" : "r");
    printf("U/S: %d (%s)\\n", e.us, e.us ? "user" : "supervisor");
    printf("Accessed: %d\\n", e.a);
    printf("Dirty: %d\\n", e.d);
    printf("NX: %d (%s)\\n", e.nx, e.nx ? "no-exec" : "exec");
    printf("Marco: 0x%lX\\n", (unsigned long)e.marco);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o pte pte.c
$ ./pte
Presente: 1
R/W: 1 (rw)
U/S: 1 (user)
Accessed: 1
Dirty: 0
NX: 1 (no-exec)
Marco: 0x1A3F2Marco: 0x1A3F2

8. Probar con un simulador

Este simulador muestra una PTE con sus bits y permite modificarlos para ver el efecto en la protección.

9. En Linux y x86 hoy

En Linux sobre x86-64, los bits de la PTE se gestionan por el núcleo. Las herramientas para inspeccionarlos:

• /proc/PID/pagemap: expone el marco y algunos bits (restringido).
• /proc/PID/smaps: muestra permisos y estado por región.
• pmap -X PID: muestra permisos por página.

El bit NX se controla con la política W^X y se configura en las tablas de páginas por el núcleo. El bit accessed lo usa el algoritmo de reemplazo (aproximación a LRU).

10. Resumen

• Una PTE contiene el marco físico y bits de control (presente, R/W, U/S, accessed, dirty, NX).
• El bit presente indica si la página está en la RAM; si es 0, se lanza un fallo de página.
• R/W controla si se puede escribir; U/S si es accesible desde el espacio de usuario.
• Accessed y dirty los gestiona el hardware y los usa el SO para reemplazo.
• NX impide la ejecución (W^X).

11. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Configura una PTE con P=1, R/W=0, U/S=1, NX=0. ¿Qué accesos son válidos?
2. Configura una PTE con P=0. ¿Qué ocurre al acceder?
3. Explica cómo el bit accessed ayuda al algoritmo de reemplazo LRU.
4. Explica cómo el bit dirty evita escrituras innecesarias al disco.
5. Investiga cómo Linux usa el bit NX para la política W^X.
6. Compara los bits de la PTE en x86 con los de otra arquitectura (ARM).
7. Dibuja una PTE con todos sus bits y explica cada uno.