# Orga-2 | 2da parte de la materia
### Otros apuntes
[Facundo Lerena](https://faculerena.com.ar/courses/orga2/cheatsheet-parcial-2)
## Indice
- [TOC]
#### Disclaimer: este apunte es bastante pedorro y mediocre, es una recopilación de información importante de las diapositivas.
## Introducción a Registros de Segmento
- Estos registros son utilizados para la segmentación de la memoria, que es una técnica para dividir la memoria en segmentos de diferentes tamaños y acceder a ellos a través de estos registros. Cada registro se utiliza para diferentes propósitos.
- En la arquitectura IA-32, los registros de segmento son cruciales para la segmentación de memoria. Cada registro segmento tiene un propósito específico en el manejo de memoria:
- **CS (Code Segment)**: Almacena las instrucciones que el CPU ejecuta.
- **DS (Data Segment)**: Maneja el área donde se almacenan los datos del programa.
- **ES (Extra Segment)**: Se utiliza en operaciones de transferencia de datos.
- **SS (Stack Segment)**: Gestiona el área de la pila, usada en llamadas a funciones y manejo de variables locales.
- **FS, GS**: Registros adicionales para usos específicos en aplicaciones o sistemas operativos.
## Definición GDT
- La GDT (Global Descriptor Table) es una estructura de datos utilizada por los procesadores x86 para definir las propiedades de los diferentes segmentos de memoria utilizados en un sistema.
- Cada entrada en la GDT es un descriptor que especifica la base, el límite y los atributos (como los niveles de privilegio y el tipo de segmento) de un segmento de memoria.
- Esto permite al sistema operativo controlar y proteger el acceso a la memoria, facilitando la gestión de tareas y la ejecución de programas con distintos niveles de privilegio
| Segmento | Descripción |
|-------------|----------------------------------------------------------------------------------------|
| **CS** | Segmento que contiene las instrucciones ejecutables del programa. |
| **DS** | Segmento que contiene datos que pueden ser leídos y escritos por el programa. |
| **ES** | Segmento utilizado en operaciones de transferencia de datos. |
| **SS** | Segmento que contiene la pila del programa, utilizada para almacenar datos temporales y direcciones de retorno. |
| **FS, GS** | Registros adicionales para usos específicos en aplicaciones o sistemas operativos. |
## Inicialización del Computador IA-32
- Al encenderse, el procesador realiza un auto-test llamado POST y configura los registros para estados iniciales conocidos. El registro IP se configura a 0xFFF0, direccionando el inicio de la ejecución en memoria alta (frecuentemente, la dirección física 0xFFFFFFF0).
## Manejo de la Línea A20
- La línea A20 es una reliquia de la arquitectura 8086 que **limitaba la memoria a 1MB**. En sistemas modernos, es necesario activar esta línea para acceder a memoria superior a 1MB.
## Selección del Modo de Operación del Procesador
El procesador puede operar en varios modos:
1. Modo Real: Simula un procesador 8086, limitado a 1MB de memoria.
2. Modo Protegido Flat: No utiliza la segmentación tradicional, simplificando el modelo de memoria.
3. Modo Protegido Segmentado: Utiliza la segmentación **para separar y proteger diferentes áreas de la memoria**.
```assembler
cli
mov eax, cr0
or eax, 1
mov cr0, eax
sti
```
- Este código activa el modo protegido flat deshabilitando interrupciones, ajustando el bit PE del registro CR0 y luego reactivando las interrupciones.
### Memoria disponible en modo real y protegido
| memoria disponible | Modo real | Modo protegido |
| -------- | -------- | -------- |
| Memoria de atención | ~1MB | 4 GB (32 bits) |
| Privilegios | :( | 4 niveles de protección |
| Interrupciones | Rutinas de atención | Rutina de atención con privilegios |
| Set de instrucciones | Todas | Depende del nivel de privilegio |
## Inicialización de la Memoria DRAM
- Importancia: La inicialización de la memoria DRAM es crucial para el rendimiento del sistema ya que la DRAM es más rápida que la memoria ROM o Flash desde donde se ejecuta el sistema inicialmente.
- Procedimiento: Incluye **configurar el controlador de memoria, actualizar el microcódigo si es necesario y configurar los parámetros de temporización de la DRAM**.
```assembler
mov eax, 0
mov ecx, 0
rdmsr
wrmsr
```
# Gestión de Memoria en Procesadores IA-32 e Intel® 64
## Administración de Memoria
### Enfoque Preliminar
Los procesadores modernos gestionan diferentes tipos de direcciones de memoria:
- **Dirección Lógica**: Usada dentro del código fuente, proporciona una abstracción para facilitar la programación.
- **Dirección Física**: Dirección real en la memoria RAM o ROM, que es manejada directamente por el hardware.
- **Dirección Virtual**: Utilizada en sistemas avanzados, puede diferir de la dirección lógica y es gestionada por la MMU (Memory Management Unit).
```assembly
mov al, 00
mov ecx, 1024
mov esi, buffer
rep stosb
```
- Este fragmento de código demuestra cómo se manejan los buffers en el ensamblador, iniciando un buffer de 1024 bytes en cero.
## Modelos de Organización de Memoria
- Modo Protegido: Permite el acceso a una mayor cantidad de memoria y proporciona características de protección y segmentación avanzadas.
- Modo IA-32e: Específico para arquitecturas de 64 bits, utiliza direcciones lineales extendidas y mejora la seguridad y la capacidad de gestión de memoria.
## Direcciones Lógicas y Lineales
- Las direcciones lógicas proporcionan una forma abstracta de referirse a la memoria, mientras que las direcciones lineales son traducciones de estas que utiliza la CPU para acceder físicamente a la memoria.
## Unidad de Segmentación
### Selectores de Segmento
- Son identificadores utilizados por la CPU para seleccionar un segmento de memoria específico para operaciones de lectura o escritura.
### Descriptores de Segmento de 32 bits
- Estructuras de datos que proporcionan la base, el tamaño y los derechos de acceso de los segmentos de memoria.
# Dirección Lineal y su Generación
- La dirección lineal se genera a partir de la combinación de un selector de segmento y un desplazamiento dentro de ese segmento, lo que permite a la CPU localizar y acceder a la memoria específica.
# Modelos de Segmentación de Memoria
- Segmentación en Modo IA-32e: Utiliza segmentación para dividir la memoria en segmentos que pueden ser manejados más eficientemente por el sistema operativo.
- Implementación Práctica de Segmentación en un SO: Ejemplos de cómo los sistemas operativos modernos utilizan la segmentación para mejorar la seguridad y la eficiencia.
- **Granularidad**: Refiere al **tamaño de los segmentos utilizados en la segmentación de memoria**. La granularidad puede ser gruesa, con segmentos grandes que reducen el overhead pero pueden incrementar la fragmentación interna; o fina, con segmentos más pequeños que minimizan la fragmentación interna a costa de un mayor overhead de manejo.
# Pasaje a modo protegido
- El pasaje a modo protegido implica varios pasos críticos que preparan al sistema para operar con mayor capacidad y seguridad:
- Bootloader: El sistema inicia desde un dispositivo booteable copiando el sector de arranque en la memoria principal.
- Armado de la GDT (Global Descriptor Table): Esencial para definir los límites y accesos de los segmentos de memoria.
- Cambios en el Procesador:
- Deshabilitar interrupciones.
- Cargar el registro GDTR con la dirección base de la GDT.
- Activar el bit PE (Protection Enable) del registro CR0 para entrar en modo protegido.
- Realizar un salto lejano (FAR JUMP) para actualizar el registro de segmento del código y efectuar el cambio de modo.
```assembler
lgdt [gdtr]
mov eax, cr0
or eax, 1
mov cr0, eax
jmp codeSegment:nextInstruction
```
- Configuración de Segmentos: Una vez en modo protegido, es crucial cargar todos los registros de segmento (CS, DS, ES, FS, GS, SS) para asegurar el correcto acceso a la memoria bajo el nuevo esquema de protección.
## IDT
- La Interrupt Descriptor Table (IDT) es esencial para la gestión de interrupciones en un entorno protegido. Contiene descriptores que definen cómo se manejan las interrupciones, excepciones y llamadas al sistema.
```assembly
lidt [idtr]
```
- IDTR (IDT Register): Este registro contiene la dirección base y el límite de la IDT.
## Descriptores IDT
- En la IDT se definen varios tipos de descriptores:
- Interrupt Gate: Utilizado para manejar interrupciones. Desactiva las interrupciones al entrar y las reactiva al salir.
- Trap Gate: Similar al interrupt gate, pero no desactiva las interrupciones.
- Task Gate: Utilizado menos frecuentemente, principalmente para cambiar de tarea en respuesta a una interrupción.
```assembly
; Ejemplo de configuración de un Interrupt Gate
mov dword [idt + 8 * n], low_offset ; Offset bits 0-15
mov dword [idt + 8 * n + 2], selector
mov byte [idt + 8 * n + 4], 0 ; Reservado
mov byte [idt + 8 * n + 5], type_attr ; Tipo y atributos
mov dword [idt + 8 * n + 6], high_offset ; Offset bits 16-31
```
- Selector: Selector de segmento de código que contiene el manejador de la interrupción.
- Offset: Dirección del manejador de la interrupción.
- Type_attr: Tipo de gate (Interrupt, Trap) y atributos como DPL (Descriptor Privilege Level).
## Tipos de interrupciones y excepciones
- Las interrupciones y excepciones se clasifican en:
- Externas: Generadas externamente (por ejemplo, hardware).
- Internas: Generadas por condiciones como divisiones por cero.
- Software: Generadas por instrucciones específicas como int.
### Excepciones comunes
- #DE (Divide Error): Ocurre cuando una división por cero es intentada.
- #GP (General Protection): Se genera por accesos no permitidos a la memoria o por violaciones de seguridad.
- #PF (Page Fault): Ocurre cuando un programa accede a un área de memoria que no está mapeada en la memoria física.
## Cambio de privilegio de ejecución
- La ejecución de una interrupción puede requerir un cambio en el nivel de privilegio:
```assembly
pushad
mov ax, kernel_ds
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
```
## PIC (Programmable Interrupt Controller)
- El PIC, especialmente el modelo 8259 en sistemas más antiguos, es responsable de manejar hasta 8 interrupciones. Su función principal es priorizar las interrupciones y enviarlas al procesador de manera ordenada y controlada. Cuando sistemas más modernos requieren más de 8 interrupciones, se pueden encadenar dos controladores PIC.
## APIC (Advanced Programmable Interrupt Controller)
- El APIC es una evolución del PIC y se utiliza en sistemas multiprocesador y en procesadores más recientes de Intel. Ofrece mejor escalabilidad y manejo de interrupciones mediante una arquitectura más compleja que permite configuraciones más flexibles y un mayor número de interrupciones. El APIC local maneja las interrupciones específicas de cada CPU, mientras que el APIC de E/S maneja las interrupciones de nivel de sistema.
## Manejo del Stack Durante las Interrupciones
- Cuando ocurre una interrupción, el procesador realiza automáticamente varias operaciones en la pila (stack) del thread actual:
1. **Guarda el EFLAGS**: Se almacenan los flags del procesador para restaurar el estado anterior después de la interrupción.
2. **Guarda el CS y el EIP**: Estos registros, que apuntan al segmento de código y a la instrucción actual, respectivamente, se guardan para poder reanudar la ejecución después de la interrupción.
3. **Cambio de Stack si es necesario**: Si la interrupción involucra un cambio de nivel de privilegio (de un nivel más alto a uno más bajo, como de usuario a kernel), el procesador cambia al stack del nuevo nivel antes de guardar el EIP y el CS.
- Estos pasos aseguran que el sistema pueda manejar interrupciones de manera eficiente sin perder el contexto del programa que estaba ejecutando antes de la interrupción, y permiten un retorno seguro y correcto a la ejecución del programa una vez que la interrupción ha sido gestionada.
## Paginación
- La paginación es una forma de mapear el espacio lineal de dirección en pequeñas partes a la memoria virtual y disco secundario. Cuando se usa paginación el procesador divide el espacio lineal en fragmentos (4kb,2Mb o 4MB) que pueden ser mapeados a la memoria física o disco.
- El programa usa direcciones lógicas, que luego el procesador traduce a direcciones fisicas. Al ir obteniendo la dirección física, se puede saber si la página o tabla esta en memoria física, gracias a los datos que hay en el directorio o tabla de páginas que indican si está o no en memoria.
- En sistemas x86, se utilizan tablas de páginas para esta traducción, con diferentes niveles de tablas que ofrecen control granular (tamaño de los bloques de memoria que la mmu puede gestionar 4KB) sobre la memoria.
```plaintext=
+-------------+ +-------------------+ +-------------------+ +-----------+
| CR3 | ---> | Directorio de | ---> | Tabla de Páginas | ---> | Memoria |
| (Base del | | Páginas | | | | Física |
| directorio | | (Array de | | (Array de | | (Marcos de |
| de páginas)| | entradas, cada | | entradas, cada | | página) |
| | | una apunta a una | | una apunta a un | | |
| | | tabla de páginas) | | marco de página) | | |
+-------------+ +-------------------+ +-------------------+ +-----------+
| | | |
|______________________|___________________________|_______________________|
| | |
V V V
Mapea a la dirección La entrada de la Datos reales en
física del directorio de tabla de páginas la memoria física
páginas, que es la base proporciona la donde se almacenan
para todo el sistema de dirección física del los datos
tablas marco de página donde
residen los datos
```
### Conceptos básicos de paginación
- **Tabla de paginas**: Estructura que almacena las direcciones fisicas de memoria
- **Entrada de tabla de página (PTE)**: Contiene la dirección física y los flags de estado de la página.
- **Extensión de direccióon fisica (PAE)**: Permite direcciones físicas más extensas en sistemas de 32 bits, extendiendo el espacio de direcciones a 36 bits.
### Tipos de paginación
- Paginación 4KB: tamaño estandar de páginas.
- Paginación de gran tamaño: Permite páginas de mayor tamaño como 2mb o 4mb, reduciendo la sobrecarga de la gestión de múltiples páginas pequeñas.
### Definición CR3
- El registro CR3, también conocido como el registro de directorio de páginas, es un registro en los procesadores x86 **que contiene la dirección física de la tabla de directorio de páginas**. Este registro es esencial para la traducción de direcciones en sistemas que utilizan paginación, ya que permite al procesador localizar la tabla de páginas que mapea direcciones virtuales a direcciones físicas.
- Al cambiar el contenido de CR3, el sistema operativo puede cambiar rápidamente el mapa completo de direcciones virtuales a físicas, facilitando así el cambio de contexto entre diferentes procesos o tareas.
- 
#### Excepciones de paginación
- #PF: se genera cuando la CPU accede a una página que no está cargada en la memoria fisica.
#### Implementación en modo protegido: La utiliza la paginación para proteger y aislar los espacios de memoria de los procesos, mejorando la seguridad y estabilidad del S.O.
### Que espacio ocupa cada cosa
| Componente | Descripción | Espacio Ocupado |
|---------------------------|----------------------------------------------------------------|-------------------|
| Direcciones Virtuales | Total de direcciones virtuales en un sistema de 32 bits. | $2^{32}$ direcciones |
| Páginas | Número de páginas, asumiendo 4KB por página. | $2^{20}$ páginas |
| Entrada por Página | Información guardada por cada página. | 20 bits (2.5 bytes)|
| Tamaño de la Tabla | Espacio total ocupado por la tabla de páginas. | 5 MB |
| Direcciones Físicas (byte)| Cuando se guarda una dirección física por cada dirección virtual| 16 GB |
## Traducción de dirección lógica a lineal
- En el modo protegido, el procesador usa dos etapas para traducir de una dirección lógica a física:
- 1ra etapa: Logical-Address-Translation
- 2da etapa: Linear-Address-Translation
- el CPU mapea la dirección fisica por medio de las direcciones lógicas.
- Estas consisten en un selector de segmento de 16 bits y un offset de 32 bits.
- Para traducir una dirección lógica a una lineal el procesador hace lo siguiente:
- Usa el offset en el selector de segmento para ubicar el descriptor de segmente en la GDT o LDT (este paso solo se requiere cuando elo procesador carga un nuevo selector de segmento en el registro de segmento).
- Examina el descriptor de segmento para chequear los privilegios de acceso y que el offset esté dentro de los limites del descriptor de segmento, usa la base para sumar con el offset de 32 bits y la forma de dirección lineal.
- Definición de descriptor de segmento:
- Un descriptor de segmento es una estructura de datos utilizada en la segmentación de memoria en arquitecturas de microprocesadores.
- Proporciona información esencial sobre un segmento de memoria, incluyendo la base, el limite y los atributos del segmento.
- Estos atributos definen los derechos de acceso, el tipo de segmento (datos so código), y otras propiedades como su tamaño, y si está presente en la memoria física.
- Los descriptores de segmento están organizados en tablas como GDT y LDT.
- Traducción de dirección lineal a fisica
- Cuando se obtiene una dirección lineal y se utiliza para paginas de 4KB la dirección se separa en tres partes.
- bits 22 a 31 proveen un offset para una entrada en el directorio de páginas.
- bits del 12 al 21 proveen un offset para una entrada en la tabla de página que contiene la base de la página.
- bits del 0 al 11 es un offset que junto con la base de la página se suman para obtener una dirección fisica del dato. Cuando se utiliza páginas de 4MB, la dirección lineal se separa en dos partes:
- Una para el directorio
- Y otra para el offset. El funcionamiento es similar a página de 4KB, solo que tiene un nivel menos.
- 
- Mappear paginas:
- Base del page directory = cr3
- Page directory index = virtual $>> 22$
- Base de page table = directorio[indice].address $<< 12$
- Page table index = (virtual $<< 10$) $>> 22$
- Tablas[indice].address = fisica $>> 12$
- 
- 
- 
- Cada tarea tiene su propio espacio lineal de dirección
- Para lograr esto, gracias al TSS (Task State Segment) se guarda el PDBR (Page Directory Register o CR3), y permite que cada tarea tenga su propio directorio de paginas, ya que al cargar o cambiar de tarea se cambia el valor del CR3 (que apunta al directorio de paginas)
## Scheduler | Tareas
Las computadoras ejecutan varios programas en simultaneo a la vista de los usuarios y parece que se están haciendo al mismo tiempo, pero no. Se hacen una por una pero al sentido humano no lo podemos percibir y por eso da esa falsa sensación de que están pasando varias cosas a la vez.
- Las tareas definen esto
- Y el S.O implementa software que se encarga de decidir que tarea ejecutar en cada tic del reloj: `Scheduler`
#### Definición de tarea
- Una tarea es una unidad de trabajo que el procesador puede:
- Despachar
- Ejecutar
- Suspender
- Puede ser ejecutada para un programa
- dos o más tareas distintas pueden tener un mismo código de programa, sin embargo sus contextos de ejecución y datos asociados pueden ser distintos.
- Podemos pensarlo como instancias del mismo programa.
- En la memoria de una tarea tenemos:
- Espacio de ejecución: Paginas mapeadas donde va a tener el código, datos y pilas.
- Le definimos un page directory con su page table correspondiente o reutilizar algún directorio entre varias tareas.
- **TSS**: Una región de memoria que almacena el estado de una tarea, a la espera de iniciarse o al momento de ser desalojada del procesador, y con un formato especifico para que podamos iniciarla/reanudarla.
- La información que se va a guardar en esta región sería:
- Registros de proposito general
- Registros de segmento de la tarea y segmento de la pila de nivel 0
- Flags
- CR3
- EIP
- 
#### Definición de scheduler: Modulo de software que administra la ejecución de tareas / procesos. Utiliza una politica o criterio para decir cual es la proxima tarea a ejecutar.

- Cuando pasamos de una tarea a otra, hay un cambio de contexto
- Esto significa que tiene que guardar en algún lado el contexto actual para no perderlo
### TSS
- 
- El registro Task Register almacena el selector de segmento de la tarea en ejecución
- Se usa para encontrar la TSS de la tarea actual.
- 
#### Inicializar TSS de una tarea:
- Completar la información inicial que permite la ejecución de la tarea
- Los valores que va a tener son aquellos que se van a cargar en los registros de CPU y que usará en la ejecución.
- EIP
- ESP, EBP, ESP0 (puntero al tope de la pila de nivel 0)
- Los selectores de segmento CS,DS,ES,FS,GS,SS,SS0 (stack segment de la pila de nivel 0)
- CR3, que va a tener la paginación asociada a la tarea.
- Cada tarea tendrá su propio page directory
- EFLAGS, en 0x00000202 para tener las interrupciones habilitadas
- 
- El bit busy indica si la tarea está siendo ejecutada
- Lo iniciamos en cero
- El bit DPL es el de privilegio que se precisa para acceder al segmento.
- Usamos nivel 0 porque solo el kernel puede intercambiar tareas.
- el LIMIT es el tamaño maximo de la TSS
- El BASE indica la dirección base de la TSS
### Tareas inicial e idle
- El procesador siempre precisa estar corriendo una tarea aunque esta no haga nada.
- Al arrancar la tarea que tarea se ejecuta
- Y si no hubiera tarea para ejecutar en algún momento, que tarea se ejecuta?
- Definimos la tarea inicial e idle para estas situaciones
- Cuando apenas inicia el kernel cargamos la tarea inicial
```
; cargar registro TR
mov ax, GDT_IDX_TASK_INITIAL
shl ax, 3 ; shifteo a la izquierda para convertir el índice de la GDT en un selector de segmento
ltr ax ; carga el registro TR con el selector de la TSS
call tasks_screen_draw ; dibuja las tareas en pantalla
; Cargo tarea inicial
mov ax, TASK_IDLE_SEL
ltr ax
; Ahora quiero hacer el jump far a la tarea idle
jmp dword TASK_IDLE_SEL:0
```
### Volviendo al scheduler

- Para cada vez que se pasa de una tarea a otra, ocurre un cambio de contexto
- Utiliza un criterio para decir cual es la pr oxima tarea a ejecutar y lo hace en cada tic del reloj.

- Acá revisar directamente las diapos, pagina 21 de las animadas
### Jump far vs Jump near
| Tipo de Salto | Descripción | Alcance | Segmento de Código | Uso | Tamaño de Instrucción |
|---------------|----------------------------------------------------------------------|---------------------------|----------------------|------------------------------------------------------------------------------------------|-----------------------------------|
| Jump Near | Cambia solo el contador de programa (IP o EIP) dentro del mismo segmento. | Dentro del mismo segmento | No modifica `CS` | Usado para saltos dentro de una misma función o bloques de código cercanos. | Más cortas y rápidas de ejecutar |
| Jump Far | Cambia el contador de programa y el registro de segmento de código (`CS`). | Entre diferentes segmentos| Cambia el registro `CS` | Usado para saltos entre diferentes segmentos de memoria, como en cambios de contexto. | Más largas y pueden ser más lentas|
- asdasd