Diferencia entre revisiones de «Sistemas Operativos (plan 1993)»

De Cuba-Wiki
m (Agrego un final de agosto de 2022)
Línea 128: Línea 128:


=== Tomados por Rodolfo Baader ===
=== Tomados por Rodolfo Baader ===
*[[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 Marzo 2019 (Sistemas Operativos)| Final 5 de Marzo 2019]] (mentira, 2020)
*[[Final Diciembre 2019 (Sistemas Operativos)| Final 19 de Diciembre 2019]]
*[[Final Diciembre 2019 (Sistemas Operativos)| Final 19 de Diciembre 2019]]

Revisión del 23:17 12 dic 2022

Plantilla: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 y, según el plan de la carrera, es una materia a ser cursada en 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

Segunda parte

Tercera parte

Nota: Los ejercicios con (*) son recomendados.

Curso de verano del 2009

Primer parcial

Segundo parcial

Parciales

Primeros parciales

Año Cuatrimestre Fecha Instancia Links
2012 Primero 28/06/2012 Recuperatorio enunciado
2013 Segundo 05/12/2013 Recuperatorio enunciado + resolución
2015 Primero 28/04/2015 Parcial enunciado: pág1, pág2
2017 Primero 25/04/2017 Parcial enunciado
2017 Primero 27/06/2017 Recuperatorio enunciado
2018 Primero 26/04/2018 Parcial enunciado, semi-resolución
2018 Primero 26/04/2018 Parcial enunciado, resolución
2018 Primero 26/06/2018 Recuperatorio enunciado + resolución
2018 Segundo 11/10/2018 Parcial enunciado + resolución
2019 Primero 30/04/2019 Parcial enunciado + resolución
2019 Primero 27/06/2019 Recuperatorio enunciado + resolución
2022 Primero 12/05/2022 Parcial enunciado
2022 Segundo 22/09/2022 Parcial resuelto (con enunciados)

Segundos parciales

Año Cuatrimestre Fecha Instancia Links
2013 Segundo 29/10/2013 Parcial enunciado + resolución
2015 Primero 28/05/2015 Parcial enunciado: pág1, pág2
2017 Primero 13/06/2017 Parcial enunciado
2017 Primero 11/07/2017 Recuperatorio enunciado
2018 Primero 14/06/2018 Parcial enunciado y resolución
2018 Primero 14/06/2018 Parcial enunciado y resolución
2018 Segundo 15/11/2018 Parcial enunciado y resolución
2018 Segundo 04/12/2018 Recuperatorio enunciado y resolución
2019 Primero 13/06/2019 Parcial enunciado y resolución
2019 Segundo 05/11/2019 Parcial enunciado y resolución (falta ej 1)
2019 Segundo 05/11/2019 Parcial enunciado y resolución
2019 Segundo 26/11/2019 Recuperatorio enunciado y resolución
2022 Primero 28/06/2022 Parcial enunciado
2022 Primero 12/07/2022 Recuperatorio enunciado
2022 Segundo 17/11/2022 Parcial enunciado y resuelto

Finales

Tomados por Roberto Bevilacqua

Tomados por Rodolfo Baader

Tomados por Sergio Yovine

Tomados por Fernando Schapachnik

Tomados por Diego Fernandez Slezak

Preguntas de Final (Oral)

  • 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?

Compilado de preguntas de final (Con respuestas)

Recursos

Bibliografía recomendada

Enlaces externos

Obtenido de «https://www.cubawiki.com.ar/index.php?title=Sistemas_Operativos_(plan_1993)&oldid=14855»