PROCESOS
Un proceso es un programa que se encuentra en ejecución. Un proceso no sólo es una copia del programa, sino que el núcleo le añade: un segmento de texto, un segmento de datos y un segmento de pila. Desde un punto de vista funcional, un proceso en UNIX es la entidad que se crea tras la llamda fork. Todos los procesos, excepto el proceso cero, son creados de esta forma. El proceso que llama a fork se conoce como el proceso padre y el proceso creado es el proceso hijo. El núcleo identifica cada proceso mediante un PID ( process identification), que es un número asociado a cada proceso, y que no cambia durante su tiempo de vida. Partes claves de los sistemas operativos • Los procesos • La gestión de memoria • La seguridad y la protección de la información • La planificación y la gestión de recursos • La estructura del sistema Los errores frecuentes en los procesos son: • Sincronización incorrecta: Es frecuente el caso en el que una rutina debe ser suspendida a la espera de un suceso en cualquier lugar del sistema. Por ejemplo, un programa inicia una lectura de E/S y debe esperar hasta que los datos están disponibles en un buffer antes de continuar. En tales casos se requiere alguna señal proveniente de alguna otra rutina. • Fallos de exclusión mutua: Es habitual el caso en que más de un usuario o programa intenta a la vez hacer uso de un recurso compartido. Por ejemplo, en un sistema de reservas de líneas aéreas. Si no se controlan estos accesos, puede producirse un error. Debe existir algún tipo de mecanismo de exclusión mutua que permita que sólo una rutina a la vez pueda realizar una transacción sobre una determinada parte de los datos. • Funcionamiento no determinista del programa: Los resultados de un programa en particular deben depender normalmente sólo de la entrada del programa y no de las actividades de otros programas en un sistema compartido. Pero cuando los programas comparten memoria y sus ejecuciones son intercaladas por el procesador, entonces pueden interferir con otros, sobre escribiendo zonas comunes de memoria de forma incierta. Así pues, el orden en que se organiza la ejecución de varios programas puede influir en los resultados de un programa en particular. • Interbloqueos: Es posible que dos o más programas estén suspendidos a la espera uno del otro.El S.O. tiene cinco responsabilidades principales en la gestión de almacenamiento: • Aislamiento del proceso: El sistema operativo debe procurar que cada proceso independiente no interfiera con los datos y la memoria de ningún otro. • Asignación y gestión automática: A los programas se les debe asignar memoria dinámicamente en la jerarquía de memoria, según la vayan necesitando. Este proceso debe ser transparente para el programador. • Soporte para la programación modular: Los programadores deben ser capaces de definir módulos de programa y de crear, destruir y alterar el tamaño de los módulos dinámicamente. • Protección y control de acceso: El s.o. debe permitir que las secciones de memoria estén accesibles de varias maneras para los diversos usuarios. • Almacenamiento a largo plazo: Muchos usuarios y aplicaciones necesitan medios para almacenar información por largos periodos de tiempo. Normalmente, los s.o. satisfacen estos requisitos mediante la memoria virtual y los servicios del sistema de archivos. La memoria virtual es un servicio que permite a los programas direccionar la memoria desde un punto de vista lógico, sin depender del tamaño de la memoria principal física disponible. El crecimiento de la utilización de los sistemas de tiempo compartido y, las redes de computadoras ha traído consigo un aumento en las preocupaciones de seguridad y protección de información. Se han identificado cuatro clases de políticas generales de protección, en orden creciente de dificultada: • No compartición: Los procesos están completamente aislados uno del otro y cada proceso tiene control exclusivo sobre los recursos que le fueron asignados estática o dinámicamente. Con esta política, los procesos suelen compartir los programas o archivos de datos haciendo copias y pasándolas a su propia memoria virtual. • Compartiendo los originales de los programas o archivos de datos: Una única copia física de un programa puede aparecer en varios espacios de memoria virtual como archivos de sólo lectura. • Subsistemas confinados o sin memoria: En este caso, los procesos se agrupan en subsistemas para cumplir una política de protección en particular. Por ejemplo, un proceso “cliente” llama a un proceso “servidor” para llevar a cabo cierta tarea con los datos. El servidor se protegerá de que el cliente descubra el algoritmo con el cual se lleva a cabo su trabajo y el cliente se protegerá de que el servidor retenga
• Diseminación controlada de la información: A los usuarios y a las aplicaciones se les dan credenciales de seguridad de un cierto nivel, mientras que a los datos y a otros recursos (p.e. los dispositivos de E/S) se les dota de clasificaciones de seguridad. La política de seguridad hace cumplir las restricciones relativas a qué usuarios tiene acceso a qué clasificaciones. • Control de acceso: Tiene que ver con la regulación del acceso del usuario al sistema completo, a los subsistemas y a los datos, así como a regular el acceso de los procesos a los recursos y objetos del sistema. • Control del flujo de información: Regula el flujo de datos dentro del sistema y su distribución a los usuarios. • Certificación: Es relativa a la demostración de que el acceso y los mecanismos de control del flujo se llevan a cabo de acuerdo a las especificaciones y a que estas cumplen las políticas de protección y seguridad deseadas. Una tarea clave del s.o. es administrar los recursos que tiene disponibles y planificar su utilización por parte de los diferentes procesos activos. Cualquier política de planificación y gestión de recursos cuenta con los tres factores siguientes: • Equidad: Sería conveniente que a todos los procesos que compitan por el uso de un recurso se les otorgue un acceso igualitario y equitativo, especialmente si estos procesos pertenecen a la misma clase. • Sensibilidades diferenciales: El sistema operativo debe intentar tomar decisiones de asignación y planificación que satisfagan la totalidad de los requisitos. El s.o. debe contemplar estas decisiones dinámicamente. Por ejemplo, si un proceso está esperando por el uso de un dispositivo de E/S, el s.o. puede querer planificar la ejecución de dicho proceso tan pronto como sea posible y así tener disponible al dispositivo para las demandas de otros procesos. • Eficiencia: El s.o. debe intentar maximizar la productividad, minimizar el tiempo de respuesta y, en el caso de tiempo compartido, alojar a tantos usuarios como sea posible. La tarea de planificación y gestión de recursos es básicamente un problema de investigación operativa, así que se pueden aplicar los resultados matemáticos de esta disciplina. Hablemos ahora de la parte clave de un s.o. la estrucura del sistema. El tamaño de un s.o. completo y la dificultad de las tareas que lleva a cabo plantean tres problemas desafortunados pero demasiado habituales: • Los s.o. cuando se entregan ya están cronológicamente retrasados. Esto conduce a nuevos s.o. y actualizaciones de los anteriores. • Los sistemas tienen fallos latentes que se manifiestan en el terreno y que deben ser detectados y corregidos.
Jerarquía del Diseño de un Sistema Operativo
Nivel Nombre Objetos Ejemplos de operaciones
13 Shell Entorno de programación
del usuario.
Sentencias de un lenguaje de shell
12 Procesos de
usuario Procesos de usuario. Salir, eliminar, suspender, reanudar. 11 Directorios Directorios. Crear, destruir, conectar,
desconectar, buscar, listar 10 Dispositivos Dispositivos externos tales como impresoras, pantallas y teclados. Crear, destruir, abrir, cerrar, leer, escribir 9 Sistema de archivos Archivos. Crear, destruir, abrir, cerrar, leer, escribir 8 Comunicacione s Tubos (pipes). Crear, destruir, abrir, cerrar, leer, escribir 7 Memoria virtual Segmentos, páginas. Leer, escribir, traer (fech) 6 Almacenamient o secundario local Bloques de datos, canales de dispositivos. Leer, escribir, asignar, liberar 5 Procesos primitivos. Procesos primitivos, semáforos, colas de procesos listos. Suspender, reanudar, esperar, señalizar. 4 Interrupciones Programas de tratamiento de interrupciones. Invocar, enmascarar, desenmascarar, reintentar. 3 Procedimientos . Procedimientos, pila de llamadas, visualización. Marcar la pila, llamar, retornar. 2 Conjunto de instrucciones Evaluación de la pila, intérprete de microprogramas, vectores de datos y escalares. Cargar, almacenar, sumar, restar, bifurcar. 1 Circuitos electrónicos Registros, puertas, buses, etc. Borrar, transferir, activar, completar. • Descripción y control de procesos. Todos los sistemas de multiprogramación (desde Windows NT hasta MVS) están construidos en torno al concepto de procesos.
El modelo más sencillo que puede construirse tiene en cuenta que, en un momento dado, un proceso puede estar ejecutándose en el procesador o no. Así pues, un proceso puede estar en uno de dos estados: Ejecución o No ejecución. Entrar Salir • Diagrama de transición de estados. Aún en este modelo tan simple se puede apreciar algunos de los elementos del diseño del sistema operativo, cada proceso debe representarse de forma que el sistema operativo pueda seguirle la pista. Esto es, debe haber información relativa a cada proceso, incluyendo su estado actual y su posición en memoria. Aquellos procesos que no están ejecutándose tiene que guardarse en algún tipo de cola, para que esperen su turno de ejecución. Cola
Entrar Expedir Salir
Interrumpir • Diagrama de colas. Creación y terminación de procesos. La vida de un proceso está limitada por su creación y su terminación. Creación de procesos. No ejecución Ejecución Procesador
Cuando se añade un proceso a los que ya está administrando el s.o., hay que construir las estructuras de datos que se utilizan para administrar el proceso y asignar el espacio de direcciones que va a utilizar el proceso. Existen cuatro sucesos comunes que llevan a la creación de un proceso: • En un entorno de trabajo por lotes , un proceso se crea como respuesta a la remisión de un trabajo. • En un entorno interactivo, se crea un proceso cuando un nuevo usuario intenta conectarse. • Proceso generado por un proceso existente. • Creado por el S.O. para dar un servicio. Cuando un proceso genera otro, el proceso generador se conoce como proceso padre y el proceso generado es el proceso hijo. Normalmente, estos procesos “emparentados” necesitarán comunicarse y cooperar entre sí. Terminación de procesos. En cualquier sistema, debe haber alguna forma de que un proceso pueda indicar que ha terminado. Razones para terminación de un proceso Terminación normal El proceso ejecuta una llamada a un servicio del SO que indica que ha terminado de ejecutarse. Tiempo límite excedido El proceso se ha ejecutado por más del límita especificado. No hay memoria disponible. El proceso necesita más memoria de la que el sistema le puede proporcionar. Violación de límites. El proceso trata de acceder a una posición de memoria a la que no le está permitido. Error de protección. El proceso intenta utilizar un recurso o un archivo que no le está permitido utilizar, o trata de utilizarlo de forma incorrecta, como escribir en un archivo que es sólo de lectura. Error aritmético. El proceso intenta hacer un cálculo prohibido, o trata de almacenar un número mayor del que el hardware acepta. Tiempo máximo de espera rebasado. El proceso ha esperado más allá del tiempo máximo especificado para que se produzca cierto suceso. Fallo de E/S Se produce un error en la entrada o la salida, tal como no encontrar un archivo, un fallo de lectura o escritura después de un número máximo de intentos. Instrucción privilegiada. El proceso intenta usar una instrucción reservada para el SO. Intervención del operador o del SO. Por alguna razón el operador o el sistema operativo terminan con el proceso.
Terminación del padre. Cuando un proceso padre finaliza, el SO. Puede diseñarse para terminar automáticamente con todos sus descendientes. Solicitud del padre. Un proceso padre tiene normalmente la autorización de terminar con cualquiera de sus descendientes. /*** Aquí falta las funciones getuid, getpid, getppid **********/ Estado de un proceso (modelo de cinco estados) Si todos los procesos estuvieran siempre listos para ejecutar, entonces la disciplina de cola propuesta anteriormente sería eficaz, sin embargo, aún en el simple ejemplo que se ha descrito, esta implementación no es adecuada: algunos procesos en el estado de No Ejecución están listos para ejecutar, mientras que otros están bloqueados, esperando a que termine una operación de E/S. Así pues, utilizando una cola sencilla, el distribuidos podría no seleccionar exactamente el proceso que está en el extremo más antiguo de la cola. Más bien, el distribuidos tendría que recorrer la lista buscando el proceso que no esté “no bloqueado” y que lleve más tiempo en la cola. Una forma más natural de afrontar esta situación es dividir el estado de No Ejecución en dos estados: Listo y Bloqueado. De esta forma contamos ahora con cinco estados: Ejecución. Proceso que está actualmente en ejecución. Listo. Proceso que está preparado para ejecutar, en cuanto se le dé la oportunidad. Bloqueado. Proceso que no puede ejecutarse hasta que se produzca cierto suceso, como la terminación de una operación de E/S. Nuevo. Proceso que se acaba de crear, pero que aún no ha sido admitido por el sistema operativo en el grupo de procesos ejecutables. Terminado. Proceso que ha sido excluido del grupo de procesos ejecutables, bien porque se detuvo o porque fue abandonado por alguna razón.
Figura 21. Diagrama de estado para un sistema operativo sencillo. Un proceso puede moverse voluntariamente al estado bloqueado haciendo una llamada a una función como sleep. Tarea: Investigar los parámetros del comando ps Creación de procesos y el fork de UNIX UNIX crea los procesos a través de una llamada fork al sistema, copiado la imagen en memoria que tiene el proceso padre. El nuevo proceso recibe una copia del espacio de direcciones del padre. Los procesos continúan su ejecución en la instrucción que está después del fork. La creación de dos procesos totalmente idénticos no es algo muy útil. El valor devuelto por fork es la característica distintiva importante que permite que el padre y el hijo ejecuten código distinto. El fork devuelve 0 al hijo y el ID del hijo, al padre. Ejemplo: en el siguiente fragmento de código tanto el padre como el hijo ejecutan la instrucción de asignación x =1 después del regreso de fork. #include <sys/types.h> #include <unistd.h> x = 0; fork();
x = 1; Ejemplo: Después de la llamada fork en el siguiente fragmento de código, los procesos padre e hijo imprimen sus ID de proceso. #include <stdio.h> #include <sys/types.h> #include <unistd.h> pid_t hijo; void main (void) { if ( (hijo = fork ( )) = = 0) { fprintf (stderr, “soy el hijo, ID= %ld\n”, (long)getpid()); /* el código del hijo va aquí */ } else if (hijo > 0) { fprintf (stderr, “soy el padre, ID = %ld\n”, (long)getppid()); /* el código del padre va aquí */ } }
Ejemplo: El siguiente fragmento de código crea una cadena de n procesos. #include <stdio.h> #include <sys/types.h> #include <unistd.h> int i, n; pid_t hijo; void main (void) { for (I = 1; I < n; I++) { if (hijo = fork()) break; /* mientras no sea diferente de cero , ie, no exista error */ fprintf (stderr, “Este es el proceso %ld con padre %ld \n”, (long)getpid(), (long)getppid()); } } Ejemplo: El siguiente fragmento de código crea un abanico de procesos. #include <stdio.h> #include <sys/types.h> #include <unistd.h> int I, n; pid_t hijo; void main (void) { for (I = 1; I < n; I++) { if (hijo = fork() <=0) break; /* después que crea un proceso termina */ fprintf (stderr, “Este es el proceso %ld con padre %ld \n”, (long)getpid(), (long)getppid()); } } Fork crea procesos nuevos haciendo una copia de la imagen del padre en la memoria. El hijo hereda la mayor parte de los atributos del padre, incluyendo el ambiente y los privilegios. El hijo también hereda algunos de los recursos del padre, tales como los archivos y dispositivos abiertos.
No todos los atributos o recursos del padre son heredados por el hijo. Este último tiene un ID de proceso nuevo y, claro que es diferente del ID del padre. Los tiempos del hijo para el usos del CPU son iniciados a 0. El hijo no obtiene los bloqueos que el padre mantiene. Si el padre ha puesto una alarma, el hijo no recibe notificación alguna del momento en que ésta expira. El hijo comienza sin señales pendientes, aunque el padre las tenga en el momento en que se ejecuta el fork. Aunque el hijo hereda la prioridad del padre y los atributos de la administración de procesos, tiene que competir con otros procesos, como entidad aparte, por el tiempo del procesador. Llamada wait al sistema ¿Qué sucede con el proceso padre después de que éste crea un hijo? Tanto el padre como el hijo continúan la ejecución desde el punto donde se hace la llamada a fork. Si el padre desa esperar hasta que el hijo termine, entonces debe ejecutar una llamada a wait o a waitpid. La llamada al sistema wait detiene el proceso que llama hasta que un hijo de éste termine o se detenga, o hasta que el proceso que la invocó reciba una señal. Wait regresa de inmediato si el proceso no tiene hijos o si el hijo termina o se detiene y aún no se ha solicitado la espera. int wait (int *stat_loc) Si wait regresa debido a la terminación de un hijo, el valor devuelto es positivo e igual al ID de proceso de dicho hijo. De lo contrario, wait devuelve –1 y pone un valor en errno. Errno = ECHILD indica que no existen procesos hijos a los cuales hay que esperar. Errno = EINTR la llamada fue interrumpida por una señal. stat_loc es un apuntador a una variable entera. POSIX (Portable Operating System Environment for Computer Environments, IEEE) especifica los macros WIFEXITED, WEXITSTUS, WIFSIGNALED, WTERMSIG, WIFSTOPPED y WSTOPSIG para analizar el estado devuelto por el hijjo y que permanence guardado en *stat_loc. El hijo regresa su estado llamando a exit, _exit o return. Ejemplo: Programa que muestra el empleo de wait. #include <sys/types.h> #include <sys/wait.h> #include <unistd.h>
main() { pid_t hijo; int estado; if ( (hijo=fork()) == 1) { perror ("fallo el fork"); exit (1); } else if (hijo == 0) fprintf (stderr, "soy el hijo con pid = %ld \n", (long) getpid()); else if (wait(&estado) !=hijo) fprintf (stderr, "una señal debio interrumpir la espera \n"); else fprintf (stderr, "soy el padre con pid = %ld e hijo con pid = %ld\n", (long)getpid(),(long)hijo); exit(0); } Descripción de procesos El S.O. es el controlador de los sucesos que se producen en un sistema informático. Es el S.O. el que planifica y expide a los procesos para su ejecución en el procesador, el que asigna los recursos a los procesos y el que responde a las solicitudes de servicios básicos realizadas por los programas de usuario. Este concepto queda ilustrado en la figura 22. Figura 22. Procesos y recursos. Estructuras de control del sistema operativo
Si el S.O. va a administrar los procesos y los recursos, entonces tiene que disponer de información sobre el estado actual de cada proceso y de cada recurso. El método universal para obtener esta información es sencillo: el sistema operativo construye y mantiene tablas de información sobre cada entidad que esté administrando. Figura 23. Estructura general de las tablas de control del sistema operativo. Debemos tener claro que las tablas mostradas en la figura 23, deben estar enlazadas o disponer de referencias cruzadas de alguna manera. La memoria, la E/S y los archivos son administrados en nombre de los procesos, por lo que debe haber alguna referencia directa o indirecta a estos recursos en la tablas de procesos. Los archivos que son referidos en las tablas de archivos son accesibles a través de un dispositivo de E/S y, algunas veces, estarán en memoria principal o en memoria virtual. Operaciones sobre procesos. Los sistemas que administran procesos deben ser capaces de realizar ciertas operaciones sobre procesos y con ellos. Tales operaciones incluyen: Crear un proceso Destruir un proceso Suspender un proceso Reanudar un proceso Cambiar la prioridad de un proceso Bloquear un proceso Despertar un proceso Despachar un proceso Permitir que un proceso se comunique con otro (comunicación entre procesos)
Crear un proceso implica operaciones tales como: Dar un nombre al proceso Insertarlo en la lista de procesos conocidos del sistema (o tabla de procesos) Determinar la prioridad inicial del proceso Crear el bloque de control de proceso Asignar los recursos iniciales al proceso. Llamada exec al sistema La llamada for al sistema crea una copia del proceso que la llama. Muchas aplicaciones requieren que el proceso hijo ejecute un código diferente del de su padre. La familia exec de llamadas al sistema proporciona una característica que permite traslapar al proceso que llama con un módulo ejecutable nuevo. La manera tradicional de utilizar la combinación forkexec es dejar que el hijo ejecute el exec para el nuevo programa mientras el padre continúa con la ejecución del código original. Existen seis variaciones de la llamada exec al sistema, las cuales se distinguen por la forma en que son pasados los argumentos de la línea de comando y el ambiente, y por si es necesario proporcionar la ruta de acceso y el nombre del archivo ejecutable. execl (execl, execlp y execle). Pasan los argumentos de la línea de comando como una lista y son útiles si se conoce el número de argumentos de la línea de comando en el momento de la compilación. #include <unistd.h> int execl (const char *path, const char *arg0, … , const char *argn, char * /*NULL*/); int execle (const char *path, const char *arg0, … , const char *argn, char * /*NULL*/, const char *envp[]); int execlp (const char *file, const char *arg0, … , const char *argn, char * /*NULL*/);
execv (execv, execvp y execve). Pasan los argumentos de la línea de comando en un arreglo de argumentos.
#include <unistd.h>
int execv (const char *path, const char *argv[]);
int execve (const char *’path, const char *argv[], const char *envp[]); Ejemplo: programa que crea un proceso para ejecutar ls –l. #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> main( ) { pid_t hijo; int estado; if (( hijo = fork( )) = = 1) { perror (“Error al ejecutar fork”); exit (1); } else if (hijo = = 0) { if (execl (“/usr/bin/ls”, “ls”, “l”, NULL) < 0) { perror (“Falla en la ejecución de ls”); exit (1); } } else if (hijo ! = wait (&estado)) perror (“Se presento una señal antes de la terminación del hijo”); exit (0); } NOTA: la función perror muestra un mensaje con el error estándar seguido por el error de la última llamada al sistema o la biblioteca que lo produjo. #include <stdio.h> void perror (const char *s);
El DIAGRAMA de estado para los procesos de UNIX es bastante complejo. El proceso se está ejecutando en modo usuario. El proceso se está ejecutando en modo kernel. El proceso no se está ejecutando, pero está listo para ejecutarse tan pronto como el kernel lo ordene. El proceso está durmiendo cargado en memoria. El proceso está listo para ejecutarse, pero el swapper (proceso 0) debe cargar el proceso en memoria antes de que el kernel pueda ordenar que pase a ejecutarse. El proceso está durmiendo y el swappper ha descargado el proceso hacia una memoria secundaria (área de swap del disco) para crear espacio en la memoria principal donde poder cargar otros procesos. El proceso está volviendo del modo kernel al modo usuario, pero el kernel se apropia del proceso y hace un cambio de contexto, pasando otro proceso a ejecutarse en modo usuario. El proceso acaba de ser creado y está en un estado de transición; el proceso existe, pero ni está preparado para ejecutarse (estado 3), ni durmiendo (estado 4). Este estado es el inicial para todos los procesos, excepto el proceso 0. El proceso ejecuta la llamada exit y pasa al estado zombi. El proceso ya no existe, pero deja para su proceso padre un registro que contiene el código de salida y algunos datos estadísticos tales como los tiempos de ejecución. El estado zombi es el estado final de un proceso.
