Encuadre: la primera parte de la materia es "una continuación de sistemas operativos": primero procesos, después desarrollo de servidores. El curso se enfoca en un solo procesador (uniprocesador): no se ve programación multiprocesador ni multinúcleo. "Distribuido" aquí significa servidor en un host y cliente en otro, conectados por red.

• Códigos del semestre → repositorio GitHub público (se puede hacer fork o rama en tu cuenta).
• Apuntes oficiales → GitHub Pages (HTTPS, alta disponibilidad). El sitio viejo profesores.fi-b.unam.mx/~carlos/acs es HTTP y está obsoleto.
• GitHub Codespaces: contenedor en la nube; el README.md del Tema 1 explica cómo levantarlo. No hace falta traer computadora — compila y ejecuta incluso desde el celular. Dentro tienes root (sudo o sudo su). Si rompes el sistema (rm -rf), destruyes el Codespace y creas otro; los programas vuelven intactos. Cerrar la pestaña lo suspende; se reactiva con el botón verde.
• En equipo propio: cualquier distro de Linux sirve. En Windows → WSL (Linux dentro de Windows) o SSH a un servidor Linux remoto.
• Red UNAM: los rangos públicos 132.247.*.* y 132.248.*.* son de la UNAM a nivel mundial. Las IP privadas (p. ej. 192.168.x.x) son internas y aisladas. El profesor se conectó por SSH a 132.248.77.168 [inaudible: también se transcribe como 132.247.248.7.168].
• Documentación formal de funciones C en Linux: The Open Group. Buscar "Open Group <función>" (ej. Open Group getpid).

Definición del profesor: "una fotografía o instantánea". Un ejecutable en ejecución crea un proceso que vive mientras la ejecución esté viva; al terminar o cerrar, el proceso muere.

Procesos en segundo plano (background) o demonios (daemon): no son visibles ni interactúas con ellos en la terminal. Cerrar la interfaz gráfica de un programa no siempre mata su proceso.

Al ejecutar un binario, el SO carga en una zona de memoria independiente (espacio de direcciones propio) las áreas de código y datos.

Segmentos estáticos:

• text (texto / código): solo lectura; código máquina + constantes de tipo string (p. ej. las que se pasan a printf).
• data: variables globales inicializadas.
• BSS (Block Started by Symbol; el profesor lo dictó como "block started by single"): variables globales no inicializadas.

Segmentos dinámicos:

• heap (montículo): memoria dinámica en ejecución (malloc).
• stack (pila): variables locales y parámetros de las llamadas a función.
• heap y stack crecen en sentidos opuestos ("uno crece a la izquierda y el otro a la derecha") para aprovechar el espacio.

Scope (ámbito) de una variable local = los límites de su función.

Tarea futura (todavía no): investigar file descriptors y la asignación dinámica de memoria (malloc).

⚠️ Examen — BCP / PCB (Process Control Block, "bloque de control de proceso"): estructura administrativa del kernel donde se guardan los metadatos del proceso. El profesor lo marcó como muy importante.

• Objetivo: entender la estructura de la imagen (código, datos inicializados, BSS, montículo y pila) y diferenciarla del contexto del SO.
• Compilar dando al binario el mismo nombre que el .c (con -o); así ls -l agrupa fuente y binario. Sin -o se genera a.out (mala práctica: el nombre no dice nada).
• Terminal 1: corre el servidor; usa getchar() para pausar y que el proceso no muera al instante — libera la memoria y muere hasta que pulsas Enter.
• Terminal 2: monitorea el proceso en RAM.
• Ubicación de las variables: global inicializada → data; global no inicializada → BSS; local → stack; reservada con malloc → heap; strings literales de printf → text.

size servidor — análisis estático (mira el archivo en disco). Columnas: text, data, bss, dec (suma en decimal), hex (suma en hexadecimal), filename. Ejemplo: 1767 + 592 + 8 = 2367 dec = 0x93F [inaudible: la transcripción decía "3F"].

⚠️ Examen: ¿por qué size no muestra heap ni stack? Porque son dinámicos: solo existen en RAM cuando el proceso está vivo; size solo analiza el archivo estático en disco.

pmap <PID> (Process Map) — análisis dinámico: consulta las estructuras del kernel e imprime el mapa completo del proceso en RAM (stack, heap, librerías .so, direcciones físicas). El PID se obtiene con getpid() (de <unistd.h>).

• Los valores de pmap no cuadran con size porque el SO asigna memoria por páginas de 4 KB; toda sección se redondea a página completa → todos los valores son múltiplos de 4.
• ⚠️ Seguridad: las zonas dinámicas (stack, heap) tienen permisos R / RW pero nunca X — para que no se pueda inyectar ni ejecutar código malicioso en el proceso.

cat /proc/<PID>/maps — mientras el proceso vive, el SO mantiene el directorio /proc/<PID>/; el archivo maps muestra direcciones hexadecimales, permisos de cada segmento y librerías dinámicas cargadas (información del PCB). Al pulsar Enter en la Terminal 1 termina getchar(), se libera el heap y el proceso muere.

• Todos los procesos forman un árbol jerárquico. La raíz tiene PID = 1: init en Unix clásico / distros viejas, systemd en distros modernas. De la raíz se derivan todos los demás procesos.
• PID = identificador único del proceso. PPID = PID del proceso padre.
• Principio: todo comando lanzado en una terminal tiene como padre al proceso de esa terminal (bash). El PID de bash no cambia mientras sea la misma terminal; el de ps cambia cada vez, porque nace y muere en el instante.

top — dinámico, se actualiza en pantalla; se sale con q.

Tiempo compartido (time-sharing): un proceso no acapara la RAM de principio a fin (sería una cola secuencial ineficiente). El planificador (scheduler) reparte pequeños lapsos de CPU entre los procesos según su prioridad, alternando tan rápido que da la ilusión de paralelismo.

ps — estático (no se actualiza). Sin opciones: solo los procesos de la terminal actual (normalmente bash + el propio ps).

ps aux — todos los procesos del sistema, ordenados por PID ascendente. Columnas: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND.

• Demonios: sin terminal asociada → ? en la columna TTY; por convención su nombre termina en d (systemd, kthreadd, watchdogd).
• VSZ = Virtual Memory Size, RSS = Resident Set Size (el profesor lo aclarará la próxima clase).

ps -e -o pid,ppid,user,stat,cmd — -e lista todos los procesos; -o elige las columnas a mostrar.

⚠️ Examen — sintaxis: las columnas tras -o van separadas por comas y SIN espacios; un espacio hace que la terminal devuelva error de sintaxis. Los estados de la columna STAT (S, R, R+, Ss…) se ven en clases posteriores.

• ls a secas no da información útil. ls -l = formato largo (permisos, tamaño, dueño, fecha). ls -la = incluye archivos ocultos (los que empiezan con .).
• Recomendado: ls -ltr — l largo, t ordena por fecha de modificación (más reciente arriba), r invierte el orden (más reciente abajo, junto al prompt).
• Uso en seguridad: en un incidente de intrusión ves de inmediato el último archivo creado o modificado por un atacante, sin hacer scroll en un directorio con cientos de archivos.

• Los procesos compiten de forma concurrente por la CPU → condición de carrera (race condition).
• Deadlock (bloqueo mutuo / "candado mortal"): "el proceso 1 dice: para continuar necesito que termine el proceso 2; y el proceso 2 dice: para continuar necesito que termine el proceso 1". No se debe estructurar un programa donde dos procesos dependen circularmente uno del otro.

• No hay tarea para entregar. Tarea moral: repasar el sitio web del curso y el PDF 2 del Tema 1 ("ID de procesos") — es extenso, no verlo todo de golpe.
• La próxima clase: teoría de fork() en C para crear procesos.