• Author / Uploaded
• Ciro Hidalgo Mozombite

• Categories
• Sistema operativo
• Microsoft Windows
• Unix
• Microcomputadoras
• Hardware de la computadora

Citation preview

Sistemas Operativos Curso académico 2014/2015

Esta obra de Jesús Torres está bajo una Licencia Creative Commons Atribución 4.0 Internacional. ISBN 978-84-695-9610-4

Índice de contenido 1. Introducción 1 1.1. ¿Qué hace un sistema operativo?..............................................................................................1 1.2. Tipos de sistemas operativos.....................................................................................................4 1.3. Historia de los sistemas operativos.........................................................................................10 2. Estructura de los sistemas operativos 11 2.1. Componentes del sistema........................................................................................................11 2.2. Servicios del sistema...............................................................................................................16 2.3. Operación del sistema operativo.............................................................................................18 2.4. Llamadas al sistema................................................................................................................20 2.5. Programas del sistema............................................................................................................23 2.6. Estructura del sistema.............................................................................................................25 2.7. Máquinas virtuales..................................................................................................................32 2.8. Arranque del sistema...............................................................................................................38 3. Gestión de procesos 41 3.1. Procesos..................................................................................................................................41 3.2. Procesos cooperativos.............................................................................................................50 3.3. Hilos........................................................................................................................................67 3.4. Planificación de la CPU..........................................................................................................77 4. Gestión de memoria 105 4.1. Memoria principal.................................................................................................................105 4.2. Memoria Virtual....................................................................................................................143 5. Gestión del almacenamiento 185 5.1. Interfaz del sistema de archivos............................................................................................185 5.2. Implementación de sistemas de archivos..............................................................................198 5.3. Estructura del almacenamiento masivo................................................................................215

Índice de figuras Figura 1.1: Vista abstracta de los componentes de un sistema informático.........................................2 Figura 1.2: Disposición de la memoria en un sistema de procesamiento por lotes..............................5 Figura 1.3: Disposición de la memoria en un sistema multiprogramado.............................................6 Figura 1.4: Instalación de un mainframe IBM 702............................................................................13 Figura 1.5: Mainframe GE-6180 con sistema operativo MULTICS (MIT ca. 1976).........................14 Figura 1.6: Miniordenador DEC PDP-7.............................................................................................15 Figura 2.2: Llamada al sistema en Linux MIPS.................................................................................25 Figura 2.1: Diagrama general de organización de los sistemas operativos........................................26 Figura 2.3: Elementos de la interfaz de programación de aplicaciones en GNU/Linux....................27 Figura 2.4: Mapeo de la memoria física en el espacio de direcciones virtual de un proceso.............37 Figura 2.5: Ejemplo de sistema operativo con estructura sencilla (MSDOS)....................................39 Figura 2.7: Ejemplo de sistema operativo con estructura sencilla (UNIX original)..........................40 Figura 2.6: Diagrama de bloques de Microsoft Windows XP............................................................40 Figura 2.8: Diagrama de bloques de GNU/Hurd................................................................................43 Figura 2.9: Ejemplo de sistema operativo con estructura modular (GNU/Linux).............................45 Figura 3.1: Estructura de un proceso en memoria..............................................................................48 Figura 3.2: Diagrama de estado de los procesos................................................................................49 Figura 3.3: Diagrama de colas de la planificación de procesos..........................................................51 Figura 3.4: Ejemplo de creación de un proceso con fork()/exec().....................................................55 Figura 3.5: Modelos de comunicación...............................................................................................57 Figura 3.6: Ejemplo de utilización de tuberías para la comunicación entre procesos........................63 Figura 3.7: Comparación entre procesos monohilo y proceso multihilo............................................66 Figura 3.8: Modelo muchos a uno......................................................................................................69 Figura 3.9: Modelo uno a uno............................................................................................................71 Figura 3.10: Muchos a muchos..........................................................................................................72 Figura 3.11: Modelo de dos niveles....................................................................................................73 Figura 3.12: Histograma de los tiempos de las ráfagas de CPU........................................................86 Figura 3.13: Planificación con colas multinivel.................................................................................88 Figura 3.14: Etapas de procesamiento de un programa de usuario..................................................102 Figura 4.1: Soporte del hardware para la paginación.......................................................................105 Figura 4.2: Descomposición de las direcciones virtuales en paginación.........................................107 Figura 4.3: Bit de válido en la tabla de páginas................................................................................111 Figura 4.4: Proceso en memoria.......................................................................................................111 Figura 4.5: Copy-on-write antes de que el proceso 1 modifique la página A..................................118 Figura 4.6: Copy-on-write después de que el proceso 1 modifique la página A..............................120 Figura 4.7: Hiperpaginación en sistemas multiprogramados...........................................................128 Figura 4.8: Proceso en memoria.......................................................................................................136 Figura 5.1: Disco duro......................................................................................................................141 iii

Índices Figura 5.2: Estructura lógica de un disco magnético.......................................................................142 Figura 5.3: Estructura de un sistema de archivos.............................................................................147

iv

1. Introducción

1.1. Funciones del sistema operativo Es habitual cuando hablamos de un elemento tan complejo como un sistema operativo que resulte más sencillo definirlo por lo que hace que por lo que es. Por ello, comenzaremos viendo el papel del sistema operativo en el conjunto de un sistema informático. Un sistema informático cualquiera puede ser dividido en cuatro componentes (véase la Figura 1.1): el hardware, el sistema operativo, los programas de aplicación y los usuarios. ●

El hardware –la CPU, la memoria, los dispositivos de entrada salida, etc.– proporcionan los recursos computaciones del sistema.

●

Los programas de aplicación –procesadores de textos, hojas de cálculo, compiladores, navegadores de Internet–. Definen las diferentes formas en las que los recursos de sistema son utilizados para resolver los problemas informáticos de los usuarios.

●

El sistema operativo controla y coordina el uso de hardware por parte de las diversas aplicaciones para los diferentes usuarios del sistema. Un sistema operativo no hace trabajo útil. Simplemente proporciona un entorno adecuado para que otros programas puedan hacerlo.

Con el fin de entender cuáles son las funciones de un sistema operativo; se puede explorar su papel desde dos puntos de vista: el del sistema informático y el del usuario.

Sistemas Operativos - 2014/2015

1. Introducción

usuario 1

usuario 2

usuario 3

...

editor

juego

compilador

...

usuario n

base de datos

programas del sistema y aplicaciones

sistema operativo

hardware

Figura 1.1: Vista abstracta de los componentes de un sistema informático.

1.1.1. Punto de vista del sistema informático Desde el punto de vista del sistema informático, el sistema operativo es el programa más íntimamente relacionado con el hardware. En este contexto, el sistema operativo actúa como: 1. Gestor de los recursos de sistema informático. 2. Programa encargado del control de la ejecución de los programas de usuario y del acceso a los dispositivos de E/S. Un sistema informático tiene múltiples recursos tanto hardware como software –tiempo de CPU, espacio de memoria, espacio de almacenamiento de archivos, dispositivos de E/S, servicios de red, etc.–. El sistema operativo, como gestor de estos recursos, los asigna a los diferentes programas, resolviendo los conflictos en las peticiones y haciendo que el sistema opere eficientemente y resuelva los problemas de los usuarios. Además, como un programa encargado del control de la ejecución de los programas de los usuarios, el sistema operativo tiene la tarea de prevenir errores y el uso inadecuado del ordenador.

1.1.2. Punto de vista del usuario Sin embargo, la función del sistema operativo desde el punto de vista del usuario varía de acuerdo con la interfaz utilizada. Por ejemplo, los usuarios que se sientan frente a un sistema de escritorio 1-2

1.1. Funciones del sistema operativo

Sistemas Operativos - 2014/2015

(véase el apartado 1.3.2) disponen de monitor, teclado, ratón y una unidad central. Estos sistemas se diseñan buscando la máxima productividad en equipos donde un usuario monopoliza todos los recursos; por lo que el sistema operativo se diseña considerando fundamentalmente la facilidad de uso, poniendo algo de atención en el rendimiento y nada en el aprovechamiento de los recursos. En otros casos un usuario se sienta frente a un terminal1 conectado a un mainframe (véase el apartado 1.3.1), mientras muchos otros acceden al mismo sistema a través de otros terminales. Por tanto, todos los usuarios comparten los recursos del sistema informático y pueden intercambiar información. En esos casos el sistema operativo debe maximizar el aprovechamiento de los recursos con el objetivo de garantizar que toda la CPU, memoria y E/S sean empleadas de forma eficiente, y que ningún usuario utiliza más que lo que le corresponde. Otro ejemplo son los sistemas de mano (véase el apartado 1.3.5), por ejemplo tablets y teléfonos móviles. A causa de las limitaciones de la interfaz, en el diseño del sistema operativo debe primar la usabilidad2, aunque el rendimiento por tiempo de vida de la batería también es importante.

1.2. Definición de sistema operativo No existe una definición universal de lo que es un sistema operativo. Hay quién considera que es lo que el fabricante nos vende cuando decimos que queremos comprar un sistema operativo. Esta definición no parece muy precisa puesto que las características incluidas pueden variar enormemente de un sistema a otro. Por ejemplo, algunos sistemas apenas alcanzan el megabyte de espacio, careciendo incluso de las aplicaciones más básicas, como puede ser un editor, mientras que otros ocupan gigabytes de espacio y están completamente basados en sistemas gráficos de ventanas. Una definición mucho más común es que el sistema operativo es aquel programa que se ejecuta continuamente en el ordenador –lo que denominamos comúnmente kernel o núcleo– siendo todo lo demás programas del sistema y aplicaciones. Sin embargo, es indudable que en algunos casos ésta definición no incluye como parte del sistema operativo algunas características que intuitivamente solemos considerar dentro del mismo. Por ejemplo, si aplicamos esta definición a los sistemas operativos de estructura microkernel (véase el apartado 2.3.3), no podríamos decir que servicios como la comunicación en red, la gestión del sistema de archivos y la gestión de la memoria (véanse 1 Los terminales son sistemas informáticos utilizados para la conexión de los usuarios a un mainframe. Sólo suelen disponer de los recursos necesarios para realizar esa tarea. 2 La usabilidad es la medida de la facilidad de uso de un producto o servicio, típicamente una aplicación software o un aparato. Más información en http://es.wikipedia.org/wiki/Usabilidad.

1-3

Sistemas Operativos - 2014/2015

1. Introducción

el apartado 2.1.2) son proporcionados por el sistema operativo. Aunque pueda parecer lo contrario, la cuestión de que incluye y que no incluye un sistema operativo no carece de importancia, como se demostró durante el caso del Departamento de Justicia de los Estados Unidos contra Microsoft por la excesiva inclusión de funcionalidades en sus sistemas operativos3. Parece evidente que un sistema operativo se define mejor por lo que «hace» –es decir, sus funciones– que por lo que «es». Sin embargo, ésta primera manera de definirlo también tiene sus dificultades. Por ejemplo, el principal objetivo de los sistemas operativos de escritorio es la facilidad de uso, mientras que en los mainframe el objetivo fundamental es la eficiencia en el aprovechamiento de los recursos. Puesto que ambos objetivos pueden ser en ocasiones contradictorios, resulta obvio que lo que tiene que «hacer» un sistema operativo para alcanzar esos objetivos puede ser diferente en cada caso, lo que dificulta el obtener una definición única. De lo que no hay duda es de que los sistemas operativos existen porque es más fácil hacer un sistema informático usable con ellos que sin ellos. El objetivo fundamental de las computadoras es ejecutar programas para resolver fácilmente los problemas de los usuario, por lo que con ese objetivo se construye el hardware de los ordenadores. Puesto que el hardware por si sólo resulta difícil de utilizar, es necesario desarrollar programas de aplicación para que sean utilizados por los usuarios. Sin embargo, estas aplicaciones necesitan realizar operaciones comunes, como controlar los dispositivos de E/S o reservar porciones de la memoria. Esas funciones comunes de control y asignación de recursos, que se corresponden con las funciones del sistema operativo desde el punto de vista del sistema informático vistas en el tema 1.1.1, son la labor del sistema operativo.

1.3. Tipos de sistemas operativos 1.3.1. Mainframe Los ordenadores centrales o mainframes fueron los primeros computadores utilizados en muchas aplicaciones comerciales y científicas. Se caracterizan no tanto por la potencia de su CPU 4 como por: su gran capacidad de memoria, su gran capacidad de almacenamiento secundario, la gran

3 Más información sobre el caso en http://goo.gl/u1tf. 4 Generalmente se considera que las mayor diferencia entre los superordenadores y los mainframes está en que los primeros se centran en resolver problemas limitados por la velocidad de cálculo –lo cual requiere miles de CPU de alto rendimiento– mientras que lo segundos se centran en problemas limitados por la E/S y la fiabilidad –sólo necesitan entre una y varias docenas de CPU–. Más información en http://es.wikipedia.org/wiki/Ordenador_central.

1-4

1.3. Tipos de sistemas operativos

Sistemas Operativos - 2014/2015

sistema operativo

área de los programas de usuario

Figura 1.2: Disposición de la memoria en un sistema de procesamiento por lotes.

cantidad de dispositivos de E/S y la rapidez de estos, así como por su alta fiabilidad. Estas máquinas pueden funcionar durante años sin problemas ni interrupciones y las reparaciones se realizan sin detener su funcionamiento.

a) Sistemas de procesamiento por lotes Los sistemas de procesamiento por lotes o sistemas en batch fueron los primeros ordenadores (véase el apartado 1.4.2). Eran enormes máquinas operadas desde una consola y conectados a lectores de tarjetas perforadas5, dispositivos de cinta e impresoras. El trabajo, normalmente en tarjetas perforadas, era preparado por el programador y entregado al operador. Para acelerar la ejecución el operador debía agrupar los programas con requerimientos similares en lotes y mandarlos a ejecutar según iba quedando disponible el ordenador. Finalmente, el resultado de cada programa debía ser devuelto al programador correspondiente. ●

El sistema operativo permanecía siempre residente en memoria (véase la Figura 1.2).

●

La única tarea del sistema operativo era transferir automáticamente el control de un trabajo al siguiente.

●

El mayor inconveniente de éste tipo de sistemas era que la CPU permanecía mucho tiempo desocupada porque era y es varios ordenes de magnitud más rápida que la E/S. Los programas necesitan realizar operaciones de E/S para obtener los datos requeridos para sus cálculos –por ejemplo guardados en tarjetas perforadas– por lo que se pierde mucho tiempo esperando a que estén disponibles dichos datos.

5 Mas información sobre la forma de trabajo con tarjetas perforadas en http://goo.gl/S9FTOk.

1-5

Sistemas Operativos - 2014/2015

1. Introducción

b) Sistemas multiprogramados Con la aparición de la tecnología de los discos magnéticos se pudo mantener todos los trabajos en el disco y no en tarjetas perforadas sobre la mesa del operador. Esto permitió que el sistema operativo pudiera encargarse de escoger el orden de ejecución de los trabajos. 3. En disco se almacena una cola con todos los trabajos que deben ser ejecutados. 4. El sistema operativo mantiene varios trabajos en memoria del conjunto de trabajos en la cola en disco (véase la Figura 1.3). 5. El sistema operativo ejecuta en la CPU unos de los trabajos en memoria. 6. Si el trabajo en la CPU requiere E/S, en lugar de mantener a la CPU ocupada inútilmente, el sistema operativo escoge otro trabajo de entre los que están en memoria y lo ejecuta en la CPU. El nuevo programa en la CPU no es interrumpido cuando el anterior termina de utilizar la E/S, sino que éste último debe esperar en la memoria una nueva oportunidad para ser escogido. 7. Cuando un programa en la CPU termina, un hueco queda libre en la memoria. Por lo tanto es necesario que el sistema operativo escoja un trabajo de la cola en disco y lo cargue en la memoria. 8. El proceso se repite mientras hayan trabajos que ejecutar. Para seguir un esquema como el anterior es necesario que el sistema operativo realice tres tareas esenciales: ●

La planificación de trabajos. Su responsabilidad es elegir cual es el siguiente trabajo que debe ser cargado para mantener llena la memoria.

●

La planificación de la CPU. Se encarga de elegir el siguiente trabajo que debe ser ejecutado en la CPU de entre los disponibles en la memoria (véase el apartado 3.4).

●

La gestión de la memoria. Es necesaria puesto que la memoria tiene que ser repartida entre los trabajos que deben ser alojados en la misma (véase el apartado 2.1.2).

Un ejemplo de este tipo de sistemas operativos es el IBM OS/360 que fue liberado en 1966 para utilizarlo en los mainframes IBM System/360 (véase el apartado 1.4.3).

1-6

1.3. Tipos de sistemas operativos

Sistemas Operativos - 2014/2015

c) Sistemas de tiempo compartido La mayor parte de los sistemas actuales son sistemas de tiempo compartido. Los sistemas anteriores ofrecían un uso eficiente de la CPU pero no eran capaces de proporcionar interacción con el usuario. El usuario se limitaba a entregar los trabajos al operador y a esperar a que éste le devolviera los resultados. Los sistemas de tiempo compartido se caracterizan por tener: ●

Un sistema de interacción directa entre el usuario y el sistema. Por ejemplo, un terminal.

●

Un sistema multiprogramado dónde la conmutación es tan frecuente que el usuario puede interactuar con cada programa mientras se ejecuta.

Utilizando esta estrategia un sistema de tiempo compartido puede disponer de varios terminales de forma que múltiples usuarios puedan utilizar la máquina simultáneamente 6. Los usuarios comparten la CPU y los otros recursos del sistema, sin embargo, la sensación para cada uno es la de que el sistema completo está dedicado a él en exclusiva. Realmente el sistema conmuta de un usuario a otro –o para ser exactos de un programa a otro, pudiendo ser de usuarios distintos– pero debido a la lentitud de la E/S interactiva7 los usuarios no perciben demora alguna. Los sistemas de tiempo compartido significaron un salto importante en complejidad por diversas razones: ●

Varios trabajos deben estar en memoria al mismo tiempo  el sistema operativo requiere mecanismos de gestión de la memoria y protección (véase el apartado 2.1.2).

●

Para tener un tiempo de respuesta razonable los trabajos en memoria deben poder ser guardados o recuperados desde el disco que sirve como almacenamiento de respaldo  el sistema operativo puede utilizar técnicas de memoria virtual (véase el apartado 4.5.1) para poder ejecutar trabajos que no están completamente cargados en memoria.

●

La CPU debe ser compartida entre los trabajos  el sistema operativo requiere mecanismos de planificación de la CPU (véase el apartado 3.4).

●

La ejecución de los trabajos debe ser ordenada  el sistema operativo debe proporcionar

6 A los sistemas que tienen esta funcionalidad se los denomina sistemas multiusuario. 7 La E/S interactiva incluye la salida de datos por pantalla y la entrada de datos utilizando dispositivos como el teclado, el ratón, etc. La velocidad de este tipo de E/S viene limitada por las capacidades humanas, por lo que hay que tener en cuenta que lo que para los humanos es rápido para una CPU resulta sumamente lento.

1-7

Sistemas Operativos - 2014/2015

1. Introducción

mecanismos de sincronización (véase el apartado 3.3.3) y comunicación (véase el apartado 3.2). ●

El sistema debe disponer de un sistema de archivos (véase el tema 5), que a su vez debe residir en un conjunto de discos  el sistema operativo requiere mecanismos de gestión de discos.

Las primeras versiones de UNIX –liberado por primera vez en 1970– el sistema operativo VMS –desarrollado en 1978– para los VAX de Digital Equipment Corportation y el IBM OS/400 –introducido en 1988– utilizado en los minicomputadores AS/400, son algunos ejemplos de sistemas operativos de tiempo compartido (véase el apartado 1.4.4).

1.3.2. Sistemas de escritorio Los sistemas de escritorio aparecieron en los primeros años de la década de 1970 y carecían de las características necesarias para ser multiusuario y multitarea. A diferencia de los sistemas de entonces, los sistemas operativos de escritorio actuales si tienen esas características pero se siguen diseñando con un objetivo diferente al de los mainframe. Como ya hemos comentado, mientras que en los sistemas de tiempo compartido y los multiprogramados se persigue maximizar la utilización eficiente de los recursos, en los sistemas de escritorio se debe maximizar la respuesta al usuario 8 y la facilidad de uso. Pese a estas diferencias los sistemas operativos de escritorio se han beneficiado del desarrollo de los sistemas operativos para mainframes. Por ejemplo, en un sistema diseñado para ser utilizado por un único usuario no tiene sentido implementar un sistema de archivos con permisos. Por eso los primeros sistemas operativos de escritorio carecían de esta característica, que ya existía en los mainframe de la época. Sin embargo, hoy en día los sistemas de escritorio son multiusuario e incluyen sistemas de archivos con permisos como medida de protección de los datos de los usuarios. Los ejemplos de este tipo de sistemas operativos van desde CP/M –lanzado en 1977– hasta los actuales GNU/Linux, Microsoft Windows 7 y Apple Mac OS X, pasando por MS-DOS, IBM OS/2 y las diversas versiones de Microsoft Windows (véase el apartado 1.4.5). 8 El tiempo de respuesta al usuario se puede considerar como el intervalo de tiempo entre un comando de un usuario –por ejemplo un click– y la respuesta del sistema a dicho comando. En ocasiones este tiempo se minimiza a costa de un uso menos eficiente de los recursos del sistema por lo que no es un objetivo deseable para diseñar un mainframe. Mas información en el tema 3.4.3.

1-8

1.3. Tipos de sistemas operativos

Sistemas Operativos - 2014/2015

1.3.3. Sistemas distribuidos En la actualidad es común el uso de redes –por ejemplo Internet o la red de área local de una oficina– para interconectar ordenadores individuales; cada uno equipado con su procesador, su memoria, sus dispositivos de almacenamiento, su fuente de alimentación, etc. En las redes de ordenadores los procesadores de dichos ordenadores se comunican con otros procesadores a través de líneas de comunicación, como redes Ethernet o líneas telefónicas. Estos sistemas son comúnmente denominados sistemas distribuidos.

a) Tipos de sistemas informáticos distribuidos Sin entrar en detalles los sistemas distribuidos pueden ser clasificados en dos grandes tipos: ●

En los sistemas cliente-servidor existen ordenadores que actúan como servidores encargados de satisfacer las peticiones generadas por otros ordenadores que actúan como clientes. Este tipo de sistemas ha ido sustituyendo a los terminales conectados a mainframes debido a que los sistemas de escritorio son cada vez más potentes y más baratos. Concretamente, los terminales han sido sustituidos por los sistemas de escritorio que, al disponer de más recursos, son capaces de realizar muchas de las funcionalidades que anteriormente eran manejadas directamente por los mainframes. Al mismo tiempo estos mainframes se han reemplazado por servidores, no muy diferentes a los sistemas de escritorios, pero preparados para atender las peticiones de sus clientes. Ejemplos de este este tipo de sistemas son los servidores de base de datos, que responden a las consultas SQL de los clientes, o los servidores de archivos, que proporcionan una interfaz de sistema de archivos con la que los clientes pueden crear, leer, escribir y borrar archivos en el servidor.

●

En los sistemas de redes entre iguales o P2P (peer-to-peer) clientes y servidores no se distinguen los unos de los otros. Todos los nodos del sistema son iguales y cada uno puede actuar como cliente y/o servidor dependiendo de cuando piden o proporcionan un servicio. La ventaja fundamental de este tipo de sistemas es que en los sistemas cliente-servidor el servidor es el cuello de botella9, pero en los sistemas de redes entre iguales la carga se distribuye entre los diversos nodos de la red. Ejemplos de este tipo de sistemas son las redes eDonkey y BitTorrent.

9 Un servidor puede ser el cuello de botella no solo por su potencia sino también por el ancho de banda de su conexión a la red. La potencia del servidor es lo de menos cuando se intenta distribuir en Internet archivos de gran tamaño –por ejemplo imágenes de CD o DVD– pues el problema es que varias descarga simultaneas pueden consumir todo el ancho de banda del servidor durante largos periodos de tiempo.

1-9

Sistemas Operativos - 2014/2015

1. Introducción

b) Sistemas operativos para sistemas distribuidos Desde el punto de vista de los sistemas operativos para sistemas distribuidos es necesario hacer la siguiente distinción: ●

Los sistemas operativos de red ofrecen a las aplicaciones que corren sobre ellos servicios de acceso a redes de ordenadores. Por ejemplo, implementan algún mecanismo que permita a diferentes procesos en diferentes ordenadores intercambiar mensajes. Además suelen incorporar la opción de proporcionar algunos servicios de red, como la compartición de archivos y dispositivos. Los ordenadores con sistemas operativos de red son autónomos, aunque conocen la existencia de la red y están en disposición de comunicarse con otros ordenadores de la misma. Este tipo de sistemas operativos son los más utilizados en los tipos de sistemas distribuidos comentados anteriormente.

●

Los sistemas operativos distribuidos crean en el usuario la ilusión de estar en un sólo ordenador, aunque en realidad el sistema operativo controla todos los ordenadores de la red dando al usuario acceso transparente a los recursos en todos los equipos de la misma. Con este tipo de sistemas operativos el usuario no sabe en que ordenador se ejecutan sus procesos, ni donde se almacenan sus archivos, ni que equipo tiene conectado los distintos periféricos a los que tiene acceso. Un ejemplo de sistema operativo distribuido es Amoeba10.

1.3.4. Sistemas de tiempo real Se utilizan cuando tenemos requerimientos rígidos de tiempo en la ejecución de las tareas o en el procesamiento de flujos de datos. Por lo tanto, se usa frecuentemente en dispositivos de control dedicados a una tarea específica; dónde se deben tomar datos de uno o varios sensores, para posteriormente analizar dichos datos y accionar algún mecanismo de control dentro de unos márgenes rígidos de tiempo. Los sistemas de tiempo real se suelen utilizar en: algunos sistemas de control industrial, domótica, armamento, la inyección electrónica de combustible en los automóviles, el procesamiento de imágenes médicas, etc.. Los sistema de tiempo real están muy relacionados con los sistemas empotrados. Estos sistemas están tanto en el motor de los automóviles y los robots que los fabrican, como en reproductores de

10 Amoeba es un sistema operativo de investigación distribuido de estructura microkernel (véase el apartado 2.3.3) escrito por Andrew S. Tanenbaum en Vrije Universiteit. Más información en http://www.cs.vu.nl/pub/amoeba/.

1-10

1.3. Tipos de sistemas operativos

Sistemas Operativos - 2014/2015

DVD, microondas, etc. Los sistemas empotrado realizan tareas muy específicas, sus sistemas operativos tienen características muy limitadas y no suelen tener interfaz de usuario. Los sistemas de tiempo real pueden ser clasificados en sistemas de tiempo real estricto y sistemas de tiempo real flexible: ●

Los sistemas de tiempo real estricto o hard real-time garantizan que las tareas serán realizadas dentro de unos márgenes estrictos de tiempo. Para ello todos los imprevistos que puedan ocasionar retardos en el funcionamiento del sistema operativo deben estar perfectamente limitados en tiempo. Por lo tanto, la memoria virtual y otras facilidades que abstraen del funcionamiento real del hardware no están presentes en este tipo de sistemas porque introducen impredecibilidad. Los sistemas de tiempo real estricto no son compatibles con los sistemas de tiempo compartido.

●

Los sistemas de tiempo real flexible o soft real-time son útiles cuando hay tareas que tienen mayor importancia que el resto por lo que deben ser realizadas con mayor prioridad y esta prioridad debe ser conservada hasta que terminan. El tiempo real flexible no sirve cuando se tienen tareas con limitaciones precisas de tiempo porque no hay manera de garantizar que dichas restricciones se van a cumplir. Sin embargo si es útil para tareas relacionadas con la multimedia, la realidad virtual, etc. Este tipo de tiempo real está disponible en la mayor parte de los sistemas operativos de propósito general pues es compatible con la memoria virtual y otras facilidades propias de los sistemas de tiempo compartido.

1.3.5. Sistemas de mano Los sistemas de mano incluyen a los tablets, lectores de libros electrónicos y teléfonos móviles. Los desarrolladores de sistemas de mano y aplicaciones para estos sistemas deben enfrentarse a diversos desafíos. Muchos de ellos vienen originados por el tamaño limitado de los dispositivos y la alimentación mediante el uso de baterías. Debido a esas limitaciones muchos sistemas de mano tienen poca cantidad de memoria, procesadores lentos y pantallas pequeñas.

1.4. Historia de los sistemas operativos La historia de los sistemas operativos se puede dividir en 5 grandes etapas o generaciones.

1-11

Sistemas Operativos - 2014/2015

1. Introducción

1.4.1. 1ª Generación (1945-55) a) Características ●

Sin sistema operativo.

●

Sólo hardware, sin lenguajes de programación.

b) Ejemplos ●

Mainframe IBM 701 y 704.

1.4.2. 2ª Generación (1955-64) a) Características ●

Sistemas operativos de procesamiento por lotes.

●

Sistema operativo básico. Se utilizan lenguajes de programación.

b) Ejemplos ●

El primer sistema operativo fue desarrollado por General Motors Research Laboratory en 1956 para su mainframe IBM 701 (véase la Figura 1.4) con el fin de automatizar la carga de los trabajos.

1.4.3. 3ª Generación (1965-1968) a) Características ●

Sistemas operativos multiprogramados.

●

Más lenguajes de programación y multiprogramación.

b) Ejemplos ●

1-12

IBM OS/360. Desarrollado por IBM para su mainframe System/360.

1.4. Historia de los sistemas operativos

Sistemas Operativos - 2014/2015

Figura 1.4: Instalación de un mainframe IBM 702.

○

Fue el primero en hacer los dispositivos de almacenamiento de acceso aleatorio un requisito para poder operar.

○

Anunciado en 1964, fue liberado en 1966 con un año de retraso. Los motivos fundamentales fueron ciertos problemas de organización interna de la compañía y la falta de experiencia en proyectos de tal envergadura, pues las previsiones iniciales eran de 1 millón de líneas de código y miles de componentes de software. La experiencia negativa del desarrollo del IBM OS/360 condujo al nacimiento de la ingeniería del software.

1.4.4. 4ª Generación Esta generación abarca desde mediados de los años 60 hasta finales de la década de los 70.

a) Características ●

Sistemas operativos de tiempo compartido.

●

Aparecen los programas interactivos y las máquinas virtuales.

1-13

Sistemas Operativos - 2014/2015

1. Introducción

Figura 1.5: Mainframe GE-6180 con sistema operativo MULTICS (MIT ca. 1976)

b) Ejemplos ●

MULTICS. Fue anunciado en 1964 como el primer sistema operativo de propósito general fruto de la colaboración entre el MIT, General Electrics y Bell Labs (véase la Figura 1.5). ○

Primer sistema operativo en proporcionar un sistema de archivos jerárquico, un intérprete de comandos implementado como programa de usuario, listas de control de acceso individuales para cada archivo, enlazado dinámico, etc.

1-14

1.4. Historia de los sistemas operativos ○

Sistemas Operativos - 2014/2015

Eliminó la separación entre el espacio de direcciones de los procesos y los archivos. En un sistema moderno eso sería como si cada archivo estuviera mapeado en memoria (véase el apartado 4.5.6).

●

VM/CMS. Es un sistema de IBM utilizado en los mainframe System/360, System/370, System/390 y zSeries. ○

El desarrollo comenzó en 1965 y la primera versión estuvo disponible a primeros de 1966.

○

VM es una máquina virtual que proporciona a cada usuario la sensación de tener su propio mainframe personal.

○

CMS es un sistema monousuario diseñado para operar fundamentalmente encima de VM.

Figura 1.6: Miniordenador DEC PDP-7.

1-15

Sistemas Operativos - 2014/2015 ●

1. Introducción

UNIX. Desarrollado originalmente por Bell Labs en 1970 para los sistemas PDP-11/20. ○

La autoría del mismo se le atribuye a un grupo de programadores, liderados por Ken Thompson, que decidieron rehacer el trabajo de MULTICS pero a menor escala después de que Bell Labs abandonara el proyecto en 1969. Inicialmente se llamó UNICS y fue desarrollado para los sistemas PDP-7 (véase la Figura 1.6).

○

La primer versión, como muchos otros sistemas operativos anteriores, estaba implementada en ensamblador. Dennis Ritchie y Brian Kernighan diseñaron un nuevo lenguaje llamado «C» especialmente pensado para que UNIX fuera escrito con él. Eso permitió que UNIX pudiera ser modificado fácilmente para funcionar en otros ordenadores. Además el código era más conciso y compacto, lo que se tradujo en el aumento de la velocidad de desarrollo de UNIX.

○

AT&T, la compañía matriz de Bell Labs, no podía competir en la industria de los ordenadores por lo que puso el código fuente de UNIX a disposición de universidades, compañías privadas y del gobierno de los Estados Unidos.

○

Una de las más importantes versiones de UNIX fue desarrollada por la Universidad de California en Berkeley. Esta versión implementaba el estándar de comunicaciones TCP/IP, el cual permitió convertir la cerrada ARPANET en la abierta Internet.

○

En la actualidad se puede considerar que hay dos grandes familias de UNIX. Por un lado AT&T UNIX System V, del que derivan sistemas tales como SCO OpenServer, Oracle/Sun Microsystems Solaris Operating Environment y SCO UnixWare. Y por el otro, BSD11 del que derivan FreeBSD, NetBSD, OpenBSD, Darwin y DragonFly BSD, entre muchos otros.

●

VMS. Es un sistema operativo diseñado originalmente por Digital Equipment Corporation –ahora propiedad de HP– en 1978 para operar en sistemas VAX. Posteriormente fue portado a sistemas DEC Alpha e Intel Itanium.

●

IBM OS/400. Es un sistema utilizado en la familia IBM AS/400 –ahora llamada iSeries–. ○

OS/400 y AS/400 fueron introducidos en el mercado en 1988.

○

La familia IBM AS/400 es una familia de minicomputadores. Este termino en desuso

11 La siglas BSD provienen de Berkeley Software Distribution.

1-16

1.4. Historia de los sistemas operativos

Sistemas Operativos - 2014/2015

hace referencia a máquinas multiusuario de rango medio, entre los mainframes y los sistemas de escritorio.

1.4.5. 5º Generación (años 1980, 1990 y 2000): Esta generación abarca desde la década de los 80 hasta la actualidad.

a) Características ●

Sistemas operativos de escritorio y ordenadores personales (PC)12.

●

Monousuario, multitarea, sistemas distribuidos, sistemas paralelos, sistemas de tiempo real, etc.

b) Ejemplos ●

CP/M. Sistema operativo estándar para la primera generación de microcomputadores13. ○

Creado por Digital Research, Inc., fundada por Gary Kildall, para ser el sistema operativo de los microordenadores basados en Intel 8080/85 y Zilog Z80.

○

La combinación del CP/M junto al bus S-100 en el MITS Altair 8800 14 fue el primer estándar industrial.

●

MS-DOS. Sistema operativo estándar para la segunda generación de microcomputadores. ○

Fue el primer sistema operativo del IBM PC –lanzado en 1981– y durante mucho tiempo fue ampliamente utilizado en la plataforma PC compatible. No era ni multitarea ni multiusuario.

○

MS-DOS fue creado por Seattle Computer Products con el nombre de 86-DOS, pero era comúnmente conocido como QDOS (Quick and Dirty Operating System). Microsoft adquirió el sistema y lo vendió a IBM con el nombre de MS-DOS.

○

Tanto IBM como Microsoft lanzaron versiones de DOS, aunque originalmente IBM

12 Se puede observar una muestra de la interfaz gráfica de usuario de algunos estos sistemas en http://goo.gl/0fFLN 13 Una microcomputadora es un ordenador que tiene un microprocesador. La primera generación de microcomputadoras también fue conocida como computadoras domésticas. 14 El MITS Altair 8800 fue un microcomputador diseñado en 1975 basado en el procesador Intel 8080A. Hoy en día es considerado el primer ordenador personal de la historia. Su bus de sistema, el S-100, se convirtió en un estándar de facto y su primer lenguaje de programación fue el producto que ayudó a fundar Microsoft, el Altair BASIC.

1-17

Sistemas Operativos - 2014/2015

1. Introducción

solamente validaba y empaquetaba el software de Microsoft. Microsoft liberaba sus versiones bajo el nombre de «MS-DOS», mientras IBM las liberaba bajo el nombre de «PC-DOS». ●

OS/2. Sistema operativo creado por Microsoft e IBM y posteriormente desarrollado por IBM en exclusiva. Se creó como el sistema operativo predilecto para la segunda generación de ordenadores personales de IBM, equipados con procesador Intel 80286. ○

OS/2 fue pensado como un sucesor con operación en modo dual (véase el apartado 2.2.1) de MS-DOS y Microsoft Windows 2.0.

○

OS/2 1.0 fue anunciado en abril y liberado en diciembre de 1987 como un sistema operativo en modo texto. La interfaz gráfica de usuario prometida –denominada Presentation Manager– se introdujo en la versión 1.1 en noviembre de 1988.

○

La colaboración entre IBM y Microsoft terminó en 1990 entre la liberación de Windows 3.0 y la de OS/2 1.3. El aumento de popularidad de Windows llevo a Microsoft a dejar de centrarse en el desarrollo de OS/2, lo que llevó a IBM a preocuparse por los continuos retrasos en el desarrollo de OS/2 2.0. Inicialmente ambas compañías acordaron que IBM tomaría el mantenimiento de OS/2 1.0 y el desarrollo de OS/2 2.0, mientras Microsoft continuaría desarrollando OS/2 3.0, que entonces era conocido como «NT OS/2». Sin embargo, finalmente Microsoft decidió renombrar NT OS/2 como Windows NT, dejando el futuro desarrollo de OS/2 en manos de IBM.

○

OS/2 Warp 3, liberado en 1994, fue un sistema completo de 32-bit.

○

OS/2 Warp 4, fue liberado en 1996. Poco después de su lanzamiento IBM anunció que OS/2 desaparecería.

●

Windows 3.x. La familia Windows 3.x de Microsoft Windows fue desarrollada desde 1990 hasta 1994. La 3.0 fue la primera versión de éxito de Windows, permitiendo a Microsoft competir con el Macintosh de Apple Computer y el Commodore Amiga. ○

En 1983 Microsoft anuncia el desarrollo de Windows, una interfaz gráfica de usuario para su propio sistema MS-DOS, que estaba disponible para los IBM PC y compatibles desde 1981.

○

Windows 3.x requería una instalación previa de MS-DOS y era iniciado como un programa más, que podía ser terminado en cualquier momento devolviendo al usuario a

1-18

1.4. Historia de los sistemas operativos

Sistemas Operativos - 2014/2015

la linea de comandos del MS-DOS. Este sistema operativo le proporcionaba a Windows controladores de dispositivo para ciertas tareas, como el acceso al CD-ROM o a la interfaz de red. Sin embargo, Windows necesitaba de aplicaciones especificas, almacenadas en un formato ejecutable mucho más complejo que el de los programas de MS-DOS. Además, debido a que MS-DOS no aislaba a las aplicaciones del hardware y no se protegía así mismo de los errores en dichas aplicaciones, Windows disponía de múltiples controladores de dispositivo propios, así como su propio sistema de gestión de la memoria. Es decir, que Windows realmente no se ejecutaba sobre MS-DOS sino que hacía uso de él. Por ello puede ser considerado un sistema operativo. ●

Windows 95, 98, Me. Sistemas operativos híbridos gráficos de 16-bit/32-bit sucesores de Windows 3.x. ○

Windows 95, liberado en 1995, fue el primer Windows unido a una versión de MS-DOS específica; aunque este hecho se intentaba mantener oculto. Entre las características de Windows 95 se pueden destacar: mejoras significativas en la interfaz de usuario, nombres de archivo de hasta 256 caracteres con conservación de mayúsculas y minúsculas y multitarea expropiativa (véase el apartado 3.4.1) para las aplicaciones de 32-bit.

○

Windows 98 fue liberado el 25 de junio de 1998.

○

Windows Me, liberado el 14 de septiembre de 2000, fue la última versión de la familia de sistemas operativos híbridos de 16-bit/32-bit que sucedió a Windows 3.1.

●

Windows NT. Sistema operativo de 32-bit antecesor del actual Windows 7. ○

Su desarrollo empezó en 1988 con el nombre de OS/2 3.0. Cuando Windows 3.0 fue liberado en mayo de 1990 tuvo tanto éxito que Microsoft decidió cambiar la API 15 del aún en desarrollo NT OS/2 –como era conocido en la época– pasando de ser una versión extendida de la API de OS/2 a una versión extendida de la API de Windows. Esta decisión causó tensión entre Microsoft e IBM y provocó que finalmente la colaboración terminara.

○

Microsoft contrató a un grupo de desarrolladores de Digital Equipment Corporation para

15 Una interfaz de programación de aplicaciones o API (del inglés application programming interface) es el conjunto de funciones, procedimientos o métodos que ofrece el sistema operativo para ser utilizado por las aplicaciones.

1-19

Sistemas Operativos - 2014/2015

1. Introducción

crear Windows NT, por lo que muchos de sus elementos reflejan la experiencia anterior de DEC en VMS. ○

Las API soportadas por Windows NT –por ejemplo Win32, POSIX y OS/2 2.1– son implementadas como subsistemas encima de un API nativo públicamente no documentado. Esta estructura en subsistemas fue lo que permitió la adopción tardía de la API de Windows, tal y como hemos comentado anteriormente.

○

Windows NT 3.1 –la primera versión de Windows NT, liberada el 13 de julio de 1993– era un sistema operativo microkernel (véase el apartado 2.3.3) multiplataforma que corría sobre procesadores Intel IA-32, DEC Alpha, MIPS R4000 y PowerPC.

○

Windows NT 4.0 fue la última versión en soportar plataformas distintas a Intel IA-32. Aunque el desarrollo de Windows 2000 para Alpha continuó hasta 1999, cuando Compaq dejó de soportar Windows NT en esa arquitectura. Además Windows NT 4.0 integró en el núcleo más funciones –por ejemplo parte del subsistema gráfico– para obtener mayor rendimiento.

●

Windows 2000, XP, Vista, 7. Sistemas operativos sucesores de Windows NT. ○

Windows 2000 –o Windows NT 5.0, liberado el 17 de febrero de 2000– fue el primer sistema operativo de la familia NT al que se le eliminaron las siglas del nombre por motivos de marketing. El objetivo era favorecer la unificación de las dos familias de sistemas operativos Windows –Windows 9x y Windows NT– alrededor de la tecnología NT.

○

Windows XP –o Windows NT 5.1– completó el proceso de unificación de las dos familias de sistemas operativos Windows, forzando la extinción de la familia Windows 9x al sustituirla con una versión de Windows XP, denominada Windows XP Home Edition, específica para la informática doméstica.

●

GNU/Linux. Se trata del más famoso ejemplo de software libre y de desarrollo de fuente abierta. ○

El proyecto GNU se inició en 1983 con el fin de desarrollar un sistema operativo estilo UNIX, incluyendo herramientas de desarrollo de software y aplicaciones de usuario, hecho enteramente de software libre.

○

1-20

El núcleo Linux fue inicialmente escrito como hobby por el estudiante universitario finés

1.4. Historia de los sistemas operativos

Sistemas Operativos - 2014/2015

Linus Torvalds mientras estudiaba en la Universidad de Helsinki. Torvalds originalmente usaba Minix, un sistema operativo simplificado escrito por Andrew Tanenbaum para enseñar diseño de sistemas operativos. Sin embargo, el hecho de que Tanenbaum no diera soporte a las mejoras de su sistema operativo introducidas por otros desarrolladores, llevó a Torvalds a escribir un sustituto de Minix. ○

En 1991, cuando se liberó la primera versión del núcleo Linux, el proyecto GNU había desarrollado todos los componentes necesarios del sistema excepto el núcleo. Torvalds y otros desarrolladores rápidamente adaptaron Linux para que funcionara con los componentes de GNU, creando un sistema operativo completamente funcional.

○

El núcleo fue licenciado bajo la GNU General Public License (GPL) pero no es parte del proyecto GNU. El proyecto GNU tiene su propio kernel denominado Hurd, pero sigue en desarrollo.

●

Mach. Es un núcleo de sistema operativo desarrollado en la Universidad Carnegie-Mellon (CMU). El proyecto en CMU se desarrolló desde 1985 hasta 1994. ○

Mach explora el concepto que denominamos como microkernel (véase el apartado 2.3.3).

○

En algún momento se pensó que Mach podría dominar el universo de los sistema operativos debido a las ventajas de los sistemas microkernel. El mayor esfuerzo para conseguirlo hasta la fecha es GNU/Hurd pero lleva más de una década de retraso. Sin embargo, otros sistemas operativos microkernel han tenido más éxito, como es el caso de QNX.

○

Apple Computers seleccionó OpenStep como base para el sucesor de su clásico Mac OS. OpenStep es realmente una versión actualizada de NeXTSTEP, que era un sistema basado en un núcleo Mach 2.5 con porciones del sistema BSD de la Universidad de Berkeley. Por lo tanto, la mezcla de Mach con BSD16 de OpenStep es la base del sistema operativo Mac OS X de Apple.

16 A la base del sistema operativo Mac OS X se la denomina Darwin. Concretamente se trata de un sistema FreeBSD portado para correr sobre el núcleo Mach.

1-21

1956

Sin sistema operativos ni lenguajes de programación

1964

1964

Uso de lenguajes de programación

Sistemas operativos de procesamiento por lotes

2ª Generación

1955

1976

Sistemas operativos de tiempo compartido

4ª Generación

1994

Windows NT 3.1 Llamado NT OS/2 hasta que IBM abandonó el proyecto al Microsoft sustituir la API OS/2 por la API Win32.

1993

OS/2 3.0 Sistemas operativo de IBM de 32bits.

Monousuario y multiusuario, multitarea, sistemas distribuidos, sistemas en cluster, sistemas de tiempo real, etc.

Sistemas de escritorio

Más lenguajes de programación, multiprogramación

1995

Windows 95 Familia de sistemas operativos híbridos de 16/32bits.

Sistemas operativos multiprogramados

1980

MS-DOS S.O. del IBM PC.

1981

Proyecto GNU Proyecto de software libre.

1983

Mach Núcleo microkernel de la CMU.

1985

2001

Windows XP Su versión Home extinguió la familia de Windows 9x.

5ª Generación

Hay programas interactivos y máquinas virtuales

1968

UNIX BSD

UNIX System V

Digital VMS Para VAX.

1978

OS/2 Sistema de 16bits pensado como sucesor de MS-DOS

1988

Linux El núcleo libre más utilizado con el proyecto GNU.

3ª Generación

1965

UNIX

1970

1991

GNU Hurd Núcleo del proyecto GNU.

IBM OS/360 Nace la ingeniería del software.

1966

CP/M S.O. de la 1ª generación de micro ordenadores.

Multics Primer sistema de propósito general.

Primer sistema operativo. General Motors Research Laboratory. Para IBM 701.

1ª Generación

1945

Mainframe IBM 701

1952

2. Estructura de los sistemas operativos

2.1. Organización de los sistemas operativos El estudio de la organización interna de los sistemas operativos requiere del análisis de tres aspectos diferentes: 1. Los componentes del sistema operativo y sus interconexiones (véase el apartado 2.1.2). 2. Los servicios que el sistema operativo proporciona a través del funcionamiento coordinado de dichos componentes (véase la Figura 2.1). 3. La interfaz de programación que el sistema operativo ofrece a usuarios y programadores como forma de acceso a dichos servicios. El estudio de los componentes del sistema operativo lo dejaremos para más adelante, tras ver la forma usual en la que los programas acceden a los servicios del sistema operativo y, por tanto, en la que se comunican indirectamente con dichos componentes. Respecto a los servicios que el sistema operativo proporciona, no entraremos en ello puesto que cada uno ofrece servicios diferentes, aunque siempre es posible identificar unos pocos tipos comunes a todos.

2.1.1. Interfaz de programación de aplicaciones Un sistema operativo proporciona un entorno controlado para la ejecución de programas. Dicho

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

aplicaciones

interfaz de programación de aplicaciones servicio de ejecución de programas

gestor de procesos

gestor de memoria

servicio de operaciones de E/S

servicio de operaciones con la memoria

servicio de manipulación de archivos

gestor de E/S

gestor del almacenamiento secundario

gestor del sistema de archivos

hardware

Figura 2.1: Diagrama general de organización de los sistemas operativos.

entorno debe proporcionar ciertos servicios que pueden ser accedidos por los programas a través de una interfaz de programación de aplicaciones o API (Application Programming Interface). Algunas de las APIs disponibles para los desarrolladores de aplicaciones son la API Win32 –en sistemas Microsoft Windows– y la API POSIX para sistemas compatibles POSIX 17 –como es el caso de los diferentes UNIX, Linux y Mac OS X–. Concretamente, junto a cada interprete o compilador de un lenguaje de programación suele ir una librería estándar que ofrece clases y/o funciones con las que los programas pueden acceder a los servicios del sistema operativo y realizar las tareas más comunes. Estas librerías generalmente no forman parte del sistema operativo, sino de las herramientas de desarrollo de cada lenguaje de programación, y constituyen la interfaz de programación de aplicaciones del lenguaje al que acompañan. Las librerías estándar necesitan acceder a los servicios del sistema operativo para, a su vez, dar servicio a los programas que las usan. Es decir, cuando un programa invoca alguna función o método de la librería estándar que lo acompaña, es muy probable que ésta necesite invocar uno o más servicios del sistema operativo para atender la petición convenientemente. Para ello las 17 POSIX (Portable Operating System Interface for Unix) es el nombre de una familia de estándares que definen una interfaz de programación de aplicaciones para sistemas operativos. Esto permite que un mismo programa pueda ser ejecutado en distintas plataformas, siempre que sean compatibles con POSIX. La práctica totalidad de los sistemas UNIX modernos son compatibles POSIX ya que la especificación deriva de la interfaz típica de ese tipo de sistemas.

2-24

2.1. Organización de los sistemas operativos

Sistemas Operativos - 2014/2015

librerías estándar utilizan la librería del sistema –o librerías del sistema, en el caso de que hayan varias– que acompaña al sistema operativo. La librería del sistema si forma parte del sistema operativo y contiene un conjunto de clases y/o funciones –generalmente más primitivas que las de la librería estándar de los lenguajes de programación– que los programas deben utilizar para acceder a los servicios del sistema operativo. Es decir, la librería del sistema constituye la interfaz de programación de aplicaciones del sistema operativo. Es muy común que esta interfaz esté implementada para ser usarla con programas en lenguaje C, lo que permite que tanto los programas en C como en C++ la puedan utilizar directamente. Sin embargo con otros lenguajes de programación esto no suele ser posible, por lo que no queda más remedio que acceder a los servicios del sistema operativo a través de la librería estándar del lenguaje en cuestión. Algunos de los servicios ofrecidos pueden ser implementados en la propia librería del sistema pero en la mayor parte de los casos ésta debe solicitar dichos servicios al resto del sistema operativo. La librería del sistema, al igual que la estándar y otras librerías utilizadas por el programa, se cargan dentro de la región de memoria asignada al proceso donde se ejecuta el programa que las utiliza. Por lo tanto, la invocación de sus métodos y funciones se realiza como si fueran cualquier otro método o función del programa. Sin embargo el código del núcleo del sistema operativo suele estar en una ubicación diferente que, desde el punto de vista de los programas, no es conocida y generalmente está protegida frente a accesos indebidos (véase el apartado 2.2.2). Eso significa que

# # Fragmento de código para escribir SIZE bytes desde la dirección BUFFER al # archivo con el descriptor FILEDES. # # Prototipo en C de la llamada al sistema write() # # ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE) # #

... lw la lw li syscall

#

...

$a0,FILEDES $a1,BUFFER $a2,SIZE $v0,4

# # # # # # #

cargar FILEDES cargar BUFFER cargar SIZE cargar id. de la llamada write() llamar al sistema v0 contiene el valor de retorno que es el número de bytes escritos

Figura 2.2: Llamada al sistema en Linux MIPS.

2-25

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

para que la librería del sistema invoque los servicios que necesita hace falta un procedimiento diferente, al que se le denomina llamada al sistema. Las llamadas al sistema proporcionan una interfaz con la que los procesos pueden invocar los servicios que el sistema operativo ofrece. Estas llamadas están habitualmente disponibles como instrucciones en lenguaje ensamblador (véase la Figura 2.2) pero generalmente los programas no las utilizan directamente sino que emplean la interfaz ofrecida por la librería del sistema, que su vez se implementa mediante invocaciones a las llamadas al sistema. En la Figura 2.3 se ilustra el papel de todos los elementos comentados con el ejemplo de un programa en C++ que invoca el método std::ofstream::open(): 1. El programa invoca el método std::ofstream::open() de la librería estándar de C++ para abrir un archivo determinado. 2. La librería estándar utiliza la librería de sistema, de la que invoca a varias funciones, para realizar la tarea encomendada. Entre las funciones llamadas está fopen(), que se utiliza para abrir el archivo indicado.

sistema operativo

llamada al sistema

fopen() ··· int fd = syscall(__NR_open, filename, ...); ···

librería del sistema (glibc)

std::ofstream::open() ··· FILE *f = fopen(filename, ...); ···

ofstream ofs; ofs.open(filename);

librería estándar de C++ (libstdc++)

programa en C++

proceso

Figura 2.3: Elementos de la interfaz de programación de aplicaciones en GNU/Linux.

2-26

2.1. Organización de los sistemas operativos

Sistemas Operativos - 2014/2015

3. La librería del sistema utiliza los servicios del sistema operativo, expuestos mediante la interfaz de llamadas al sistema, para realizar la tarea encomendada por la invocación de fopen(). Entre las llamadas al sistema utilizadas está open, que le dice al sistema operativo

que deseamos abrir el archivo indicado. 4. Al realizar la llamada el sistema operativo toma el control deteniendo la ejecución del proceso que la solicita. Entonces se realiza la tarea mediante el funcionamiento coordinado de los diferentes componentes del sistema (véase el apartado 2.1.2).

a) Invocación de las llamadas al sistema Generalmente una llamada al sistema se invoca mediante una instrucción específica en lenguaje ensamblador que genera una excepción18 –por ejemplo la instrucción int 80 en la Figura 2.2– que es capturada por el sistema operativo, deteniendo la ejecución del proceso que la invocó. Cuando se realiza la llamada es necesario que el proceso identifique la operación que quiere que se realice. Esto se suele hacer poniendo un número identificativo de la llamada en un registro concreto de la CPU. Por ejemplo, el número de la llamada al sistema open del ejemplo de la Figura 2.3 es 219. Sin embargo, una llamada al sistema suele requerir más información que simplemente la identidad de la llamada. Si por ejemplo se quisiera leer un bloque de datos desde un almacenamiento secundario, al menos se debería indicar el archivo o dispositivo desde el que se desea realizar la lectura, así como la dirección y tamaño de la región de la memoria donde se quiere que los datos sean copiados. En concreto hay tres métodos para pasar parámetros a una llamada al sistema: ●

En el paso de parámetros por registros se cargan los parámetros de la llamada al sistema en los registros de la CPU antes de realizar la llamada. Este método es el más eficiente, pero limita el número de parámetros al número de registros disponibles en la CPU. Es utilizado, por ejemplo, en Linux para IA-3220 cuando la llamada al sistema tiene menos de seis parámetros (véase la Figura 2.2).

●

En el paso de parámetros por tabla en memoria se copian los parámetros de la llamada al

18 Una excepción es una interrupción generada por software, que puede ser debida a un error –por ejemplo una división por cero o un acceso no válido a memoria– o a una llamada al sistema de un proceso para que se ejecute un servicio del sistema operativo. 19 En GNU/Linux se puede conocer el número correspondiente a cada llamada al sistema soportada por el núcleo consultado el listado del archivo /usr/include/asm/unistd.h. 20 IA-32 (Intel Architecture, 32-bit), conocida en la actualidad de manera genérica como x86 o i386, es la arquitectura del conjunto de instrucciones de los procesadores Intel de 32 bits. Concretamente es una extensión de 32 bits, implementada por primera vez en el Intel 80386, para la arquitectura x86 original de 16 bits.

2-27

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

sistema en una tabla en memoria, de manera que la dirección de dicha tabla debe ser cargada en un registro de la CPU antes de la llamada al sistema. Evidentemente no limita el número de parámetros que pueden ser pasados a una llamada al sistema. Por ejemplo, es utilizado en Linux IA-32, cuando la llamada al sistema tiene más de cinco parámetros, y en Microsoft Windows. ●

En el paso de parámetros por pila se insertan los parámetros de la llamada al sistema en la pila del proceso. En este caso el sistema operativo es el encargado de extraer los parámetros de la pila durante la llamada al sistema. Al igual que en el caso anterior tampoco se limita el número de parámetros que pueden ser pasados. Es utilizando, por ejemplo, en FreeBSD.

En cualquier caso, sea cual sea el método utilizado, el sistema operativo debe comprobar de manera estricta los parámetros pasados en la llamada al sistema antes de realizar cualquier operación, puesto que nunca debe confiar en que los procesos hagan su trabajo correctamente. A fin de cuentas una de las funciones del sistema operativo es el control de dichos procesos.

2.1.2. Componentes del sistema Como ya hemos comentado en diversas ocasiones en este tema, el sistema operativo ofrece una serie de servicios a través del funcionamiento coordinado de los diferentes componentes que lo forman. A fin de cuentas, crear un software tan complejo como un sistema operativo no es sencillo, por ello resulta más práctico dividirlo en piezas más pequeñas especializadas en aspectos concretos de la gestión del sistema.

a) Gestión de procesos La gestión de los procesos es un elemento central de todo sistema operativo ya que el proceso es la unidad de trabajo en cualquier sistema operativo moderno: ●

Un proceso puede ser considerado como un programa en ejecución, es decir, cuando las instrucciones del programa son ejecutadas por una CPU. Un proceso es un entidad activa que necesita recursos –CPU, memoria, archivos, E/S– que se le asignan cuando es creado o cuando lo solicita durante la ejecución. Cuando el proceso termina el sistema operativo reclama de estos recursos aquellos que sean reutilizables.

●

Un programa no es un proceso, es una entidad pasiva; como el contenido de un archivo en disco con las instrucciones que algún día una CPU ejecutará. Un programa no puede hacer

2-28

2.1. Organización de los sistemas operativos

Sistemas Operativos - 2014/2015

ningún tipo de trabajo a menos que sus instrucciones sean ejecutadas por una CPU pero si eso ocurre, ya no sería un programa sino un proceso. ●

La CPU ejecuta las instrucciones de cada proceso una detrás de otra, de manera que para conocer la siguiente instrucción a ejecutar cada proceso tiene un contador de programa que se lo indica a la CPU. Por tanto, aunque dos procesos estén asociados al mismo programa no pueden ser considerados el mismo proceso, ya que la secuencia de ejecución de instrucciones puede ser distinta al tener cada uno un contador de programa independiente.

Por el momento estamos considerando que proceso y trabajo (véase el apartado 1.3.1) hacen referencia al mismo concepto. Sin embargo más adelante veremos que el segundo es mucho más general que el primero puesto que un proceso puede colaborar con otros procesos para desarrollar un trabajo determinado (véase el apartado 3.1.7).

Responsabilidades de la gestión de procesos El sistema operativo es responsable de la siguientes actividades relacionadas con la gestión de procesos: ●

Crear y terminar procesos.

●

Suspender y reanudar los procesos.

●

Proporcionar mecanismos para la sincronización de procesos.

●

Proporcionar mecanismos para la comunicación entre procesos.

●

Proporcionar mecanismos para el tratamiento de interbloqueos.

b) Gestión de la memoria principal La memoria principal es un recurso fundamental para las operaciones de cualquier sistema operativo moderno. Esto es así porque generalmente es el único almacenamiento al que la CPU tiene acceso directo, por lo que para que un programa pueda ser ejecutado debe ser copiado a la memoria principal. Además sirve de zona de intercambio de datos entre la CPU y los dispositivos de E/S. Por ejemplo, para que la CPU pueda procesar los datos de un archivo en disco, éstos primero deben ser transferidos a la memoria principal. Para mejorar el aprovechamiento de la CPU y la respuesta al usuario es necesario tener copiados varios programas en la memoria al mismo tiempo. Puesto que dichos programas deben compartir la 2-29

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

memoria existe automáticamente la necesidad de que el sistema operativo disponga de un componente de gestión de la memoria principal.

Responsabilidad de la gestión de la memoria El componente de gestión de la memoria debe asumir las siguientes responsabilidades: ●

Controlar qué partes de la memoria están actualmente en uso y cuáles no.

●

Decidir que procesos añadir o extraer de la memoria cuando hay o falta espacio en la misma.

●

Asignar y liberar espacio de la memoria principal según sea necesario.

c) Gestión del sistema de archivos Los ordenadores pueden almacenar información en diferentes tipos de medios físicos –por ejemplo en discos magnéticos, en CD/DVD-ROM, en memorias de estado sólido, etc.– cada uno de los cuales tiene características propias. El acceso a cada tipo medio es controlado por un dispositivo –por ejemplo el controlador de disco, la unidad de CD-ROM, etc.– que también tiene características propias. Para simplificar todo esto el sistema operativo proporciona una visión lógica uniforme de todos los sistemas de almacenamiento. Es decir, abstrae las propiedades físicas de los dispositivos de almacenamiento para definir una unidad de almacenamiento lógico, el archivo. Un archivo o fichero es una colección de información relacionada definida por su creador –por ejemplo programas, imágenes, datos–. Los archivos normalmente se organizan en directorios para facilitar su uso.

Responsabilidades de la gestión del sistema de archivos El sistema operativo es responsable de la siguientes actividades relacionadas con la gestión del sistema de archivos: ●

Crear y borrar archivos.

●

Crear y borrar directorios para organizar los archivos.

●

Soportar primitivas21 para la manipulación de archivos y directorios.

●

Mapear en memoria archivos del almacenamiento secundario.

21 El término primitivas hace referencia a funciones que realizan operaciones muy básicas. Estas operaciones básicas pueden ser combinadas para realizar operaciones más complejas.

2-30

2.1. Organización de los sistemas operativos ●

Sistemas Operativos - 2014/2015

Copias de seguridad de los archivos en sistemas de almacenamiento estables y seguros.

d) Gestión del sistema de E/S El sistema de E/S oculta las peculiaridades del hardware al resto del sistema. El sistema de E/S consta de: ●

Un componente de gestión de memoria con soporte para servicios de buffering22, caching23 y spooling24. Estos servicios son habitualmente utilizados por el resto del sistema de E/S.

●

Una interfaz genérica de acceso a los controladores de dispositivo. Esta interfaz genérica hace que el acceso de los procesos a los dispositivos sea a través de una interfaz similar, sin importar las particularidades de cada dispositivo. Por ejemplo, una característica de los sistemas UNIX es que cada dispositivo de E/S se representa como un archivo en el sistema de archivos. Esto permite que los procesos utilicen para acceder a los dispositivos de E/S las mismas primitivas que emplean para manipular los archivos.

●

Controladores de dispositivo que son quiénes conocen las peculiaridades específicas del dispositivo para el que ha sido creado.

e) Gestión del almacenamiento secundario Los programas que se desean ejecutar deben estar en la memoria principal, o almacenamiento primario, pero ésta es demasiado pequeña para alojar todos los datos y todos los programas del sistema. Además, incluso aunque pudiera ser así, los datos almacenados en la memoria principal se perderían en caso de que fallara la alimentación. Por eso los ordenadores deben disponer de un almacenamiento secundario para respaldar a la memoria principal. Hoy en día lo más común es utilizar discos duros para esa tarea. 22 El buffering o uso de memoria intermedia es una estrategia para leer datos desde un dispositivo de E/S. La CPU instruye al dispositivo para que escriba bloques de datos en la memoria de forma que la operación se realiza mientras la CPU está ocupada procesando los bloques leídos anteriormente desde el dispositivo. Al escribir en un dispositivo de E/S el proceso es análogo. 23 En el caching el sistema mantiene en la memoria principal una copia de los datos almacenados en los dispositivos de E/S del sistema como, por ejemplo, en los discos. Esto mejora la eficiencia del sistema puesto que el acceso a la memoria principal es más rápido que el acceso a los dispositivos de E/S. La memoria principal es de tamaño limitado, por lo que sólo se mantiene copia de los datos utilizados con mayor frecuencia. 24 El spooling se utiliza en dispositivos que no admiten el acceso simultaneo de varias aplicaciones a vez, como es el caso de impresoras y unidades de cinta. Cuando varias aplicaciones intentan enviar un trabajo a una impresora el sistema operativo lo intercepta para copiar los datos enviados a un archivo distinto para cada aplicación. Cuando una aplicación termina de enviar el trabajo el archivo correspondiente es encolado para su impresión. Así los archivos son impresos de uno en uno.

2-31

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

Responsabilidades de la gestión del almacenamiento secundario El sistema operativo es responsable de la siguientes actividades relacionadas con la gestión del almacenamiento secundario: ●

Gestión del espacio libre.

●

Asignación del espacio de almacenamiento.

●

Planificación del acceso al disco.

f) Gestión de red El componente de red se responsabiliza de la comunicación entre los procesadores en sistemas interconectados mediante una red de ordenadores –por ejemplo en Internet o la red de área local de una oficina–.

g) Protección y seguridad Protección es cualquier mecanismo para controlar el acceso de los procesos y usuarios a los recursos definidos por el sistema. Estos son necesarios cuando un sistema informático tiene múltiples usuarios y permite la ejecución concurrente de varios procesos, pues así sólo pueden utilizar los recursos aquellos procesos que hayan obtenido la autorización del sistema operativo. Además la protección también permite mejorar la fiabilidad al permitir detectar los elementos del sistema que no operan correctamente. Un recurso desprotegido no puede defenderse contra el uso –o mal uso– de un usuario no autorizado o incompetente. Ejemplos típicos de mecanismos de protección son el hardware de direccionamiento de memoria, que se utiliza para que los procesos se ejecuten en su propio espacio de direcciones, y el temporizador, que garantiza que ningún proceso toma el control de la CPU de manera indefinida. Además los registros de los dispositivos de E/S suelen estar protegidos del acceso directo de los usuarios, lo que protege la integridad de los dispositivos, mientras que en algunos sistemas se pueden establecer permisos sobre los archivos para garantizar que sólo los procesos con la debida autorización tienen acceso. En todo caso, un sistema puede tener la protección adecuada pero estar expuesto a fallos y permitir accesos inapropiados. Por eso es necesario disponer de mecanismos de seguridad que se encarguen de defender el sistema frente a ataques internos y externos. Eso incluye a virus y gusanos, ataques

2-32

2.1. Organización de los sistemas operativos

Sistemas Operativos - 2014/2015

de denegación de servicio25, robo de identidad y uso no autorizado del sistema, entre muchos otros tipos de ataque.

2.1.3. Interfaz de usuario Aunque cada sistema operativo ofrece servicios diferentes, vamos a detenernos en uno común e importante para todos los sistemas que han sido diseñados para que los usuarios interactúen con ellos directamente, la interfaz de usuario. Las interfaces de usuario pueden ser de diferentes tipos: ●

Interfaz de línea de comandos o intérprete de comandos, que permite que los usuarios introduzcan directamente los comandos que el sistema operativo debe ejecutar. En algunos sistemas este tipo de interfaz se incluye dentro del núcleo, pero en la mayor parte –como MSDOS y UNIX– se trata de un programa especial denominado shell que se ejecuta cuando un usuario inicia una sesión.

●

Interfaz de proceso por lotes, en la que los comandos y directivas para controlar dichos comandos se listan en archivos que posteriormente pueden ser ejecutados. Este tipo de interfaz es la utilizada en sistemas no interactivos, como los de procesamiento por lotes y los multiprogramados. También suele estar disponible en los sistemas de tiempo compartido, junto con algún otro tipo de interfaz de usuario, como es el caso de la shell de los sistemas UNIX.

●

Interfaz gráfica de usuario o GUI (Graphical User Interface) que permite a los usuarios utilizar un sistema de ventanas y menús controlable mediante el ratón.

Puesto que la interfaz de usuario puede variar de un sistema a otro, y de un usuario a otro dentro del mismo sistema, no se suele incluir como un componente básico del sistema operativo, pero si como un servicio útil para los usuarios. A parte de la interfaz de usuario, cualquier sistema operativo moderno incluye una colección de programas del sistema. El papel de estos programas del sistema es proporcionar un entorno conveniente para la ejecución y desarrollo de programas. Entre los programas del sistema se suelen incluir aplicaciones para manipular archivos y directorios, programas para obtener información sobre el estado del sistema –como la fecha y hora o la memoria y el espacio en disco disponible–,

25 En los ataques de denegación de servicio se intentan utilizar todos los recursos de sistema para evitar que éste pueda dar servició a los usuarios legítimos.

2-33

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

herramientas de desarrollo –como intérpretes, compiladores, enlazadores y depuradores–, programas de comunicaciones –como clientes de correo electrónico y navegadores web–, etc. Además, muchos sistemas operativos disponen de programas que son útiles para resolver los problemas más comunes de los usuarios. Entre estos programas se suelen incluir: editores de archivos de texto y procesadores de texto, hojas de cálculo, sistemas de base de datos, juegos, etc. Ha esta colección de aplicaciones se la suele conocer con el término de utilidades del sistema o programas de aplicación.

2.2. Operación del sistema operativo Los sistemas operativos modernos pertenecen a un tipo de software que se dice que está controlado mediante interrupciones: ●

Si no hay ningún proceso que ejecutar ni ningún dispositivo de E/S pide la atención del sistema, el sistema operativo debe permanecer inactivo esperado a que algo ocurra.

●

Los sucesos que requieren la activación del sistema casi siempre se indican mediante una interrupción: ○

Cuando un proceso comente un error –como una división por cero o un acceso a memoria no válido– o un programa solicita un servicio al sistema operativo a través de una llamada al sistema lo que se genera es una excepción –que no es más que una interrupción generada por software– que despierta al sistema operativo para que haga lo que sea más conveniente.

○

Cuando los dispositivos de E/S requieren la atención del sistema operativo –por ejemplo porque se ha completado una transferencia de datos– se genera una interrupción que despierta al sistema operativo.

Dado que el sistema operativo y los procesos de usuarios comparten los recursos del sistema informático, necesitamos estar seguros de que un error que se produzca en un programa sólo afecte al proceso que lo ejecuta. Por ejemplo, en los sistemas de tiempo compartido –y en cualquier otro tipo de sistema operativo donde los programas tengan que compartir la memoria, como es el caso de los sistema microprogramados– un programa erróneo puede modificar el código de otro programa, los datos de otro programa o el propio sistema operativo. Por eso es necesario establecer mecanismos de protección frente a los errores en los programas que se ejecutan en el sistema. 2-34

2.2. Operación del sistema operativo

Sistemas Operativos - 2014/2015

2.2.1. Operación en modo dual Para evitar este tipo de problemas es necesario poder distinguir entre la ejecución de código del sistema operativo y del código de los programas de usuario. El método que utilizan la mayor parte de los sistemas operativos consiste en utilizar algún tipo de soporte en el hardware que permita diferencia entre varios modos de ejecución y restringir la utilización de las instrucciones peligrosas –instrucciones privilegiadas– para que sólo puedan ser utilizadas en el modo en el que se ejecuta el código del sistema operativo. Como mínimo son necesarios dos modos de operación diferentes: ●

En el modo usuario se ejecuta el código de las tareas de los usuarios. Si se hace un intento de ejecutar una instrucción privilegiada en este modo, el hardware la trata como ilegal y genera una excepción que es interceptada por el sistema operativo, en lugar de ejecutar la instrucción.

●

En el modo privilegiado –también denominado modo supervisor, modo del sistema o modo kernel– se ejecuta el código de las tareas del sistema operativo. El hardware es el encargado de garantizar que las instrucciones privilegiadas sólo pueden ser ejecutadas en este modo.

El modo actual de operación puede venir indicado por un bit de modo que se añade al hardware de la computadora, de forma que si por ejemplo el bit está a 0, el código en ejecución opera en modo privilegiado mientras que si el bit está a 1, el código en ejecución opera en modo usuario. Comúnmente en el grupo de las instrucciones privilegiadas se suelen incluir: ●

Las instrucción para conmutar al modo usuario.

●

Las instrucciones de E/S.

●

Las instrucciones necesarias para la gestión de las interrupciones.

A continuación podemos ver el ciclo de vida de la ejecución de instrucciones en un sistema con modo dual de operación: 1. Inicialmente, al arrancar la computadora, el hardware se inicia en el modo privilegiado –es decir, con el bit de modo a 0–. En este modo se carga el sistema operativo e inicia su ejecución. 2. El sistema operativo debe cambiar al modo usuario –poniendo el bit de modo a 1– antes de ceder el control a un proceso de usuario. Esto ocurre cuando es necesario que un proceso de usuario continúe o inicie su ejecución (véase el apartado 3.4.2). 2-35

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

3. El hardware conmuta a modo privilegiado cuando ocurre una interrupción o una excepción –poniendo el bit de modo a 0– antes de pasar el control al código del sistema operativo que se encargará de tratarlas. Esto último es importante pues, como ya hemos comentado, los sistemas operativos están controlados mediante interrupciones. Al activarse el modo privilegiado cada vez que ocurre una interrupción podemos estar seguros de que las tareas del sistema operativo se ejecutará en modo privilegiado. Cuando se dispone de la protección del modo dual el hardware se encarga de detectar los errores de ejecución y de notificarlo al sistema operativo mediante excepciones, siendo responsabilidad de este último realizar un tratamiento adecuado de los mismos. Por lo general, si un programa falla de alguna forma, como por ejemplo intentando utilizar una instrucciones ilegal o de acceder a una zona de memoria inválida, el sistema operativo lo hace terminar de manera anormal.

2.2.2. Protección de la memoria La memoria principal debe acomodar tanto el sistema operativo como a los diferentes procesos de los usuarios. Por eso la memoria normalmente se divide en dos partes: 1. La primera parte sirve para albergar el sistema operativo residente 26. El sistema operativo puede estar localizado tanto en la parte baja como en la parte alta de la memoria. El factor determinante en la elección es la localización del vector de interrupciones. Puesto que en la mayor parte de las arquitecturas éste reside en la parte baja de la memoria, normalmente el sistema operativo también se aloja en la parte baja. 2. La segunda parte alberga los procesos de usuario. Sin embargo en los sistemas operativos modernos los procesos no tienen acceso libre a toda memoria física con el objeto de proteger a los procesos en ejecución y al sistema operativo de posibles errores en cualquiera de ellos: ●

El sistema operativo proporciona a cada proceso una «vista» privada de la memoria similar a la que tendrían si cada uno de ellos se estuviera ejecutando en solitario (véase la Figura 2.4).

●

A esa «vista» que tiene cada proceso de la memoria es a lo que se denomina espacio de

26 El termino sistema operativo residente hace referencias a los componentes del sistema operativo que deben estar permanentemente en la memoria. Comúnmente dicho conjunto de elementos componen el núcleo del sistema.

2-36

2.2. Operación del sistema operativo

Sistemas Operativos - 2014/2015

sistema operativo

proceso 2

proceso 1

sistema operativo 0x00000000

proceso 2 0x00000000

memoria física

espacio de direcciones del proceso 2

Figura 2.4: Mapeo de la memoria física en el espacio de direcciones virtual de un proceso.

direcciones virtual del proceso y está formado por el conjunto de direcciones que puede generar la CPU para un proceso dado. ●

Durante los accesos a la memoria principal en tiempo de ejecución estas direcciones virtuales son convertidas en direcciones físicas antes de ser enviadas a la memoria principal. Por tanto las direcciones físicas son las direcciones reales que ve la memoria, mientras que el espacio de direcciones físico es el conjunto de direcciones físicas que corresponden a un espacio de direcciones virtual dado.

La conversión de una dirección virtual en una física la realiza en tiempo de ejecución un dispositivo hardware denominado MMU (Memory-Management Unit). Las ventajas de este dispositivo desde el punto de vista de la protección de la memoria son que: ●

Permite el aislamiento de los procesos, creando para cada uno la ilusión de que toda la memoria es para él y evitando que un proceso pueda acceder a la memoria de otros procesos.

●

Permite marcar los modos de acceso autorizados en las diferentes regiones de la memoria –como por ejemplo lectura, escritura y ejecución– evitando que el código ejecutado en modo usuario tenga acceso a zonas a las que no debería tenerlo. El acceso a la memoria en un modo no autorizado se considera una instrucción privilegiada, por lo que ese tipo de acceso desde el modo usuario siempre genera una excepción.

2-37

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

2.2.3. El temporizador El temporizador se utiliza para poder estar seguros de que el sistema operativo es capaz de mantener el control de la CPU, puesto que lo que no puede ocurrir es que un proceso entre en un bucle infinito de manera que nunca devuelva el control al sistema operativo. El temporizador se configura durante el arranque del sistema para interrumpir a la CPU a intervalos regulares. Así cuando el temporizador interrumpe el control se transfiere automáticamente al sistema operativo. Entonces este puede: conceder más tiempo al proceso en ejecución, detenerlo y darle más tiempo de CPU en el futuro o tratar la interrupción como un error y terminar de manera anormal el programa. Indudablemente las instrucciones que pueden modificar el contenido del temporizador son instrucciones privilegiadas.

2.3. Sistemas operativos por su estructura Ya hemos discutido anteriormente acerca de los componentes más comunes en un sistema operativo (véase el apartado 2.1.2). En esta sección comentaremos su organización e interconexión dentro del núcleo.

aplicaciones

programa residente del sistema

drivers de dispositivo de MSDOS

drivers de dispositivo de la BIOS

hardware

Figura 2.5: Ejemplo de sistema operativo con estructura sencilla (MSDOS).

2-38

2.3. Sistemas operativos por su estructura

Sistemas Operativos - 2014/2015

2.3.1. Estructura sencilla Los sistemas con estructura sencilla no tienen una estructura bien definida. Es decir, los interfaces y niveles de funcionalidad no están bien separados. Por ejemplo, en MSDOS los programas de aplicación podían acceder directamente a la BIOS o al hardware para hace acceder a cualquier dispositivo (véase la Figura 2.5). Disponiendo de esa libertad un programa erróneo cualquiera podía corromper el sistema completo. Como el Intel 8086 para el que fue escrito MSDOS no proporcionaba un modo dual de operación, los diseñadores del sistema no tuvieron más opción que dejar accesible el hardware a los programas de usuario. Otro ejemplo es el de UNIX original, donde se combinaba un montón de funcionalidad en un mismo nivel, el núcleo (véase la Figura 2.6). Es decir, todo lo que estaba por encima del hardware y por debajo de las llamadas al sistema era el núcleo. Este proporciona la planificación de CPU, la gestión de la memoria, el soporte de los sistemas de archivos y muchas otras funcionalidades del sistema operativo. En general se trata de una enorme cantidad de funcionalidad que es difícil de implementar y mantener en un mismo nivel. Esa concentración de funcionalidad en el núcleo define a los sistemas de estructura sencilla como sistemas de núcleo molítico. Tanto MSDOS como UNIX eran originalmente sistemas pequeños y simples, limitados por la

aplicaciones intérpretes de comando compiladores e intérpretes librerías del sistema

modo usuario modo privilegiado

llamadas al sistema

gestión de señales del terminal sistema de E/S de caracteres drivers de terminal

sistema de ficheros

planificador de la CPU

sistema de E/S de bloques

reemplazo de páginas

drivers de disco y cinta

paginación bajo demanda memoria virtual

interfaz del núcleo con el hardware

hardware

Figura 2.6: Ejemplo de sistema operativo con estructura sencilla (UNIX original).

2-39

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

funcionalidades del hardware de su época, que fueron creciendo más allá de las previsiones originales. Lo cierto es que con mejor soporte del hardware se puede dividir el sistema operativo en piezas más pequeñas y apropiadas que las del MSDOS y UNIX original.

2.3.2. Estructura en capas Un método para dividir el sistema operativo en piezas más pequeñas, con el fin de hacerlo más modular, es partirlo en capas. Las capas se seleccionan de manera que cada una use sólo funciones y servicios de las capas inferiores y de servicios sólo a las capas superiores. Cada capa no tiene que saber como se implementan las funciones que utiliza de las capas inferiores, sólo debe conocer qué

logon process

OS/2 applications

Win 16 applications

security subsystem

OS/2 subsystem

Win 16 VDM

Win 32 applications

MSDOS applications

POSIX applications

MSDOS VDM

POSIX subsystem

authentication pakage

modo usuario

security account manager database

modo privilegiado I/O manager

Win 32 subsystem

executive security virtual object process plug and reference memory manager manager play manager monitor manager

file system

local procedue call facility

window manager

cache manager device driver

kernel

I/O manager network drivers hardware abstraction layer

hardware

Figura 2.7: Diagrama de bloques de Microsoft Windows XP.

2-40

graphic device drivers

2.3. Sistemas operativos por su estructura

Sistemas Operativos - 2014/2015

es lo que hacen y como utilizar. Por lo tanto cada capa tiene la responsabilidad de ocultar la existencia de estructuras de datos, operaciones y hardware a las capas de nivel superior. Este tipo de sistemas son los que se denominan con estructura en capas. Los sistemas con estructura en capas siguen concentrado la mayor parte de la funcionalidad en el núcleo, por lo que también son sistemas monolíticos aunque el núcleo es más modular. Ejemplos de este tipo de sistemas operativos son el IBM OS/2 y Microsoft Windows (véase la Figura 2.7). Sin embargo esta

forma de dividir los componentes del sistema operativo no está libre de

inconvenientes: ●

La mayor dificultad con los sistemas con estructura en capas es definirlas. Esto debe ser planificado cuidadosamente debido a la restricción, comentada anteriormente, de que un capa sólo puede utilizar los servicios de las capas inferiores. Por ejemplo, el planificador de CPU suele tener información de los procesos que están en la memoria y parte de esa información puede ser intercambiada con el disco para aumentar la memoria principal disponible. Este planteamiento nos lleva a pensar que la gestión del almacenamiento secundario debe ir en una capa inferior a la del planificador de la CPU. Sin embargo el planificador debe replanificar la CPU cuando el proceso que actualmente la ocupa solicita alguna operación de E/S, por lo que la gestión del almacenamiento secundario debe estar encima del planificador de la CPU para que le pueda decir que replanifique. Al final la solución de compromiso es tender hacia sistemas con pocas capas donde cada una tiene mucha funcionalidad.

●

Esta estrategia es sin duda mucho menos eficiente que la de los sistemas de estructura sencilla. En cada capa los parámetros son modificados y los datos necesarios deben de ser transferidos, por lo que cada una añade cierto nivel de sobrecarga al funcionamiento del sistema.

2-41

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

2.3.3. Microkernel Los sistemas microkernel eliminan todos los componentes no esenciales del núcleo y los implementa como programas de nivel de usuario. Aunque hay poco consenso, en general un núcleo microkernel proporciona funciones mínimas de gestión de procesos y memoria, junto a algún mecanismo de comunicación. En estos sistemas la función principal del núcleo es precisamente proporcionar dicho mecanismo de comunicación entre el programa cliente y los diversos servicios del sistema. Generalmente esta comunicación se implementa mediante paso de mensajes (véase el apartado 3.2). Entre los beneficios de estos sistemas operativos se incluyen: ●

Facilidad a la hora de añadir nuevas funcionalidades. Los nuevos servicios son añadidos como aplicaciones de nivel de usuario, por lo que no es necesario hacer modificaciones en el núcleo.

●

Facilidad a la hora de portar el sistema a otras plataformas.

●

Más seguridad y fiabilidad. Puesto que los servicios se ejecutan a nivel de usuario en procesos separados, un servicio que falla no puede afectar a otros ni puede ser utilizado para ganar acceso a otros servicios o al núcleo.

El mayor inconveniente es su pobre rendimiento causado por la sobrecarga que añade el mecanismo de comunicación. Por ejemplo Microsoft Windows NT nació con una estructura de microkernel en capas donde una parte importante de los servicios eran proporcionados por unos procesos de usuario llamados subsistemas. Además el sistema operativo podía mostrar diferentes personalidades o entornos operativos –OS/2, POSIX y DOS– a través del uso de subsistemas ambientales, que también se ejecutaban como procesos de usuario. Las aplicaciones de Microsoft Windows NT se comunicaban con estos subsistemas utilizando una forma de IPC (véase el apartado 3.2.3) denominada LPC (Local Procedure Call), una forma local y optimizada de RPC27. Con esta estructura la pérdida de rendimiento respecto a Microsoft Windows 95 era tan importante que los diseñadores se vieron obligados a mover más servicios al espacio del núcleo. En la actualidad Microsoft Windows XP (véase la Figura 2.7) –que es un heredero directo de Microsoft Windows

27 La RPC (Remote Procedure Call) es una mecanismo de llamada a procedimiento diseñado para ser utilizado entre sistemas conectados por redes de ordenadores, permitiendo que un proceso cliente llame a un procedimiento en un proceso servidor, aunque ambos estén en equipos diferentes, y ocultado los detalles de la comunicación que permiten que la llamada tenga lugar.

2-42

2.3. Sistemas operativos por su estructura

Sistemas Operativos - 2014/2015

aplicaciones Hurd

aplicaciones POSIX glibc

(1)

servidores Hurd autenticación

contraseña

sistema de ficheros

procesos

red

...

modo usuario

(1) (1)

modo privilegiado

GNU Mach OSkit

paso de mensajes

gestor de memoria

gestor de tareas

controladores de dispositivo

hardware

Figura 2.8: Diagrama de bloques de GNU/Hurd.

NT– tiene una arquitectura más monolítica que microkernel 28 ya que aunque muchos servicios siguen siendo proporcionados por procesos de usuario, esto sólo ocurre con aquellos donde el rendimiento no es un factor crítico. Sin embargo varios sistemas operativos siguen utilizando núcleos microkernel, como Tru64 UNIX y GNU/Hurd (véase la Figura 2.8). Ambos proporcionan una interfaz UNIX implementada sobre un microkernel Mach. Otro ejemplo es QNX, un sistema operativo de tiempo real con una gran aceptación que basa en la estructura de microkernel su estabilidad como sistema para tareas críticas. Además siguen existiendo algunos proyectos de investigación dirigidos a resolver los problemas de rendimiento asociados a los núcleos microkernel.

28 A las 280 llamadas al sistema de Microsoft Windows XP –algo menos de 200 en Microsoft Windows NT 3.51– se deben sumar las más de 650 del subsistema gráfico, alojado en el núcleo desde Microsoft Windows NT 4.0.

2-43

Sistemas Operativos - 2014/2015

2. Estructura de los sistemas operativos

2.3.4. Estructura modular Los sistemas de estructura modular tienen divido el núcleo en módulos, cada uno de los cuales implementa funciones y servicios concretos, a imagen y semejanza de las técnicas de programación orientada a objetos. Quizás por eso sea la mejor metodología actual para diseñar sistemas operativos. Además se parecen a los sistemas con estructura en capas en que cada módulo del núcleo tiene definidos interfaces protegidas, pero a diferencia de estos todos los módulos pueden llamar a cualquier otro módulo. Estos núcleos suelen disponer un pequeño conjunto de componentes fundamentales que se cargan durante el arranque, aunque también pueden enlazar dinámicamente servicios adicionales tanto durante la inicialización del sistema como o en tiempo de ejecución. En este aspecto se asemejan a los núcleos microkernel, ya que el módulo principal sólo tiene funciones básicas, aunque es mucho más eficiente al no necesitar un mecanismo de paso de mensajes, puesto que los componentes se cargan directamente en la memoria destinada al núcleo. Por lo tanto también deben ser considerados como sistemas monolíticos. Este tipo de estructura es la utilizada en los UNIX modernos, como Oracle/Sun Microsystems Solaris, Linux (véase la Figura 2.9) y Mac OS X.

2-44

modo privilegiado

modo usuario

Linux

gestión de módulos

gestión del tiempo

hardware

core

red

mmap

swap

gestor de memoria

Figura 2.9: Ejemplo de sistema operativo con estructura modular (GNU/Linux).

controladores de dispositivo

bin_exec

planificación de procesos

buffer-cache

VFS

planificador de procesos

sistema de ficheros virtual

llamadas al sistema

librerías del sistema (glibc)

aplicaciones

System V IPC

Kernel IPC

Net IPC

File IPC

IPC

3. Gestión de procesos

3.1. Procesos Los primeros sistemas informáticos sólo permitían que un programa se ejecutara de cada vez. Dicho programa tenía un control completo sobre el sistema y acceso a todos los recursos del mismo. Por el contrario, los sistemas de tiempo compartido actuales permiten que múltiples programas sean cargados y ejecutados concurrentemente. Obviamente esta evolución requiere un control más fino y la compartimentación de los diversos programas para que no interfieran unos con otros. Esto a su vez conduce a la aparición de la noción de proceso, que no es sino la unidad de trabajo en un sistema operativo moderno de tiempo compartido. Por simplicidad, en este tema utilizaremos los términos trabajo y proceso de forma indistinta. A fin de cuentas tanto los trabajos en los sistemas de procesamiento por lotes como los procesos en los sistemas de tiempo compartido son la unidad de trabajo en sus respectivos sistemas y el origen de toda actividad en la CPU. Por último, antes de continuar, no debemos olvidar que en un sistema operativo hay: ●

Procesos del sistema ejecutando el código del sistema operativo contenido en los programas del sistema, que generalmente realizan tareas que es mejor mantener fuera del núcleo.

●

Procesos de usuario ejecutando código de usuario contenido en los programas de aplicación.

Sistemas Operativos - 2014/2015

3. Gestión de procesos

Sin embargo en lo que resta de tema no estableceremos ningún tipo de distinción entre ellos. Al fin y al cabo todos son simples procesos de cara al resto del sistema.

3.1.1. El proceso Como ya hemos comentado con anterioridad, un proceso es un programa en ejecución. Sin embargo los procesos no son sólo el código del programa, sino que también suelen contener algunos otros elementos: ●

El código del programa, conocido como la sección text.

●

La sección de datos contiene las variables globales. Se divide entre la sección data, donde se almacenan las variables inicializadas, y la sección bss, donde se almacenan las variables sin inicializar.

●

La pila contiene datos temporales como parámetros y direcciones de retorno de las funciones y variables locales. Es conocida como la sección stack.

●

El montón, que es donde se aloja la memoria que se asigna dinámicamente durante la ejecución del proceso.

●

Información de la actividad actual, como el contador de programa, los registros de la CPU, etc.

En la Figura 3.1 se puede observar la disposición de algunos de estos elementos en la memoria. Máx. sistema operativo

pila

montón datos código 0x00000000

Figura 3.1: Estructura de un proceso en memoria.

3-48

3.1. Procesos

Sistemas Operativos - 2014/2015

En todo caso es importante recordar que un proceso es una entidad activa, con un contador de programa especificando la próxima instrucción a ejecutar y un conjunto de recursos del sistema asociados. Mientras que un programa no es un proceso ya que es una entidad pasiva, como un archivo en disco que contiene el código que algún día será ejecutado en la CPU. Por lo tanto dos procesos pueden estar asociados al mismo programa pero no por eso dejan de ser distintos procesos (véase el apartado 2.1.2). Ambos tendrán la misma sección text pero el contador de programas, la pila, la sección data, etc. contendrán valores diferentes.

3.1.2. Estados de los procesos Los procesos tienen un estado que cambia a lo largo de su ejecución y está definido parcialmente por la actividad actual del propio proceso. Los estados por los que puede pasar un procesos varían de un sistema operativo a otro, aunque los siguientes son comunes a todos ellos: ●

Nuevo. El proceso está siendo creado.

●

Ejecutando. El proceso está siendo ejecutado puesto que ha sido escogido por el planificador de la CPU. Sólo puede haber un proceso en este estado por CPU en el sistema.

●

Esperando. El proceso está esperando por algún evento, como por ejemplo que termine alguna operación de E/S o que se reciba alguna señal. Obviamente varios procesos pueden estar en este estado.

●

Preparado. El proceso está esperando a que se le asigne la CPU. Varios procesos pueden estar en este estado.

nuevo

admitido

salida

terminado

temporizador

preparado

E/S o evento completado

ejecutando

asignación por el planificador de la CPU

a la espera de un evento o E/S

esperando

Figura 3.2: Diagrama de estado de los procesos.

3-49

Sistemas Operativos - 2014/2015 ●

3. Gestión de procesos

Terminado. El proceso ha finalizado su ejecución y espera a que se liberen los recursos que le fueron asignados.

El diagrama de estado de los procesos se muestra en la Figura 3.2.

3.1.3. Bloque de control de proceso El bloque de control de proceso o PCB (Process Control Block) es una estructura de datos que representa a cada proceso en el sistema operativo. Sirve de almacén para cualquier información que puede variar de un proceso a otro. ●

Estado del proceso. Por ejemplo: nuevo, preparado, esperando, etc.

●

Contador de programa. Indica la dirección de la próxima instrucción del proceso que debe ser ejecutada por la CPU.

●

Registros de la CPU.

●

Información de planificación de la CPU. Incluye la información requerida por el planificador de la CPU. Por ejemplo la prioridad del proceso, punteros a las colas de planificación donde está el proceso, punteros al PCB del proceso padre y de los procesos hijos, etc.

●

Información de gestión de la memoria. Incluye la información requerida para la gestión de la memoria. Por ejemplo los valores de los registros base y límite que definen el área de la memoria física que ocupa el proceso, la tabla de páginas –en el caso de que se use paginación (véase el apartado 4.4)– o la tabla de segmentos –en el caso de que se utilice segmentación– etc.

●

Información de registro. Esta información incluye la cantidad de CPU usada, límites de tiempo en el uso de la CPU, estadísticas de la cuenta del usuario al que pertenece el proceso, estadísticas de la ejecución del proceso, etc.

●

Información de estado de la E/S. Incluye la lista de dispositivos de E/S reservados por el proceso, la lista de archivos abiertos, etc.

3-50

3.1. Procesos

Sistemas Operativos - 2014/2015

cola de preparados

CPU

interrupción del temporizador

E/S

evento

cola de espera de E/S

cola de espera del evento

petición de E/S

esperar por un evento

Figura 3.3: Diagrama de colas de la planificación de procesos.

3.1.4. Colas de planificación En los sistemas operativos hay diferentes colas de planificación para los procesos en distintos estados. ●

Cola de trabajo. Contiene a todos los procesos en el sistema de manera que cuando un proceso entra en el sistema va a esta cola.

●

Cola de preparados. Contiene a los procesos que están cargados en la memoria principal y están preparados para ser ejecutados. La cola de preparados es generalmente una lista enlazada de PCB donde cada uno incluye un puntero al PCB del siguiente proceso en la cola.

●

Colas de espera. Contienen a los procesos que están esperando por un evento concreto, como por ejemplo la finalización de una solicitud de E/S. Estas colas también suelen ser implementadas como listas enlazadas de PCB y suele existir una por evento, de manera que cuando ocurre algún evento todos los procesos en la cola asociada pasan automáticamente a la cola de preparados.

●

Colas de dispositivo. Son un caso particular de cola de espera. Cada dispositivo de E/S tiene asociada una cola de dispositivo que contiene los procesos que están esperando por ese dispositivo en particular.

Una manera habitual de representar la planificación de procesos es a través de un diagrama de colas como el de la Figura 3.3. Analizándolo podemos tener una idea clara del flujo típico de los procesos dentro del sistema:

3-51

Sistemas Operativos - 2014/2015

3. Gestión de procesos

1. Un nuevo proceso llega al sistema. El proceso es colocado en la cola de preparados. Allí espera hasta que es seleccionado para su ejecución y se le asigna la CPU. Mientras se ejecuta pueden ocurrir varias cosas: ○

El proceso puede solicitar una operación de E/S por lo que abandona la CPU y es colocado en la cola de dispositivo correspondiente. No debemos olvidar que aunque en nuestro diagrama no exista más que una de estas colas, en un sistema operativo real suele haber una para cada dispositivo.

○

El proceso puede querer esperar por un evento. Por ejemplo puede crear un subproceso y esperar a que termine. En ese caso el proceso hijo es creado mientras el proceso padre abandona la CPU y es colocado en una cola de espera hasta que el proceso hijo termine. La terminación del proceso hijo es el evento que espera el proceso padre para continuar su ejecución.

○

El proceso puede ser sacado forzosamente de la CPU –como resultado de la interrupción del temporizador que indica que lleva demasiado tiempo ejecutándose– y colocado en la cola de preparados.

2. Cuando la espera concluye los procesos pasan del estado de espera al de preparado y son insertados en la cola de preparados. 3. El proceso repite este ciclo hasta que termina. En ese momento es eliminado de todas las colas mientras el PCB y los recursos asignados son liberados.

3.1.5. Planificación de procesos Durante su ejecución, los procesos se mueven entre las diversas colas de planificación a criterio del sistema operativo como parte de la tarea de planificación. Este proceso de selección debe ser realizado por el planificador adecuado: ●

En los sistemas de multiprogramados 29 el planificador de largo plazo –o planificador de trabajos– selecciona los trabajos desde la cola de entrada en el almacenamiento secundario, dónde están todos almacenados, y los carga en memoria.

●

El planificador de corto plazo o planificador de CPU selecciona uno de los procesos en la

29 Los sistemas de tiempo compartido como GNU/Linux, Microsoft Windows o cualquier sabor de UNIX carecen de planificador de trabajos. En estos sistemas simplemente se cargan los procesos en memoria para que sean ejecutados cuando el usuario lo solicita.

3-52

3.1. Procesos

Sistemas Operativos - 2014/2015

cola de preparados y lo asigna a la CPU. Obviamente este planificador es invocado cuando un proceso en ejecución abandona la CPU por cualquiera de los motivos comentados. ●

Algunos sistemas operativos utilizan el planificador de medio plazo para sacar procesos de la memoria y reintroducirlos posteriormente. A este esquema se le denomina intercambio –o swapping– y puede ser necesario utilizarlo cuando escasea la memoria.

3.1.6. Cambio de contexto El cambio de contexto es la tarea de asignar a la CPU un proceso distinto al que la tiene asignada en el momento actual. Esto implica salvar el estado del viejo proceso en su PCB y cargar en la CPU el estado del nuevo. Entre la información que debe ser preservada se incluye: ●

Los registros de la CPU.

●

El estado del proceso.

●

La información de gestión de la memoria. Por ejemplo la información referente al espacio de direcciones del proceso.

El cambio de contexto es sobrecarga pura puesto que no hace ningún trabajo útil mientras se conmuta. Su velocidad depende de aspectos tales como: el número de registros, la velocidad de la memoria y la existencia de instrucciones especiales30.

3.1.7. Operaciones sobre los procesos En general los procesos pueden ser creados y eliminados dinámicamente, por lo que los sistemas operativos deben proporcionar mecanismos para la creación y terminación de los mismos.

a) Creación de procesos Un proceso –denominado padre– puede crear múltiples procesos –los hijos– utilizando una llamada al sistema específica para la creación de procesos. En general cada proceso se identifica de manera unívoca mediante un identificador de proceso o PID (Process Identifier), que 30 Algunas CPUs disponen de instrucciones especiales para salvar y cargar todos los registros de manera eficiente. Esto reduce el tiempo que la CPU está ocupada en los cambios de contexto. Otra opción es el uso de juegos de registros, como es el caso de los procesadores Sun UltraSPARC e Intel Itanium. Con ellos el juegos de registros de la CPU puede ser mapeado sobre un banco de registros mucho más extenso. Esto permite que la CPU almacene de forma eficiente el valor de los registros de más de un proceso.

3-53

Sistemas Operativos - 2014/2015

3. Gestión de procesos

normalmente es un número entero. Puesto que cada nuevo proceso puede a su vez crear otros procesos, al final se acaba obteniendo un árbol de procesos31. Hay varios aspectos en la creación de los procesos que pueden variar de un sistema operativo a otro: ●

¿Cómo obtienen los subprocesos los recursos que necesita para hacer su trabajo? ○

En algunos sistemas operativos los subprocesos sólo puede aspirar a obtener un subconjunto de los recursos de su padre. Esto permite evitar, por ejemplo, que un proceso pueda sobrecargar el sistema creando demasiados procesos.

○

Mientras que en otros cada subproceso puede solicitar y obtener los recursos directamente del sistema operativo.

●

¿Qué ocurre con los recursos de un proceso cuando decide crear subprocesos? ○

El proceso puede estar obligado a repartir sus recursos entre sus hijos.

○

O puede que esté en disposición de compartir algunos recursos –como memoria y archivos– con algunos de sus hijos. Por ejemplo en POSIX todos los archivos abiertos por un proceso son heredados en ese estado por sus hijos.

●

¿Cómo un proceso puede pasar parámetros de inicialización a sus procesos hijo? Además de los diversos recursos que un proceso obtiene cuando es creado, el proceso padre suele poder pasar parámetros de inicialización a sus procesos hijo. Por ejemplo en lenguaje C/C++ se puede obtener acceso a estos parámetros través de los argumentos argc y argv de la función main() del programa.

●

¿Qué ocurre con la ejecución de un proceso cuando crea un subproceso? Si eso ocurre se suelen contemplar dos posibilidades en términos de la ejecución del padre:

●

○

El padre continúa ejecutándose concurrentemente con el hijo.

○

El padre decide esperar a que algunos o todos sus hijos terminen.

¿Cómo se construye el espacio de dirección de los subprocesos? En general hay dos posibilidades:

31 En los sistemas UNIX el proceso init es el proceso padre raíz de todos los procesos de usuario. Su PID siempre es 1 ya que es el primer proceso creado por el sistema operativo al terminar la inicialización del núcleo. Por lo tanto es el responsable de crear todos los otros procesos que son necesarios para el funcionamiento del sistema.

3-54

3.1. Procesos

Sistemas Operativos - 2014/2015

/* lanzar otro proceso */ pid_t pid = fork(); if (pid == 0) { // proceso hijo execlp("/bin/ls", "ls", "-l", NULL); } else if (pid > 0) { // proceso padre // el padre esperará a que el hijo termine wait(NULL); std::cout