Sistemas Operativos: Introducción a sus funciones y componentes

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
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
Figura 1.1: Vista abstracta de los componentes de un sistema informático.
usuario
1
usuario
2
usuario
3
usuario
n
hardware
sistema operativo
programas del sistema y aplicaciones
editor compilador
juego base
de datos
...
...

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

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 CPU4
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
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
Figura 1.2: Disposición de la memoria en un sistema de procesamiento por lotes.
sistema operativo
área de los
programas de usuario

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

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áneamente6
. 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

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 usuario8
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.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

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

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

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
● IBM OS/360. Desarrollado por IBM para su mainframe System/360.
1-12

1.4. Historia de los sistemas operativos Sistemas Operativos - 2014/2015
○ 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
Figura 1.4: Instalación de un mainframe IBM 702.

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
Figura 1.5: Mainframe GE-6180 con sistema operativo MULTICS (MIT ca. 1976)

○ 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.
1-15
Figura 1.6: Miniordenador DEC PDP-7.

● 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

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 880014
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

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

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 API15
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

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.
○ El núcleo Linux fue inicialmente escrito como hobby por el estudiante universitario finés
1-20

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

1ª
Generación
Sin
sistema
operativos
ni
lenguajes
de
programación
2ª
Generación
Sistemas
operativos
de
procesamiento
por
lotes
Uso
de
lenguajes
de
programación
5ª
Generación
Sistemas
de
escritorio
Monousuario
y
multiusuario,
multitarea,
sistemas
distribuidos,
sistemas
en
cluster,
sistemas
de
tiempo
real,
etc.
4ª
Generación
Sistemas
operativos
de
tiempo
compartido
Hay
programas
interactivos
y
máquinas
virtuales
3ª
Generación
Sistemas
operativos
multiprogramados
Más
lenguajes
de
programación,
multiprogramación
1945
1955
Mainframe
IBM
701
1952
Primer
sistema
operativo.
General
Motors
Research
Laboratory.
Para
IBM
701.
1956
Windows
XP
Su
versión
Home
extinguió
la
familia
de
Windows
9x.
1964
1965
1968
1980
2001
Windows
95
Familia
de
sistemas
operativos
híbridos
de
16/32bits.
1995
OS/2
Sistema
de
16bits
pensado
como
sucesor
de
MS-DOS
OS/2
3.0
Sistemas
operativo
de
IBM
de
32bits.
1993
Linux
El
núcleo
libre
más
utilizado
con
el
proyecto
GNU.
1994
GNU
Hurd
Núcleo
del
proyecto
GNU.
1988
Mach
Núcleo
microkernel
de
la
CMU.
1985
Proyecto
GNU
Proyecto
de
software
libre.
1983
2001
1991
MS-DOS
S.O.
del
IBM
PC.
CP/M
S.O.
de
la
1ª
generación
de
micro
ordenadores.
1981
1976
IBM
OS/360
Nace
la
ingeniería
del
software.
1966
Multics
Primer
sistema
de
propósito
general.
UNIX
Digital
VMS
Para
VAX.
1978
1964
1970
UNIX
System
V
UNIX
BSD
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.

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
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 POSIX17
–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
Figura 2.1: Diagrama general de organización de los sistemas operativos.
gestor de procesos gestor de memoria
gestor del sistema
de archivos
gestor del
almacenamiento
secundario
servicio de
operaciones con
la memoria
servicio de
manipulación de
archivos
servicio de
ejecución de programas
hardware
interfaz de programación de aplicaciones
aplicaciones
gestor de E/S
servicio de
operaciones de E/S

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
2-25
#
# 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 $a0,FILEDES # cargar FILEDES
la $a1,BUFFER # cargar BUFFER
lw $a2,SIZE # cargar SIZE
li $v0,4 # cargar id. de la llamada write()
syscall # 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.

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.
2-26
Figura 2.3: Elementos de la interfaz de programación de aplicaciones en GNU/Linux.
fopen()
···
int fd = syscall(__NR_open, filename, ...);
···
std::ofstream::open()
···
FILE *f = fopen(filename, ...);
···
ofstream ofs;
ofs.open(filename);
proceso
programa en C++
librería estándar de
C++ (libstdc++)
librería del sistema
(glibc)
sistema operativo
llamada al sistema

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

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

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

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

● 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

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

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

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

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 residente26
. 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
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
Figura 2.4: Mapeo de la memoria física en el espacio de direcciones virtual de un proceso.
sistema operativo
proceso 1
proceso 2
sistema operativo
proceso 2
0x00000000 0x00000000
memoria física espacio de direcciones
del proceso 2

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.
2-38
Figura 2.5: Ejemplo de sistema operativo con estructura sencilla (MSDOS).
aplicaciones
programa residente del sistema
drivers de dispositivo de MSDOS
drivers de dispositivo de la BIOS
hardware

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
2-39
Figura 2.6: Ejemplo de sistema operativo con estructura sencilla (UNIX original).
hardware
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
sistema de E/S de
bloques
drivers de disco y
cinta
planificador de la
CPU
reemplazo de
páginas
paginación bajo
demanda
memoria virtual
interfaz del núcleo con el hardware
aplicaciones

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é
2-40
Figura 2.7: Diagrama de bloques de Microsoft Windows XP.
logon
process
OS/2
applications
Win 16
applications
Win 32
applications
MSDOS
applications
POSIX
applications
security
subsystem
OS/2
subsystem
Win 16
VDM
MSDOS
VDM
POSIX
subsystem
authentication
pakage
security account
manager database
Win 32
subsystem
I/O manager
object
manager
security
reference
monitor
process
manager
plug and
play manager
virtual
memory
manager
local
procedue
call facility
file system
cache
manager
device
driver
network
drivers
I/O manager
window
manager
graphic
device
drivers
kernel
hardware abstraction layer
hardware
executive
modo
usuario
modo
privilegiado

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

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

NT– tiene una arquitectura más monolítica que microkernel28
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
Figura 2.8: Diagrama de bloques de GNU/Hurd.
aplicaciones
Hurd
aplicaciones
POSIX
red ...
procesos
autenticación
hardware
modo
usuario
modo
privilegiado
glibc
sistema de
ficheros
contraseña
servidores Hurd
paso de
mensajes
gestor de
memoria
gestor de
tareas
controladores
de dispositivo
GNU Mach
OSkit
(1)
(1)
(1)

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

Figura
2.9:
Ejemplo
de
sistema
operativo
con
estructura
modular
(GNU/Linux).
librerías
del
sistema
(glibc)
planificador
de
procesos
planificación
de
procesos
gestión
del
tiempo
gestión
de
módulos
gestor
de
memoria
core
mmap
swap
sistema
de
ficheros
virtual
controladores
de
dispositivo
VFS
bin_exec
buffer-cache
IPC
File
IPC
Net
IPC
Kernel
IPC
System
V
IPC
red
llamadas
al
sistema
hardware
Linux
modo
usuario
modo
privilegiado
aplicaciones

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.
3-48
Figura 3.1: Estructura de un proceso en memoria.
Máx.
sistema operativo
código
datos
montón
pila
0x00000000

Sistemas Operativos: Introducción a sus funciones y componentes

Sistemas Operativos: Introducción a sus funciones y componentes

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Sistemas Operativos: Introducción a sus funciones y componentes

Ähnlich wie Sistemas Operativos: Introducción a sus funciones y componentes (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Sistemas Operativos: Introducción a sus funciones y componentes