Edición de «Sistemas Operativos (plan 1993)»

{{Revisar guías}}

'''Sistemas Operativos''' es una materia dedicada al estudio de los conceptos en que se basan los Sistemas Operativos. Pertenece al área de [[Sistemas (Area)|Sistemas]] y, según el [[plan de la carrera]], es una materia a ser cursada en [[Plan de la Carrera#Tercer año|tercer año]]. Es correlativa de [[Organización del Computador II]] y [[Algoritmos y Estructuras de Datos II]] y necesaria para cursar [[Ingeniería del Software II]], [[Bases de Datos]] y [[Teoría de las Comunicaciones]].

Históricamente, esta materia se cursa los martes y jueves a la noche.

== Información general sobre la cursada ==
La cursada de Sistemas Operativos es teórico-práctica.

La materia consta de dos parciales; uno al principio y uno antes del final de la cursada. Los recuperatorios de ambos son al final del cuatrimestre.

Además de los parciales, la materia incluye la realización de tres trabajos prácticos (con su correspondiente recuperatorio) y cuatro talleres.

== Guías prácticas con soluciones ==
=== Primera parte ===
*[[Práctica Administración del Procesador (Sistemas Operativos)|Práctica 1: Administración del Procesador]]
*[[Práctica Semáforos (Sistemas Operativos)|Práctica 2: Semáforos]]
*[[Práctica Threads (Sistemas Operativos)|Práctica 3: Threads]]
*[[Práctica Administración de Memoria (Sistemas Operativos)|Práctica 4: Administración de Memoria]]
*[[Práctica Administración de Periféricos (Sistemas Operativos)|Práctica 5: Procesos Administracion de Perifericos]]

=== Segunda parte ===
*[[Práctica Administración de la Información (Sistemas Operativos)|Práctica 1: Administración de la Información]]
*[[Práctica Planificación de la Carga (Sistemas Operativos)|Práctica 2: Planificación de la Carga]]
*[[Práctica Abrazo Mortal (Sistemas Operativos)|Práctica 3: Abrazo Mortal (Deadlock)]]
*[[Práctica Protección y Seguridad (Sistemas Operativos)|Práctica 4: Protección y Seguridad]]
*[[Práctica Programación Concurrente (Sistemas Operativos)|Práctica 5: Procesos y Programación Concurrentes]]

=== Tercera parte ===
*[[Práctica Sistemas Distribuidos (Sistemas Operativos)|Práctica 1: Intro. Sistemas Distribuidos]]
*[[Práctica Modelo Cliente/Servidor (Sistemas Operativos)|Práctica 2: Modelo Cliente/Servidor]]
*[[Práctica Remote Procedure Call (Sistemas Operativos)|Práctica 3: RPC - Remote Procedure Call]]
*[[Práctica Sincronización de Sistemas Distribuidos (Sistemas Operativos)|Práctica 4: Sincronización de Sistemas Distribuidos]]
*[[Práctica Threads Distribuidos (Sistemas Operativos)|Práctica 5: Threads Distribuidos]]
*[[Práctica File Systems Distribuidos (Sistemas Operativos)|Práctica 6: File Systems Distribuidos]]

Nota: Los ejercicios con (*) son recomendados.

=== Curso de verano del 2009 ===

==== Primer parcial ====
*[[Práctica 1 (Sistemas Operativos verano)|Práctica 1: Administración de Procesos]]
*[[Práctica 2 (Sistemas Operativos verano)|Práctica 2: Comunicación entre Procesos]]
*[[Práctica 3 (Sistemas Operativos verano)|Práctica 3: Sincronización entre procesos]]

==== Segundo parcial ====
*[[Práctica 4 (Sistemas Operativos verano)|Práctica 4: Administración de memoria]]
*[[Práctica 5 (Sistemas Operativos verano)|Práctica 5: Administración de E/S]]
*[[Práctica 6 (Sistemas Operativos verano)|Práctica 6: Protección y Seguridad]]

== Parciales ==

=== Primeros parciales ===
{| class="wikitable sortable"
|-
! Año !! Cuatrimestre !! Fecha !! Instancia !! Links
|-
| 2012 || Primero || 28/06/2012 || Recuperatorio || [[Media:SisOp_1recu_28-6-12.pdf|enunciado]]
|-
| 2013 || Segundo || 05/12/2013 || Recuperatorio || [[Media:SisOp_1recu_05-12-13.pdf|enunciado + resolución]]
|-
| 2015 || Primero || 28/04/2015 || Parcial || enunciado: [[Media:SisOp_1parcial_28-04-15_1.png|pág1]], [[Media:SisOp_1parcial_28-04-15_2.png|pág2]]
|-
| 2017 || Primero || 25/04/2017 || Parcial || [[Media:SisOp_1parcial_25-04-17.pdf|enunciado]]
|-
| 2017 || Primero || 27/06/2017 || Recuperatorio || [[Media:SisOp_1recu_27-06-17.pdf|enunciado]]
|-
| 2018 || Primero || 26/04/2018 || Parcial || [[Media:SisOp_1parcial_26-04-18.pdf|enunciado]], [[Media:SisOp_resolucion1parcial_26-04-18.pdf|semi-resolución]]
|-
| 2018 || Primero || 26/04/2018 || Parcial || [[Media:sistemas_primer_parcial_2018_c1_enunciado.pdf|enunciado]], [[Media:sistemas_primer_parcial_2018_c1_resolucion.pdf|resolución]]
|-
| 2018 || Primero || 26/06/2018 || Recuperatorio || [[Media:SisOp_1recu_26-06-18.pdf|enunciado + resolución]]
|-
| 2018 || Segundo || 11/10/2018 || Parcial || [[Media:SisOp_1parcial_11-10-18.pdf|enunciado + resolución]]
|-
| 2019 || Primero || 30/04/2019 || Parcial || [[Media:SisOp_1parcial_30-04-19.pdf|enunciado + resolución]]
|-
| 2019 || Primero || 27/06/2019 || Recuperatorio || [[Media:SisOp_1recu_27-06-19.pdf|enunciado + resolución]]
|-
| 2022 || Primero || 12/05/2022 || Parcial || [[Media:SisOp_1parcial_12-05-22.pdf|enunciado]]
|}

=== Segundos parciales ===
{| class="wikitable sortable"
|-
! Año !! Cuatrimestre !! Fecha !! Instancia !! Links
|-
| 2013 || Segundo || 29/10/2013 || Parcial       || [[Media:SisOp 2parcial 29-10-13.pdf|enunciado + resolución]]
|-
| 2015 || Primero || 28/05/2015 || Parcial       || enunciado: [[Media:SisOp_2parcial_28-05-15_1.jpg|pág1]], [[Media:SisOp_2parcial_28-05-15_2.jpg|pág2]]
|-
| 2017 || Primero || 13/06/2017 || Parcial || [[Media:SisOp_2parcial_13-06-17.pdf|enunciado]]
|-
| 2017 || Primero || 11/07/2017 || Recuperatorio || [[Media:SisOp_2recu_11-07-17.pdf|enunciado]]
|-
| 2018 || Primero || 14/06/2018 || Parcial || [[Media:SisOp_2parcial_14-06-17.pdf|enunciado]] y [[Media:SisOp_resolucion2parcial_14-06-17.pdf|resolución]]
|-
| 2018 || Primero || 14/06/2018 || Parcial || [[Media:sistemas_segundo_parcial_2018_c2_enunciado.pdf|enunciado]] y [[Media:sistemas_segundo_parcial_2018_c2_resolucion.pdf|resolución]]
|-
| 2018 || Segundo || 15/11/2018 || Parcial || [[Media:SisOp_2parcial_15-11-18_resuelto.pdf|enunciado y resolución]]
|-
| 2018 || Segundo || 04/12/2018 || Recuperatorio || [[Media:SisOp_2recu_04-12-18_resuelto.pdf|enunciado y resolución]]
|-
| 2019 || Primero || 13/06/2019 || Parcial || [[Media:SisOp_2parcial_13-06-19.pdf|enunciado y resolución]]
|-
| 2019 || Segundo || 05/11/2019 || Parcial || [[Media:SisOp_2parcial_05-11-19.pdf|enunciado y resolución (falta ej 1)]]
|-
| 2019 || Segundo || 05/11/2019 || Parcial || [[Media:SisOp_2parcial_05-11-2019_v3.pdf|enunciado y resolución]]
|-
| 2019 || Segundo || 26/11/2019 || Recuperatorio || [[Media:SisOp_2recu_26-11-19_resuelto.pdf|enunciado y resolución]]
|-
| 2022 || Primero || 28/06/2022 || Parcial || [[Media:SisOp_2parcial_28-06-22.pdf|enunciado]]
|-
| 2022 || Primero || 12/07/2022 || Recuperatorio || [[Media:SisOp_2parcial_12-07-22.pdf|enunciado]]
|}

== Finales ==

=== Tomados por Roberto Bevilacqua ===
*[[Final del 29/12/09 (Sistemas Operativos)|Final del 29/12/09]]
*[[Final del 22/04/10 (Sistemas Operativos)|Final del 22/04/10]]
*[[Final del 26/11/10 (Sistemas Operativos)|Final del 26/11/10]]

=== Tomados por Rodolfo Baader ===
*[[Final Marzo 2019 (Sistemas Operativos)| Final 5 de Marzo 2019]] (mentira, 2020)
*[[Final Diciembre 2019 (Sistemas Operativos)| Final 19 de Diciembre 2019]]
*[[Final 12 Diciembre 2019 (Sistemas Operativos)| Final 12 de Diciembre 2019]]
*[[Final Mayo 2018 (Sistemas Operativos)| Final 16 de Mayo 2019]]
*[[Final Agosto 2017 (Sistemas Operativos)| Final 9 de Agosto 2017]]
*[[Final Diciembre 2016 (Sistemas Operativos)| Final 14 de Diciembre 2016]]
*[[Final Octubre 2016 (Sistemas Operativos)| Final 19 de Octubre 2016]]
*[[Final Febrero 2016 (Sistemas Operativos)| Final 18 de Febrero 2016]]
*[[Final Diciembre 2015 (Sistemas Operativos)|Final 21 de Diciembre 2015]]
*[[Final Marzo 2015 (Sistemas Operativos)|Final 5 de Marzo 2015]]
*[[Final Febrero 2015 (Sistemas Operativos)|Final 26 de Febrero 2015]]
*[[Final Agosto 2013 (Sistemas Operativos)|Final Agosto 2013]]
*[[Final Marzo 2012 (Sistemas Operativos)|Final Marzo 2012]]
*[[Final Diciembre 2011 (Sistemas Operativos)|Final Diciembre 2011]]
*[[Otros finales (Sistemas Operativos)|Otros finales]]

=== Tomados por Sergio Yovine ===
*[[Final Agosto 2015 (Sistemas Operativos)|Final 6 de Agosto 2015]]
*[[Medio:SisOp_final_2-8-16.pdf|Final 2 de Agosto 2016]]
*[[Medio:FinalSSOO-03-08-17.jpeg|Final 3 de Agosto 2017]]
*[[Final 16 de Noviembre de 2017 |Final 16 de Noviembre de 2017]]

=== Tomados por Fernando Schapachnik ===
*[[Un final de Chapa (Sistemas Operativos)|Un final de Chapa (2013)]]
*[[Final 9 de Marzo 2018 (Sistemas Operativos)|Final 9 de Marzo 2018]]
*[[Final 25 de abril 2018]]
*[[Final 19 de Junio 2018]]
*[[Final 31 de Julio 2018]]

=== Tomados por Diego Fernandez Slezak ===
*[[SisOp_final_27-02-14|Final del 27/02/14]]

=== Preguntas de Final (Oral) ===
[https://docs.google.com/document/d/16gVrJF2UkiHtTxStT1kf1_tzc1j7VsuUTrITKYxm5ZA/edit?usp=sharing Respuestas]
* Procesos
** ¿Qué es una system call? ¿Para qué se usan? ¿Cómo funcionan? Explicar en detalle el funcionamiento una system call en particular.
** ¿Las system calls son universales a todos los sistemas operativos o son dependientes de cada sistema?
** ¿Para qué sirve la system call fork? ¿Qué debilidades tiene? Comparar con vfork y la creación de threads.
** Diferencias entre system calls para crear procesos entre Linux y Windows.
** ¿Cómo funcionan los estados de un proceso? Ready, bloqueado, running.
** Explicar las transiciones de cada estado a cada estado (en particular, de waiting a ready). 
** Hablar de la tabla de procesos.
** ¿Qué estructura se debe mantener en memoria para poder tener procesos?
** ¿Qué es un proceso, un thread y en qué se diferencian?
** ¿En qué momento se ejecuta un thread?
** ¿Qué debería agregar a la PCB para manejar los threads?
** ¿Qué pasaría si los threads compartieran el stack? 
** Qué tendría que ver en un sistema para que piense que va a andar mejor agregando:
*** más procesadores. 
*** más memoria.
** Hablar de strace y ptrace.

* Scheduling
** Describir los objetivos que pueden tener las políticas de scheduling (fairness, carga del sistema, etc.).
** ¿Qué objetivo prioriza SJF y por qué no se usa en la práctica?
** ¿Cómo funciona el scheduling con múltiples colas? 
** ¿Hay algún problema con que las prioridades fueran fijas?
** Hablar sobre la afinidad de un procesador. ¿Qué información extra tenemos que tener en la PCB para mantener afinidad en un sistema multicore?
** Explicar el problema de inversión de prioridades.

* Sincronización
** ¿Para qué necesitamos sincronización entre procesos? ¿Qué soluciones nos ofrece el HW? Explicar el caso para monoprocesador y para multiprocesador. (instrucciones atómicas y deshabilitar interrupciones)
** ¿Cómo nos afecta si el scheduler es preemptive o non-preemptive en la implementación de un semáforo?
** Evaluar si están bien o mal utilizadas en los siguientes ejemplos las primitivas de sincronización:
*** Usar TASLock (spinlock) para acceder a disco.
*** Usar semáforos para incrementar un contador.
*** Usar un contador atómico  para un recurso que tienen que poder acceder 3 procesos a la vez.
*** usar spinlock para un recurso que tienen que poder acceder 3 procesos a la vez.
** Diferencia entre spin lock y semáforos (hablar de TTAS). ¿En qué contexto preferimos uno sobre el otro y por qué?. 
** ¿Cómo implementamos una sección crítica con spin locks?
** Explicar el problema clásico de lectores y escritores. Explicar cómo podemos evitar inanición del escritor.

* Memoria
** Se nos muestra un árbol de procesos donde cada proceso tiene una serie de page frames asignados. Explicar las siguientes situaciones:
*** ¿Por qué todos los procesos de un sistema compartirían una página? (páginas del kernel o bibliotecas compartidas)
*** ¿Por qué dos procesos específicos podrían compartir una página? (hablar de fork y copy-on-write)
** ¿Para qué sirve la paginación de la memoria? ¿Qué ventajas tiene sobre utilizar direcciones físicas? Hablar sobre el tamaño de las páginas y cómo se relaciona con el tamaño de los bloques en disco. (hablar de fragmentación interna y fragmentación externa)
** ¿Qué es un page fault y cómo se resuelve?
** ¿Por qué puede pasar que tengamos muchos procesos en waiting, y cómo podría tratar de arreglarlo si no pudiese agregar memoria?

* E/S
** Hablar de RAID (para qué sirve). Explicar la diferencia entre RAID 4 y RAID 5. ¿Cuál es mejor y por qué?
** Explicar los distintos algoritmos básicos de scheduling de disco. Explicar cómo se comportan en HDD y en SDD.
** ¿Qué son los drivers y qué permiten?
** Explicar diferencias entre un disco magnético y un SSD. ¿Qué problemas tiene un SDD? Hablar de write amplification y borrado. 
** ¿Cómo hace un disco para saber si un bloque está libre / si puede ser borrado? Explicar cómo podemos indicarle a un SDD que un bloque está libre (y que puede borrado). (comando TRIM)
** Explicar cómo se puede hacer una recuperación de datos, después de haber borrado un archivo.

* FS
** ¿Qué es un file descriptor? Nombrar 3 system calls que los afecten.
** ¿Cuándo se revisan los permisos de acceso sobre un archivo? Explicar por qué el file descriptor se crea cuando hacemos un open y no se vuelven a revisar los permisos.
** ¿Qué es un FS y para qué sirve?
** ¿Cuándo es adecuado reservar espacio en disco de manera secuencial? ¿Qué beneficios nos trae? (CD-ROM, ISO-9660)
** ¿Cuál FS nos conviene utilizar para un sistema embebido: FAT o inodos?
** ¿Cuál FS nos conviene utilizar para implementar UNDO (deshacer la última escritura a disco)? ¿Cómo se implementaría en FAT y en inodos?
** ¿Cuál FS nos conviene utilizar para implementar un backup total? ¿Cómo se implementaría en FAT y en inodos?
** ¿Cuál FS nos conviene utilizar para implementar un backup incremental? ¿Cómo se implementaría en FAT y en inodos?
** ¿Cuál FS nos conviene utilizar para implementar snapshot? (Diferenciar el caso en que queramos tomar una snapshot mientras el sistema está corriendo) ¿Cómo se implementaría en FAT y en inodos?
** Explicar las diferencias entre FAT e inodos. Ventajas y desventajas de cada uno.
** ¿FAT implementa algún tipo de seguridad?
** Explicar qué es journaling.
** Describir ext2. 
** ¿Qué mantiene un inodo? ¿Cómo es la estructura de directorios?
** ¿Para qué sirven los block groups y los clusters? Motivación para agrupar páginas en bloques, y bloques en grupos de bloques.
** ¿Cuáles son las estructuras más importantes de ext2? Explicar cada una (en particular, hablar del superbloque). 
** Explicar cómo se manejan los bloques libres del disco.
** ¿Qué pasa cuando se inicia el sistema luego de haber sido apagado de forma abrupta? Explicar cómo hace el sistema para darse cuenta de si hubo algún error (cuando no hace journaling) y cómo lo arregla. (inconsistencias entre contadores y bitmaps, entre entradas de inodos y bitmaps, entre entradas de directorios y bitmaps)
** Explicar las diferencias (ventajas y desventajas) entre soft links y hard links. ¿Por qué no podemos usar un hard link para referenciar inodos de otro FS, incluso si está basado en inodos?
** Explicar cómo se crean y borran archivos con las estructuras del FS (incluido cómo se modifica el block group). Explicar el caso de borrado en hard links. 
** Explicar qué ocurre cuando se borra un archivo en ext3 (y diferencias con ext2).

* Distribuidos
** ¿Cómo podemos mantener una base de datos distribuida sincronizada?
** ¿Qué es un sistema distribuido? ¿Qué significa que un sistema sea completamente distribuido? ¿Qué beneficios ofrecen? ¿Qué problemas nos puede traer?
** Explicar los distintos algoritmos de commits que se utilizan para actualizar una copia del archivo que está en varios nodos (2PC y 3PC). ¿Cuál es la diferencia entre 2PC y 3PC? Explicar la diferencia entre weak/strong termination.
** ¿Qué hace un nodo si se cae después de que todos digan ''sí'' al coordinador en 2PC?
** Explicar el problema bizantino.
** Explicar token ring ¿Qué problemas tiene? ¿Qué se hace en caso de que se pierda el token? ¿Cómo podemos mejorarlo?
** Explicar la diferencia entre grid y cluster.

*File Systems Distribuidos    
** ¿Qué es un file system distribuido? Explicar la interfaz VFS.
** Hablar de las limitaciones en DFS. 
** ¿Cómo podría hacer para poder tener $2$ discos distribuidos, y que los dos contengan la misma información? Y en caso de que se caiga la conexión, ¿cómo hacemos?
** ¿NFS es un file system completamente distribuido?
** Proponer una manera para mantener sincronizados $N$ servidores NFS. Explicar cómo saben los nodos a qué servidor pedirle los datos.
** Si un nodo se cae, ¿cómo hacemos para que se entere después de las transacciones que no tiene?     
* Seguridad
** ¿Cuáles son las tres categorías principales de permiso frente a un archivo? (owner, group, universo, ACL, capability)
** Explicar cómo son las ACLs en UNIX.
** Explicar SETUID. Explicar otro método (distinto a setuid y setguid) para ejecutar con permisos de otro usuario.
** Explicar cómo funcionan los canarios.
** ¿Para qué sirve el bit NX (No eXecute) de la tabla de páginas?
** Explicar buffer overflow y mecanismos para prevenirlo. (canario, páginas no ejecutables, randomización de direcciones) ¿En qué parte de la memoria se buscan hacer los buffer overflow? (En el stack, pero también se puede hacer en el heap. 
** ¿Cómo se genera el canario? ¿En tiempo de compilación o de ejecución?
** Explicar el ataque Return to libc.
** Dar un ejemplo de un error de seguridad ocasionado por race condition. (cambiar concurrentemente puntero de symbolic links)
** Explicar las diferencias entre MAC y DAC.
** ¿Qué es una firma digital? Explicar cómo es el mecanismo de autenticación. 
** ¿Qué es una función de hash? ¿Cómo se usa en el log-in de un SO? ¿Qué problemas tiene usar un hash para autenticar usuarios? ¿Cómo se puede mejorar la seguridad? ¿Qué es un SALT? ¿Cómo podemos hacer que calcular la función de hash sea más costoso? ¿Qué otros usos tiene la función de hash en seguridad?
** ¿Qué es una clave pública/privada? ¿Cómo podemos distribuir una clave pública?
** ¿Por qué es más seguro utilizar un esquema de clave pública/privada para una conexión por ssh, comparado con usuario/contraseña?
** ¿Cómo podemos asegurarnos que un programa es confiable? ¿Qué pasa si nos modifican tanto el hash como el archivo? Explicar cómo podemos brindar de manera segura las actualizaciones de un software. (integridad, autenticación, canal seguro)
** Explicar las diferencias entre HTTP y HTTPS. Explicar cómo se podría realizar un ataque cuando se realiza una actualización de un programa por HTTP (suponiendo que la actualización está firmada digitalmente) pegándole a un endpoint http. 
** ¿Se puede considerar Deadlock un problema de seguridad?
** ¿Qué problemas de seguridad hay asociados a los file descriptors? ¿Cómo lo resuelve SELinux?

* Virtualización
** ¿Qué es la virtualización y los contenedores? ¿Cómo se implementan?

=== [https://docs.google.com/document/d/1QOFw99da5EBd8kaa5tli7xId3tFPLQNIvbWytqu8m7k/edit# Compilado de preguntas de final (Con respuestas)] ===

== Recursos ==
* [[Media:SisOp_resumen_2022.pdf|Resumen para el final (2022)]]
* [[Media:SisOp_resumen_2021.docx|Resumen de las teoricas para el final]]: Desgrabación de las teóricas dadas el 2do C, 2020 (virtual).
* [[Media:apunte_so_final_zamboni.pdf|Apunte para el final]]: Apunte para estudiar para el final.
* [[Media:Resumen_so.pdf|Apunte para el final]]: Basado en el Tanenbaum.
* [[Media:resumen_so_tagliavini_v2.pdf|Apunte teórico (en forma de bullets)]]. Explicaciones con buen detalle. Tiene todos los temas que entran para el final.
*[[Media:SisOp_Apunte_Final.pdf|Apunte teórico en PDF]]: Apuntes de donde sacar las respuestas a las prácticas y parciales, 25 capítulos. Anteriormente este apunte se encontraba en la página oficial de la materia pero lo sacaron porque no lo mantenían actualizado. De todas maneras es muy útil.
* [https://github.com/CubaWiki/SisOp-Resumen-Taravilse/releases/download/1.0/sisop-resumen.pdf Apunte para el final]([https://github.com/CubaWiki/SisOp-Resumen-Taravilse Repositorio de fuentes]), por Leopoldo Taravilse. Bastante completo pero le falta un poco a la parte de sistemas distribuidos.
* [[Media:resumen_so_lbarrios.pdf|Apunte para el final]] ([https://github.com/lbarrios/sistemas-operativos-final/tree/master/resumen Repositorio de fuentes]): por Ezequiel Barrios. Basado principalmente en las clases y el Silberschatz.

== Bibliografía recomendada ==
*A. Silberschatz y P. Galvin, ''Sistemas Operativos'', Addison Wesley, 1999 ('''Circulante 681 364 Silberschatz''' en la [[Biblioteca Central]])
*A. Tanenbaum, ''Sistemas Operativos Modernos'', Prentice Hall, 1993 ('''Circulante 681 364 Tanenbaum''' en la [[Biblioteca Central]])
* [http://greenteapress.com/semaphores/ The Little Book of Semaphores, 2E (Allen B. Downey)]: un libro gratuito en PDF, con una colección de problemas de sincronización (pista, y solución usando semáforos)

== Enlaces externos ==
*[https://campus.exactas.uba.ar/course/view.php?id=999 Página oficial de la materia]
*[http://minix1.woodhull.com/ Una página con unas guías para instalar MINIX]
*[http://www.minix3.org Página oficial de MINIX 3]

[[Category:Materias]]
[[Category:Computación]]
[[Category:Sistemas]]
@@ Línea 1: / Línea 1: @@
-{{Plan 1993|Sistemas Operativos (plan 2023)}}
+{{Revisar guías}}
 '''Sistemas Operativos''' es una materia dedicada al estudio de los conceptos en que se basan los Sistemas Operativos. Pertenece al área de [[Sistemas (Area)|Sistemas]] y, según el [[plan de la carrera]], es una materia a ser cursada en [[Plan de la Carrera#Tercer año|tercer año]]. Es correlativa de [[Organización del Computador II]] y [[Algoritmos y Estructuras de Datos II]] y necesaria para cursar [[Ingeniería del Software II]], [[Bases de Datos]] y [[Teoría de las Comunicaciones]].
@@ Línea 48: / Línea 48: @@
 *[[Práctica 5 (Sistemas Operativos verano)|Práctica 5: Administración de E/S]]
 *[[Práctica 6 (Sistemas Operativos verano)|Práctica 6: Protección y Seguridad]]
-=== 2c2023 ===
-[https://github.com/honi/uba-so Guías resueltas 2c2023]
-[https://joaquinserna.notion.site/Sistemas-Operativos-58682f508f9245ada34ef5bb2c1c605b Guías resueltas, resúmenes, ejercicios de parcial resueltos]
 == Parciales ==
@@ Línea 85: / Línea 79: @@
 |-
 | 2022 || Primero || 12/05/2022 || Parcial || [[Media:SisOp_1parcial_12-05-22.pdf|enunciado]]
-|-
-| 2022 || Segundo || 22/09/2022 || Parcial || [[Media:SO_1p_2c2022_resuelto.pdf|resuelto (con enunciados)]]
-|-
-| 2023 || Primero || 02/05/2023 || Parcial || [[Media:SO_parcial1_02-05.pdf|enunciado]]
-|-
-| 2023 || Primero || 06/07/2023 || Recuperatorio || [[Media:SO_recu1_06-07.pdf|enunciado]]
-|-
-| 2023 || Primero || 03/10/2023 || Parcial || [[Medio:SisOp_1parcial_03-10-23_enunciado.pdf|enunciado]], [[Media:SisOp_1parcial_03-10-23.pdf|resolución]]
 |}
@@ Línea 127: / Línea 113: @@
 |-
 | 2022 || Primero || 12/07/2022 || Recuperatorio || [[Media:SisOp_2parcial_12-07-22.pdf|enunciado]]
-|-
-| 2022 || Segundo || 17/11/2022 || Parcial || [[Media:So_2p_2c2022_consigna.pdf|enunciado]] y [[Media:So_2p_2c2022_resuelto.pdf|resuelto]]
-|-
-| 2023 || Primero || 01/07/2023 || Parcial || [[Media:SO_parcial2_01-07.pdf|enunciado]] y [[Media:SO_2parcial_01-07-23_resuelto.pdf|resuelto]]
-|-
-| 2023 || Primero || 13/07/2023 || Recuperatorio || [[Media:SO_recu2_13-07.pdf |enunciado]]
-|-
-| 2023 || Segundo || 28/11/2023 || Parcial || [[Media:SisOp_2parcial_28-11-23.pdf|enunciado y resolución]]
 |}
@@ Línea 145: / Línea 123: @@
 === Tomados por Rodolfo Baader ===
-*[[Final Julio 27 2023 (Sistemas Operativos)| Final 27 de Julio 2023]]
-*[[Final Marzo 2023 (Sistemas Operativos)| Final 9 de Marzo 2023]]
-*[[Final 2da Marzo 2023 (Sistemas Operativos)| Final 2 de Marzo 2023]]
-*[[Archivo:Final Baader 20-12.txt|Final 20 de Diciembre de 2022]]
-*[[Media:Sistemas Operativos Final 10-8-22.pdf| Final 10 de Agosto 2022]]
 *[[Final Marzo 2019 (Sistemas Operativos)| Final 5 de Marzo 2019]] (mentira, 2020)
 *[[Final Diciembre 2019 (Sistemas Operativos)| Final 19 de Diciembre 2019]]
@@ Línea 189: / Línea 162: @@
 ** ¿Para qué sirve la system call fork? ¿Qué debilidades tiene? Comparar con vfork y la creación de threads.
 ** Diferencias entre system calls para crear procesos entre Linux y Windows.
-** ¿Cómo funcionan los estados de un proceso? Ready, bloqueado, running. Explicar las transiciones de cada estado a cada estado (en particular, de waiting a ready).
+** ¿Cómo funcionan los estados de un proceso? Ready, bloqueado, running.
-** ¿Qué estructura se debe mantener en memoria para poder tener procesos? Hablar de la tabla de procesos.
+** Explicar las transiciones de cada estado a cada estado (en particular, de waiting a ready).
+** Hablar de la tabla de procesos.
+** ¿Qué estructura se debe mantener en memoria para poder tener procesos?
 ** ¿Qué es un proceso, un thread y en qué se diferencian?
+** ¿En qué momento se ejecuta un thread?
 ** ¿Qué debería agregar a la PCB para manejar los threads?
 ** ¿Qué pasaría si los threads compartieran el stack?
@@ Línea 270: / Línea 246: @@
 ** ¿Qué es un file system distribuido? Explicar la interfaz VFS.
 ** Hablar de las limitaciones en DFS.
-** ¿Cómo podría hacer para poder tener 2 discos distribuidos, y que los dos contengan la misma información? Y en caso de que se caiga la conexión, ¿cómo hacemos?
+** ¿Cómo podría hacer para poder tener $2$ discos distribuidos, y que los dos contengan la misma información? Y en caso de que se caiga la conexión, ¿cómo hacemos?
 ** ¿NFS es un file system completamente distribuido?
-** Proponer una manera para mantener sincronizados N servidores NFS. Explicar cómo saben los nodos a qué servidor pedirle los datos.
+** Proponer una manera para mantener sincronizados $N$ servidores NFS. Explicar cómo saben los nodos a qué servidor pedirle los datos.
 ** Si un nodo se cae, ¿cómo hacemos para que se entere después de las transacciones que no tiene?
 * Seguridad
@@ Línea 300: / Línea 276: @@
 == Recursos ==
-*[https://github.com/FerFrassia/finalSSOO Script simulador de final]: Toma preguntas de los últimos finales al azar, por Fer Frassia.
-*[https://docs.google.com/document/d/1GCgKRl6F2ZYdkoi1NGor3ZlAeJxAL7ngQhahi8hVV6o/edit?usp=sharing RecetarioSO-Merge teóricas, prácticas y resumenes]: Merge de todo el material de la materia por Paula Pérez Bianchi
 * [[Media:SisOp_resumen_2022.pdf|Resumen para el final (2022)]]
 * [[Media:SisOp_resumen_2021.docx|Resumen de las teoricas para el final]]: Desgrabación de las teóricas dadas el 2do C, 2020 (virtual).