SO II

***********************************************
12/4
************************************************

man 2 'function'

Sistema de archivos

Archivo: Unidad de almacenamiento de datos en el disco (o cualquier medio de almacenamiento persistente). Usualmente se le asocia un nombre a cada archivo y los datos se recuperan a través de ese nombre.El sistema de archivos se encarga de representar los archivos en el almacenamiento persistente

Usualmente se usa una ordenación jerárquica (estructura de directorios). Esto da lugar a que un nombre de un archivo involucre rutas (PATH). Cambien pueden aparecer distintos volúmenes dentro de un sistema de archivos virtual.
    En DOS, los volúmenes corresponden con unidades o particiones (aunque se pueden crear volúmenes virtuales).
    En Unix, los distintos volúmenes aparecen dentro (debajo) de un directorio dentro de una única jerarquía de directorios.

Operaciones con archivos:
    Abrir y/o crear:
        int open (char *path, int flags, int mode);
            Devuelve un file descriptor, o sea, un numero que le permitirá al proceso referenciar el archivo en sucesivas operaciones.
        int creat (char *file, int mode);

    Leyendo y escribiendo datos:
        int read (int fd, void *buffer, size_t  count);
        int write (int fd, void *buffer, size_t  count);
            Ambos retornan el nro de bytes leidos/escritos. En caso de error, (-1)

    Cerrando el archivo:
        int close(int fd);
            Se usa al terminar de trabajar con un archivo para asi liberar recursos. Es importante verificar que close termino de forma correcta.

    Borrando un archivo:
        int unlink (char *path);
            En realidad, borra el enlace al que referencia ese path. Si no hay otras referencias al archivo, entonces si se borran todos los datos.

    Otras operaciones:
        Crear links, obtener información sobre el archivo (y cambiarla), crear y administrar directorios

Posicionándose en el archivo:
    Cuando se hace una lectura, la siguiente lectura continua en donde termino la lectura anterior. Lo mismo ocurre con la escritura. Es decir, el sistema debe saber por
        cada fd cual fue el lugar de la ultima operación (no se hace distinción si fue lectura o escritura)
    Se puede cambiar la posición desde donde comenzara la próxima operación la seek position
        off_t lseek (int fd, off_t offset, int whence)
            donde whence indica que se toma como referencia para el offset.

Información necesaria:
    Por cada proceso, se necesita mantener información sobre cada archivo abierto por ese proceso (file descriptor).
    Información general para cada archivo
        Nro de procesos que lo tienen abierto.
        Ubicación en el disco.
        Control de acceso simultaneo y bloqueos.


¿Como manejar el acceso concurrente a un archivo?
    Puedo usar shared locks o exclusive locks. En el problema de lectores/escritores, los lectores tienen un shared lock y los escritores poseen un exclusive lock.
    El sistema de bloqueos puede ser obligatorio ( mandatory locking - se setea automáticamente o forzosamente), puede que sea programado por el usuario (advisory locking) o pueden ser combinados. Algunos sistemas pueden bloquear la parte de un archivo.
    DOS usa mandatory lockings con exlusive locks, en cambio, UNIX usa advisory locking y por defecto no bloquea el archivo

***********************************************
************************************************

PAGINACION

¿Que puede pasar al tratar de acceder a una pagina?
	1) La PTE correspondiente esta en la TLB. Accedemos a la memoria sin sobrecosto.
	2) La PTE no esta en la TLB. Hay un fallo de pagina
		- Buscamos en la tabla la entrada correspondiente
		- Cambiamos una entrada de la TLB por esta
		- Volvemos a ejecutar la instruccion
	3) La PTE dice que es invalida
		- El SO verifica que el proceso puede acceder a esa pagina (NO MATA AL PROCESO)
		- Elegimos una pagina a reemplazar -> Algoritmos de reemplazo
		- Si esta modificada, copiarla a disco
		- Cargar la nueva pagina a memoria
		- Cambiar las PTE de las paginas en cuestion. Invalidar las entradas de ellas en la TLB
		- Continuar la ejecucion
---------------------------------------------
Cuando toda la memoria esta usada y se necesita una pagina podemos elegir una pagina victima para enviarla a swap.

Recordemos que una page fault puede deberse a
    - Intento de acceso a una dir virtual no asignada (SIGSEGV al proceso)
    - Crecimiento del stack

Políticas de reemplazo

FIFO: Elijo la pagina que esta hace mas tiempo en memoria. Supongamos que la secuencia de accesos a paginas virtuales de proceso (la llamaremos traza) es la siguiente: (Ver ejemplo libro pag. 171)
- Ventajas: fácil de implementar
- Desventaja: Anomalía de Belady (quitamos de memoria una página de memoria muy usada, sólo porque es la más antigua)

Algoritmo optimo: Sacar la pagina mas lejana en el tiempo. Problema: No puedo ver a futuro las pag. necesitadas :(

Una forma de aproximarse al algoritmo optimo es mirar la historia del proceso y seleccionar la pagina que hace mas tiempo que no se usa, es decir, la usada menos recientemente. Este algoritmo se llama LRU (Least recently used) e intenta proveer un comportamiento casi óptimo mediante la observación de las páginas que menos fueron usadas recientemente. Este tipo de páginas, estadísticamente son las que tienen menor probabilidad de ser usadas nuevamente.
- Desventajas: Es costoso de implementar

Otra opción de implementación es guardar los accesos en una lista (doble enlazada) ordenada por hora de acceso. Este algoritmo parece mejor pero puede involucrar cambiar hasta todos los punteros.

Muchos SO utilizan algún algoritimo aproximado a LRU pero con una implementación para barata

***********************************************
31/5
***********************************************

Memoria compartida (libro)
Asignación de marcos

Cada proceso para poder realizar trabajo útil posiblemente necesite de:
    - la pagina correspondiente a la instrucción en el .text
    - al menos una pagina del .data
    - al menos una pagina del stack

Esto nos da la idea de que es conveniente tener al menos 3 paginas en RAM de cada proceso. Conviene asegurarnos que un proceso tenga un conjunto mínimo de paginas en memoria. Lo optimo seria que este su working set (cantidad de memoria que un proceso requiere en un intervalo de tiempo dado)

¿Cuantas paginas asigno a cada proceso? (Pag 177)

    -Asignación igualitaria: determina el tamaño de un proceso en memoria en función de una constante (o de un numero de procesos y el tamaño de la RAM). Esto penaliza demasiado a los procesos grandes
    -Asignación proporcional: asignar la memoria en proporción a la memoria virtual de un proceso. El problema de esto es que cuando aparece un proceso nuevo debemos recalcular todos los procesos y también tener en cuenta la memoria dinámica
    -Asignación proporcional con prioridades: asigno la memoria teniendo en cuenta la prioridad de cada proceso

***********************************************
07/6
***********************************************
Virtualizacion:
	-> Emulacion
	-> Hipervisores (tipo I)
	-> Paravirtualizacion
	-> Dockers (contenedores)

Emulacion (Mirar apunte Virtualizacion)

Si queremos emular una maq virtual de la misma arquitectura que el anfitrion no nos hace falta traducir todas las instrucciones
¿Que traducimos? Las intrucciones relacionadas con el hardware requeriran una traduccion pero ¿como hacemos para simular solo esas instrucciones?

La mejor seria que cuando se ejecute una instruccion que requiera privilegios, el programa (huesped) se interrumpa dando lugar a que el anfitrion
la simule. ¿Como podemos lograr esto?

	1)	Analizar el assambler antes de ejectuarlo y buscar instrucciones privilegiadas  para cambiarlas por "saltos" al anfitrion y asi poder emularlas pero acerlo con el binario
completo es muy costoso por lo tanto se suele tomar porciones de codigo (hasta encontrar un salto o una instruccion privilegiada) para ejecutar ese codigo llamando luego al
anfitrion para que haga los arreglos necesarios. Asi, las instrucciones comunes se ejecutan en el hardware real y el analisis del codigo solo se hace una sola vez
		A ese tipo de emulacion se lo llama EMULADOR (o Hipervisor de tipo II)


	2) Con apoyo del hardware ( hipervisores de tipo I). Como el hardware detecta automaticamente las instrucciones sensibles (privilegiadas) no es necesario realizar el analisis
del codigo ya que el hardware llamara al anfitrion (hipervisor) cuando encuentre una instruccion de este tipo. Para poder ejecutar muchas copias de un SO sencillo (CMS) se crea
un pequeño programa de control (cp) que coordenaba el trabajo de estos (CP/CMS)

En los x86 (hasta el 2005) algunas instrucciones sensibles cuando se ejecutaban en modo usuario no producian ningun efecto (ni siquiera un fallo). En el 2005, Instel corrige esto
para que las instrucciones privilegiadas produzcan fallos aun cuando se ejecuten en modo usuario. Tambien se agregan drivers para dispositivos simulados que pueden funcionar
mejor que el hardware real

Uno podria pensar que el tipo II de virtualizacion es mas lenta que la virtualizacion hecha por hipervisores, dado que hay que crear los bloques en tiempo de ejecucion y
emularlas instrucciones en modo usuario. Sin embargo, este esquema de virtualizacion a veceses mas rapido debido al cacheo de instrucciones y a que no se salta a modo kernel
tan seguido.

Paravirtualizacion

¿Como evitar toda la sobrecarga generada por la emulacion de dispositivos? Puedo modificar el SO huesped para que la I/O sea mas sencilla, o sea, hacer que el hipervisor presente
una API al hardware mucho mas facil de simular. Un hipervisor de paravirtualizacion es practicamente un microkernel que ejecuta S.O. huespedes como procesos.

Contenedores (Dockers): la idea es fabricar espacios independientes dentro del mismo SO (util para distrubicion de recursos / seguridad).
Permite separar -tablas de procesos, -señales e IPC, -tarjetas de red, -multiplexacion de dispositivos

Un contenedor Docker, a diferencia de una máquina virtual, no requiere incluir un sistema operativo independiente. En su lugar, se basa en las funcionalidades del kernel y
utiliza el aislamiento de recursos (CPU, la memoria, el bloque E / S, red, etc.) y namespaces separados para aislar de vista la aplicación del sistema operativo.
--------------------------------------
Virtualizacion de memoria

¿Como simular las tablas de paginacion?
El problema que se plantea en virtualizacion de memoria es como mapear las paginas fısicas que el S.O. huesped cree que existen con paginas reales, o sea que debe haber un
segundo nivel de traduccion: pagina virtual huesped -> pagina fisica huesped -> pagina fisica anfitrion.

El hipervisor lleva una shadow page table con la traduccion de las paginas que le dio al S.O. huesped. Esto es facil de hacer mediante las caracteristicas que proveen las
tecnologıas de virtualizacion de Intel (EPT) y AMD (NPT+RVI). Ambas tecnologias reespectivamente se encargar de solucionar el problema que surge con la TLB ya que si bien una
forma seria flushear la TLB cada vez que se pase a otra VM, esto reduciria el rendimiento ya que habria que estar llenandola cada vez a cada cambio de contexto

Virtualizacion de I/O

El S.O. huesped tratara de escribir en las posiciones de memoria donde cree que un dispositivo puede leer (a traves de DMA). Sin embargo, estas direcciones no son reales,
por lo cual el hipervisor debe traducir estas llamadas para escribir realmente en la posicion fısica donde el hardware pueda leerlo. De la misma manera cuando un dispositivo
escribe en una posicion determinada por DMA, se debe copiar, o mapear esa direccion fisica a una direccion que pueda leer el S.O. huesped. Este proceso es lento y proclive a introducir errores