Tema 05. Sistemas Operativos

T05 - SISTEMAS OPERATIVOS.
1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS.................................................................................................. 3

1.1. CONCEPTO DE SISTEMA OPERATIVO.................................................................................................................. 3
1.2. EVOLUCIÓN DE LOS SISTEMAS OPERATIVOS................................................................................................... 3
2. COMPONENTES DEL SISTEMA.................................................................................................................................... 4
2.1. ADMINISTRACIÓN DE PROCESOS ........................................................................................................................ 4
2.2. ADMINISTRACIÓN DE LA MEMORIA PRINCIPAL.............................................................................................. 4
2.3. ADMINISTRACIÓN DE ARCHIVOS ........................................................................................................................ 5
2.4. ADMINISTRACIÓN DEL SISTEMA DE E/S ............................................................................................................ 6
2.5. ADMINISTRACIÓN DEL ALMACENAMIENTO SECUNDARIO.......................................................................... 6
2.6. OPERACIÓN EN RED ................................................................................................................................................ 6
2.7. SISTEMA DE PROTECCIÓN ..................................................................................................................................... 7
2.8. SISTEMA DE INTÉRPRETE DE COMANDOS......................................................................................................... 7
3. GESTIÓN MULTITAREA ................................................................................................................................................ 7
3.1. CONCEPTO DE PROCESO ........................................................................................................................................ 8
3.2. BLOQUE DE CONTROL DEL PROCESO ................................................................................................................. 8
3.3. ESTADOS DE PROCESO ........................................................................................................................................... 8
3.4. COMUNICACIÓN ENTRE PROCESOS .................................................................................................................... 9
3.4.1. COMUNICACIÓN DIRECTA ............................................................................................................................ 10
3.4.2. COMUNICACIÓN INDIRECTA ........................................................................................................................ 10
3.4.3. USO DE BUFFERS ............................................................................................................................................ 10
4. PROTECCIÓN DE MEMORIA...................................................................................................................................... 11
4.1. PROTECCIÓN DEL SISTEMA OPERATIVO MEDIANTE HARDWARE ............................................................ 11
4.2. PROTECCIÓN ENTRE PROCESOS CONCURRENTES ........................................................................................ 12
4.2.1. CONDICIONES DE COMPETENCIA ENTRE PROCESOS ............................................................................... 12
4.2.2. SECCIONES CRÍTICAS ....................................................................................................................................... 13
4.2.3. EXCLUSIÓN MUTUA .......................................................................................................................................... 14
4.2.3.1. DESACTIVACIÓN DE INTERRUPCIONES.................................................................................................. 14
4.2.3.2. VARIABLES DE CERRADURA...................................................................................................................... 14
4.2.3.3. SOLUCIÓN DE PETERSON.......................................................................................................................... 14
5. SISTEMAS DE ARCHIVOS............................................................................................................................................ 15
5.1. ARCHIVOS................................................................................................................................................................ 15
5.2. DIRECTORIOS.......................................................................................................................................................... 16
5.3. IMPLANTACIÓN DEL SISTEMA DE ARCHIVOS ................................................................................................ 17
5.3.1. ASIGNACIÓN ADYACENTE.............................................................................................................................. 17
5.3.2. ASIGNACIÓN EN FORMA DE LISTA LIGADA................................................................................................ 17
5.3.3. ASIGNACIÓN MEDIANTE UNA LISTA LIGADA Y UN ÍNDICE ..................................................................... 18
5.3.4. NODOS-i ............................................................................................................................................................ 18
6. TECNOLOGÍA PLUG & PLAY (PNP).......................................................................................................................... 19
6.1. FUNCIONAMIENTO DE PLUG & PLAY................................................................................................................ 19
6.2. USO DE PLUG & PLAY............................................................................................................................................ 20
7. INTERFAZ DE USUARIO .............................................................................................................................................. 20
8. SISTEMAS WINDOWS ................................................................................................................................................... 21
8.1. INTRODUCCIÓN...................................................................................................................................................... 21
8.1.1. WINDOWS NT.................................................................................................................................................... 22
8.1.2. WINDOWS 2000................................................................................................................................................. 22
TEMARIO-TICC-mar04 T05
Actualizado en marzo de 2004 Página 1 de 63
8.1.3. WINDOWS XP.................................................................................................................................................... 22
8.2. VISIÓN GENERAL ................................................................................................................................................... 23
8.3. GESTIÓN DE PROCESOS ........................................................................................................................................ 26
8.4. GESTIÓN DE LA MEMORIA................................................................................................................................... 28
8.5. ENTRADA/SALIDA ................................................................................................................................................. 28
8.6. SISTEMAS DE ARCHIVOS...................................................................................................................................... 29
8.7. SEGURIDAD ............................................................................................................................................................. 29
8.8. LA INTERFAZ HOMBRE-MÁQUINA .................................................................................................................... 30
8.9. ADMINISTRACIÓN DEL SISTEMA ....................................................................................................................... 30
8.9.1. ESPACIOS DE NOMBRES................................................................................................................................. 31
8.9.2. EL DIRECTORIO ACTIVO ................................................................................................................................ 31
9. SISTEMAS UNIX ............................................................................................................................................................. 32
9.1. EVOLUCIÓN HISTORICA....................................................................................................................................... 32
9.2. CARACTERÍSTICAS................................................................................................................................................ 33
9.3. TIPOS DE SHELL...................................................................................................................................................... 34
9.3.1. INTRODUCCIÓN............................................................................................................................................... 34
9.3.2. SHELL DEL SYSTEM V: (sh)............................................................................................................................. 35
9.3.2.1. ORDENES DE ENTRADA.............................................................................................................................. 35
9.3.2.2. UTILIZACIÓN DE COMODINES PARA ESPECIFICAR ARCHIVOS.......................................................... 36
9.3.2.3. ENTRADA Y SALIDA ESTÁNDAR................................................................................................................ 37
9.3.2.4. VARIABLES DEL SHELL.............................................................................................................................. 37
9.3.3. El C-SHELL (csh)............................................................................................................................................... 39
9.3.4. EL SHELL KORN (ksh) ..................................................................................................................................... 41
9.4. ESTRUCTURA DE ARCHIVOS............................................................................................................................... 42
9.4.1. CARACTERÍSTICAS SISTEMA DE ARCHIVOS................................................................................................ 43
9.4.2. ALMACENAR DATOS........................................................................................................................................ 44
9.4.3. NOMBRES DE ARCHIVO.................................................................................................................................. 44
9.4.4. TIPOS DE ARCHIVOS....................................................................................................................................... 44
9.4.5. ESTRUCTURA INTERNA DEL SISTEMA DE ARCHIVOS ............................................................................... 47
9.4.5.1. EL BLOQUE DE ARRANQUE ...................................................................................................................... 47
9.4.5.2. EL SÚPER BLOQUE...................................................................................................................................... 47
9.4.5.3. LA LISTA DE NODOS INDICE ..................................................................................................................... 48
9.4.5.4. BLOQUES DE DATOS................................................................................................................................... 50
9.4.5.5. CREACIÓN DE UN SISTEMA DE ARCHIVOS............................................................................................. 50
9.4.6. ESTRUCTURA EXTERNA DEL SISTEMA DE ARCHIVOS .............................................................................. 50
9.4.6.1. DIRECTORIOS Y ARCHIVOS ESTÁNDAR ................................................................................................... 51
9.4.7. OPERACIONES CON ARCHIVOS Y DIRECTORIOS....................................................................................... 53
9.5. INTERFACES GRAFICAS. ...................................................................................................................................... 55
9.5.1. Gestor de ventanas ............................................................................................................................................. 56
9.6. IMPLEMENTACIONES COMERCIALES Y SOFTWARE LIBRE......................................................................... 57
10. CONCLUSIÓN.................................................................................................................................................................. 58
11. BIBLIOGRAFÍA............................................................................................................................................................... 58
12. ESQUEMA – RESÚMEN................................................................................................................................................. 59
1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS
1.1. CONCEPTO DE SISTEMA OPERATIVO
Seguramente todos hemos oído hablar de los sistemas operativos Windows, Unix…, pero si preguntásemos qué
es realmente un sistema operativo, oiríamos generalidades, y nos daríamos cuenta de que realmente no se ha
llegado a entender su verdadero significado.
Antes de dar una definición concreta es recomendable analizar qué componentes (o recursos) forman parte de
una computadora:
□ Procesador. Es el corazón de todo el sistema. Ejecuta las instrucciones que le indica el usuario.
□ Memoria RAM. Almacena las instrucciones a ejecutar por el procesador para agilizar el flujo de datos.
□ Almacenamiento secundario. Necesario para evitar la pérdida de datos. Forman parte de este grupo los
discos, cintas, CD-ROM, DVD-ROM…
□ Dispositivos de E/S. Encargados de interactuar con el usuario.
Para poder ejecutar un programa, éste debe ser consciente

de todos los recursos de los que dispone el usuario. No sólo Usuario
debe saber cuáles son necesarios, sino también su manera
de funcionar. Y ahora bien, ¿qué pasa si se reemplaza alguno
de los dispositivos por uno de otro fabricante? El programa
Aplicación
deberá adaptarse al nuevo y habrá que volverlo a programar.
Desde este punto de vista es dónde nace el concepto de Sistema

sistema operativo. Pensemos en qué ocurriría si entre el Operativo
hardware y nuestros programas hubiera “algo” que lograse la
adaptación entre ambos. Ya no haría falta programar de
nuevo las aplicaciones, sino que valdría con una leve Hardware
modificación de ese “algo”.
Ahora ya nos encontramos en situación de dar una definición:

Un sistema operativo es un programa que actúa como
intermediario entre el usuario y el hardware de una
computadora. El propósito general de cualquier sistema
operativo es ofrecer un ambiente en el que un usuario pueda
ejecutar programas.
1.2. EVOLUCIÓN DE LOS SISTEMAS OPERATIVOS
La lógica o software de los ordenadores se ha complicado conforme han ido evolucionando éstos. Los primeros
ordenadores, década de los 40, sólo podían programarse en lenguaje máquina, y puede considerarse que el
sistema operativo aún no existía.
Con lo comentado en el apartado anterior, ni que decir tiene que los sistemas operativos siempre han estado
íntimamente ligados a la arquitectura hardware que se disponía en ese momento. Surgen y evolucionan como
causa anexa al desarrollo y evolución de los componentes físicos.
John von Neumann fue quien dio el primer paso en la informática y en las relaciones hombre-máquina con el
concepto de programa almacenado, que consistía en archivar en el ordenador un conjunto de instrucciones de
máquina para posteriormente ejecutarlas.
La aparición del lenguaje ensamblador, constituyó un gran avance sobre la primitiva programación en código
máquina. Además, la forma de implementar los sistemas ha ido evolucionando con el tiempo, los más sencillos
funcionaban con monoprogramación. Monoprogramación o monoejecución es el sistema en el que se ejecuta
solamente un programa cada vez y no comienza la ejecución de otro hasta terminar con éxito el anterior.
El monitor, es el programa antepasado del sistema operativo. Abarca funciones muy elementales, como visualizar
y modificar los contenidos de la memoria principal, el lanzamiento automático para ejecución de un programa, la
introducción de puntos de ruptura en los programas para su puesta a punto, etc. Gracias al monitor apareció el
concepto de secuencia automática de trabajos.
Si se aprovechan los tiempos de inactividad de la CPU en la ejecución de otros programas simultáneamente, se

dice que el ordenador trabaja en multiprogramación. La multiprogramación consiste en cargar en la memoria
distintos programas a la vez, simultaneando el tiempo de entrada-salida de unos programas, con el trabajo en otro
programa por parte de la CPU. Es lo que se denomina concurrencia de procesos. En realidad la CPU sólo ejecuta
una instrucción al mismo tiempo, pero va ejecutando varios programas simultáneamente, al ceder el control de la
CPU de unos a otros, aunque no hayan finalizado los programas anteriores.
2. COMPONENTES DEL SISTEMA

Podemos crear un sistema tan grande y complejo, como es un sistema operativo, sólo si lo descomponemos en
piezas más pequeñas. Cada una de estas piezas deberá ser una porción bien definida del sistema, con entradas,
salidas y funciones definidas con cuidado. Obviamente, no todos los sistemas operativos tienen la misma
estructura; sin embargo, muchos de los modernos comparten la meta de soportar los componentes del sistema
que se describen en las siguientes secciones.
2.1. ADMINISTRACIÓN DE PROCESOS
Todas las computadoras modernas son capaces de hacer varias cosas al mismo tiempo. A la vez que ejecuta un
programa de usuario, una computadora puede leer de un disco e imprimir en una terminal o impresora. En un
sistema de multiprogramación, la CPU también alterna de programa en programa, lo que da una apariencia de
que se ejecutan de forma simultánea, aunque, en sentido estricto, la CPU ejecuta en un cierto instante un solo
programa.
Todo proceso necesita recursos, incluyendo tiempo de CPU, memoria, archivos y dispositivos de E/S, para
realizar una tarea. Estos recursos son dados al proceso por el sistema cuando se crea, o bien le son asignados
mientras está en ejecución. Además de los diversos recursos físicos y lógicos que obtiene un proceso al crearse,
puede recibir al mismo tiempo varios datos de inicialización. Por ejemplo, considere un proceso cuya función es
mostrar el estado de un archivo en la pantalla de una terminal. Al proceso se le dará como entrada el nombre de
archivo, y se ejecutará las instrucciones apropiadas y las llamadas al sistema para obtener y exhibir en la terminal
la información deseada. Cuando el proceso termina, el sistema operativo reclamará todos los recursos
reutilizables.
Por todo ello, el sistema operativo es responsable de las siguientes actividades relacionadas con la
administración de procesos:
□ Crear y eliminar procesos de usuario y procesos del sistema.

□ Suspender y continuar procesos.
□ Proporcionar mecanismos para la sincronización de procesos.
□ Proporcionar mecanismos para la comunicación de procesos.
□ Proporcionar mecanismos para el manejo de bloqueos mutuos entre procesos.
2.2. ADMINISTRACIÓN DE LA MEMORIA PRINCIPAL
La parte del sistema operativo que administra la memoria se llama administrador de memoria. Su labor consiste
en llevar un registro de las partes de memoria que se están utilizando y aquellas que no, con el fin de asignar
espacio en memoria a los procesos cuando éstos la necesiten y liberarlo cuando terminen, así como administrar
el intercambio entre la memoria principal y el disco, en los casos en que la memoria principal no pueda albergar a
todos los procesos.
Para que un programa se ejecute, debe convertirse en un mapa de direcciones absolutas y cargarse en memoria.
Transcurrido cierto tiempo, el programa termina, su espacio de memoria se declara disponible, y el siguiente
programa puede cargarse y ejecutarse.
Para mejorar tanto el uso de CPU como la velocidad de respuesta de la computadora, debemos almacenar varios
programas en memoria. Existen muchos esquemas diferentes para administrar la memoria. Estos esquemas
reflejan diversos enfoques para la administración de la memoria, y la eficacia de los diferentes algoritmos
depende de la situación concreta. La selección de un esquema de administración para un sistema específico
depende de muchos factores, especialmente del diseño del hardware del sistema.
Por tanto, el sistema operativo es responsable de las siguientes actividades relacionadas con la administración de
la memoria:
□ Llevar un registro de las partes de la memoria que están siendo utilizadas en ese momento y quién las
está utilizando.
□ Decidir qué procesos se van a cargar en la memoria cuando el espacio de la misma esté disponible.
□ Asignar y liberar espacio de la memoria según se necesite.
2.3. ADMINISTRACIÓN DE ARCHIVOS
La administración de archivos es uno de los componentes más visibles en un sistema operativo. Las
computadoras pueden almacenar información en varios tipos de medios físicos. Los discos duros, disquetes, CD,
DVD… son los medios más comunes. Cada uno de éstos tiene sus propias características y organización física.
A su vez, cada medio es controlado por un dispositivo que también tiene características propias y únicas. Estas
propiedades incluyen velocidad de acceso, capacidad, velocidad de transferencia de datos, etc.
Para un uso conveniente del ordenador, el sistema operativo debe proporcionar una vista lógica uniforme del
almacenamiento de la información. Este sistema hace una abstracción de las propiedades físicas de sus
dispositivos de almacenamiento para definir una unidad de almacenamiento lógico, el archivo.
Un archivo es un conjunto de información relacionada definida por su creador. Comunmente, los archivos
representan programas y datos. Los archivos de datos pueden ser numéricos, alfabéticos o alfanuméricos.
Asimismo, pueden tener formato libre (por ejemplo, archivos de texto), o pueden tener un formato específico (por
ejemplo, campos fijos). Un archivo consta de una secuencia de bits, bytes, líneas o registros, cuyos significados
son definidos por sus creadores. El concepto de archivo es un concepto muy general.
El sistema operativo es responsable de las siguientes actividades relacionadas con la administración de archivos:
□ Crear y eliminar archivos.

□ Crear y eliminar directorios.
□ Dar soporte a primitivas para la manipulación de archivos y directorios.
□ Hacer un mapa de los archivos.
□ Respaldar archivos en medios de almacenamiento estables (no volátiles).
2.4. ADMINISTRACIÓN DEL SISTEMA DE E/S
Uno de los principales propósitos de un sistema operativo es ocultar al usuario las peculiaridades de los
dispositivos específicos del hardware.
El subsistema de E/S consta de:
□ Un componente de administración de memoria que incluye manejo de buffers, asignación de caché y

spooling (operación simultánea de periféricos en línea).
□ Una interfaz general de manejadores de dispositivo.
□ Controladores para dispositivos de hardware específicos.
Sólo el manejador de dispositivos conoce las peculiaridades del dispositivo específico al cual está asignado.
2.5. ADMINISTRACIÓN DEL ALMACENAMIENTO SECUNDARIO
El propósito general de un sistema de cómputo es ejecutar programas. Estos programas junto con los datos a los
que acceden, deben estar en la memoria principal, o almacenamiento primario, durante la ejecución. Debido a
que la memoria principal es muy pequeña para albergar todos los datos y programas, y dado que los datos que
contiene se pierden cuando se interrumpe la energía, el sistema de cómputo debe proporcionar un
almacenamiento secundario como respaldo para la memoria principal.
La mayoría de los ordenadores modernos emplean discos como el principal medio de almacenamiento, tanto para
programas como para datos. La mayoría de los programas están almacenados en el disco hasta que se cargan
en memoria para ser ejecutados, y luego utilizan el disco como fuente y destino de su procesamiento. Por lo tanto
la administración correcta del almacenamiento en disco se convierte de vital importancia en cualquier sistema
operativo.
El sistema operativo es responsable de las siguientes actividades relacionadas con la administración de discos:
□ Administración del espacio libre.

□ Asignación de almacenamiento.
□ Planificación del disco.
2.6. OPERACIÓN EN RED
Un sistema distribuido es un conjunto de procesadores que no comparten memoria, dispositivos periféricos ni un

reloj. En su lugar, cada procesador tiene su propia memoria y reloj local, y los procesadores se comunican entre
ellos mediante varias líneas de comunicación, como buses de alta velocidad o redes. Los procesadores en un
sistema distribuido varían en tamaño y en función.
Los procesadores en el sistema están conectados mediante una red de comunicación, la cual se puede configurar
de diferentes formas. La red puede estar total o parcialmente conectada. El diseño de la red de comunicación
debe considerar las estrategias de asignación de rutas para mensajes y las estrategias de conexión, así como los
problemas de contención y seguridad.
Un sistema distribuido reúne varios sistemas físicos distintos, posiblemente heterogéneos, en un solo sistema
coherente, proporcionando al usuario el acceso a los diversos recursos que el sistema mantiene. El acceso a un
recurso compartido permite una aceleración del cómputo, mayor funcionalidad y disponibilidad de los datos y una
mejora en la fiabilidad.
2.7. SISTEMA DE PROTECCIÓN
Si un ordenador tiene múltiples usuarios y permite la ejecución concurrente de varios procesos, entonces estos
procesos deben ser protegidos de las actividades de los demás. Para dicho fin, se incorporan mecanismos que
aseguran que los archivos, los segmentos de memoria, la CPU y otros recursos sean utilizados sólo por aquellos
procesos que cuentan con una autorización del sistema operativo.
Cuando hablamos de protección nos referimos a cualquier mecanismo que sirve para controlar el acceso de
programas, procesos o usuarios a los recursos definidos por un sistema de cómputo u ordenador.
Un recurso sin protección no puede defenderse ante el uso (o abuso) de un usuario no autorizado o
incompetente. Un sistema orientado a la protección proporciona un medio para distinguir entre un uso autorizado
y otro no autorizado.
2.8. SISTEMA DE INTÉRPRETE DE COMANDOS
Uno de los programas del sistema más importante para un sistema operativo es el intérprete de comandos, que
es la interfaz entre el usuario y el sistema operativo. Algunos sistemas operativos incluyen el intérprete de
comandos en su kernel o núcleo. Otros sistemas operativos, como MS-DOS y UNIX, tratan al intérprete de
comandos como un programa especial que se ejecuta al iniciar un trabajo.
Muchos comandos se transmiten al sistema operativo mediante sentencias de control. Cuando se inicia un trabajo
nuevo en un sistema por lotes, o cuando un usuario se conecta a un sistema de tiempo compartido, se ejecuta
automáticamente un programa que lee e interpreta estas sentencias de control. Este programa también se conoce
como intérprete de línea de comandos, y con frecuencia se denomina shell. Su función es simple: obtener la
siguiente sentencia de comandos y ejecutarla.
Los sistemas operativos difieren en el área del shell, con un intérprete de comandos amigable con el usuario que
permite que el sistema sea simple para algunos usuarios. Un estilo de interfaz amigable es el sistema de menús y
ventanas basado en el uso de ratón, empleado en Macintosh y en Windows. El ratón se mueve para posicionar el
apuntador sobre imágenes, o iconos, los cuales están en la pantalla y representan programas, archivos y
funciones del sistema. Algunos usuarios prefieren otros intérpretes de comandos más poderosos, complejos y
difíciles de aprender. En estos intérpretes, los comandos se introducen desde el teclado y se exhiben en una
pantalla o terminal de impresión, con la tecla de entrada o retorno (enter) señalando que un comando está
completo y listo para ser ejecutado. Los intérpretes de MS-DOS y UNIX funcionan de esta forma.
3. GESTIÓN MULTITAREA
Un sistema operativo de tiempo compartido o multitarea permite a varios usuarios compartir una computadora
simultáneamente. Debido a que cada acción o comando en un sistema de tiempo compartido tiende a ser corta,
sólo se necesita un poco de tiempo de CPU para cada usuario. Como el sistema cambia rápido de un usuario al
siguiente, cada usuario tiene la impresión de que todo el sistema de cómputo está dedicado para su uso, pero en
realidad la computadora está siendo compartida por muchos usuarios.
Un sistema operativo de tiempo compartido hace uso de la planificación de la CPU y la multiprogramación para
proporcionar a cada usuario una pequeña porción de tiempo. Cada usuario tiene por lo menos un programa
distinto en memoria. Un programa que se carga en la memoria y se está ejecutando se le conoce como proceso.
Cuando se ejecuta un proceso, éste lo hace sólo por un tiempo breve antes de que termine o necesite realizar
operaciones de E/S. Las operaciones de E/S pueden ser interactivas; es decir, la entrada es desde el teclado, el
ratón u otro dispositivo y la salida es a una pantalla, impresora, etc. Debido a que las acciones de E/S interactivas
se efectúan a las velocidades de los humanos, requieren mucho tiempo para completarse. La entrada, por
ejemplo, está limitada por la velocidad del usuario para teclear; siete caracteres por segundo es una captura
rápida para las personas, pero es increíblemente lenta para los ordenadores. En lugar de dejar a la CPU ociosa
cuando tiene lugar esta entrada interactiva, el sistema operativo asignará rápidamente el programa de algún otro
usuario.
La idea del tiempo compartido se demostró desde principios de la década de 1960, pero debido a que los
sistemas de tiempo compartido eran difíciles y costosos de construir, no se volvieron comunes sino hasta
principios de la década de 1970. Aun cuando todavía se realiza algún procesamiento por lotes, la mayoría de los
sistemas de hoy en día son de tiempo compartido. De acuerdo a esto, la multiprogramación y el tiempo
compartido son los temas centrales de los sistemas operativos modernos.
3.1. CONCEPTO DE PROCESO
Informalmente, un proceso es un programa en ejecución. Un proceso es más que el código del programa.
También incluye la actividad actual, representada por el valor del contador de programa y el contenido de los
registros del procesador. Un proceso por lo general también incluye la pila del proceso, que contiene datos
temporales (parámetros de método, direcciones de retorno y variables locales) y una sección de datos, que
contiene variables globales.
Hacemos énfasis en que un programa por sí mismo no es un proceso. Un programa es una entidad pasiva, tal
como el contenido de un archivo almacenado en disco, en tanto que un proceso es una entidad activa, con un
contador de programa que especifica la siguiente instrucción a ejecutarse en un conjunto de recursos asociados.
3.2. BLOQUE DE CONTROL DEL PROCESO
Cada proceso se representa en el sistema operativo mediante un bloque de Estado

control del proceso (Process Control Block, PCB), también denominado bloque de Apuntador del
proceso
control de tarea. Número de proceso
Contador de programa
Dicho bloque de control está compuesto por varios campos: Registros
Límites de la memoria
□ Estado del proceso. El estado puede ser nuevo, listo, ejecución, espera, Lista de
Archivos abiertos
detenido, etc.
.
□ Contador del programa. El contador indica la dirección de la siguiente .
instrucción a ejecutar.
□ Registros de la CPU. Cada vez que un proceso deja de estar en
ejecución, se debe almacenar el estado de todos los registros internos de la CPU, tales como
acumuladores, registros índice, apuntadores de pila, registros de propósito general, etc.
□ Información de planificación de la CPU. Incluye la prioridad del proceso, apuntadores a colas de
planificación, etc.
□ Información de administración de la memoria. Puede incluir datos referentes al valor de los registros base
y límite, las tablas de páginas, o las tablas de segmentos.
□ Información contable. Incluye la cantidad de tiempo de la CPU y tiempo real usado, así como los límites
de tiempo, número total de trabajos realizados, etc.
□ Información del estado de E/S. Incluye la lista de dispositivos de E/S asignados al proceso, una lista de
archivos abiertos, etc.
3.3. ESTADOS DE PROCESO
Aunque cada proceso es una entidad independiente, con su propio contador de programa y estado interno, es
frecuente que los procesos deban interactuar unos con otros. Un proceso podría generar cierta salida que fuera
utilizada por otro.
Cuando un proceso se bloquea, lo hace porque desde el punto de vista lógico no puede continuar. Esto ocurre,
por lo general, porque espera ciertos datos que no están disponibles todavía. También es posible que se detenga
un proceso que conceptualmente esté listo y que se pueda ejecutar, debido a que el sistema operativo ha
decidido asignar la CPU a otro proceso en cierto momento. Estas dos condiciones son totalmente distintas. En el
primer caso, la suspensión es inherente al problema (no se puede procesar la línea de comando del usuario hasta
que ésta sea escrita). En el segundo caso, es un aspecto técnico del sistema (no existe la CPU suficiente como
para darle a cada proceso su propio procesador privado).
Los posibles estados de un proceso son:
□ En ejecución: utiliza la CPU en el instante dado.

□ Listo: se detiene de forma temporal para que se ejecute otro proceso
□ Bloqueado: no se puede ejecutar debido a algún evento externo.
Desde el punto de vista lógico, los dos primeros estados son similares. En ambos casos, el proceso desea
ejecutarse, sólo que en el segundo caso, no existe CPU disponible para él. El tercer estado es distinto de los
otros, puesto que el proceso no se puede ejecutar, incluso aunque la CPU no tenga labores que realizar.
Son posibles cuatro transiciones entre estos estados:
□ La transición 1 ocurre cuando un proceso descubre que no puede continuar. En ciertos sistemas, el
proceso debe ejecutar una llamada al sistema, BLOCK, para pasar al estado de bloqueo. Lo más
frecuente es que un proceso lea de un tubo o archivo especial (por ejemplo, una terminal) y que no
existan datos disponibles, por lo que el proceso se bloquea de forma automática.
□ La transición 2 ocurre cuando el planificador decide que el proceso en ejecución ya ha sido ejecutado el
tiempo suficiente y, que es hora que otro proceso tenga tiempo de CPU.
□ La transición 3 ocurre cuando los demás procesos han tenido su parte de CPU y es tiempo de que el
primer proceso vuelva a ejecutarse,
□ La transición 4 aparece cuando ocurre el evento externo por el que espera un proceso (como la llegada
de nuevos datos). Si no existe otro proceso en ejecución en ese momento, se produce la transición 3 de
forma inmediata y el proceso comienza su ejecución. En caso contrario, tendría que esperar en estado de
listo por un momento, hasta que la CPU esté disponible.
Nuevo Terminado
Interrupción (2)
Admitido Salir
Listo Ejecución
Planificador (3)
Terminación de
E/S o evento (4) Espera de E/S o evento (1)
Espera
3.4. COMUNICACIÓN ENTRE PROCESOS
Para que dos procesos puedan comunicarse y de este modo compartir información, se requiere que exista un
enlace de comunicaciones entre ambos. Este enlace puede implementarse de varias formas. En este apartado
tan sólo nos ocuparemos de la implementación lógica.
3.4.1. COMUNICACIÓN DIRECTA
Cada proceso que quiere comunicarse con otro debe nombrar explícitamente al receptor de la comunicación. En
este esquema las primitivas de comunicación son:
□ Send (P, mensaje). Enviar un mensaje al proceso P.
□ Receive (Q, mensaje). Recibir un mensaje del proceso Q.
Un enlace de comunicación en este esquema tiene las siguientes propiedades:
□ Un enlace se establece automáticamente entre cada par de procesos que desean comunicarse.
□ Un enlace está asociado exactamente con dos procesos.
□ Entre cada par de procesos, existe exactamente un enlace.
3.4.2. COMUNICACIÓN INDIRECTA
En la comunicación indirecta los mensajes se envían y reciben de buzones, o puertos. Un buzón puede verse, de
manera abstracta, como un objeto en donde los procesos pueden colocar y borrar mensajes. Cada buzón tiene un
identificador único. Las primitivas de este esquema son:
□ Send (A, mensaje). Enviar un mensaje al buzón A.

□ Receive (A, mensaje). Recibir un mensaje del buzón A.
Entre sus principales propiedades cabe destacar:
□ Se establece un enlace entre un par de procesos sólo si ambos miembros tienen un buzón compartido.
□ Un enlace puede estar asociado con más de dos procesos.
□ Entre cada par de procesos en comunicaciones, puede haber varios enlaces diferentes, y cada enlace
corresponde a un buzón.
3.4.3. USO DE BUFFERS
Tanto en la comunicación directa como en la indirecta, los mensajes intercambiados residen en una cola
temporal. Básicamente existen tres formas de implementar dicha cola:
□ Capacidad cero. La cola tiene una longitud máxima de cero mensajes. De esta forma, el enlace no puede
tener mensajes esperando en él. En este caso, el emisor debe bloquearse hasta que el receptor obtenga
el mensaje.
□ Capacidad limitada. La cola tiene una longitud finita igual a n. En este caso a lo sumo n mensajes pueden
residir en ella. Si la cola no está llena cuando se envía el nuevo mensaje, éste se coloca en la cola. En
caso contrario el emisor se bloquea al igual que en el caso de capacidad cero.
□ Capacidad ilimitada. De esta forma el emisor nunca se bloquea.
4. PROTECCIÓN DE MEMORIA
4.1. PROTECCIÓN DEL SISTEMA OPERATIVO MEDIANTE HARDWARE
En todo sistema operativo existen unos mecanismos, las interrupciones, encargadas de establecer la
comunicación entre la CPU y los periféricos. Cuando un dispositivo necesita utilizar la CPU, modifica ciertas
banderas de un registro especial. Cuando la CPU se da cuenta del cambio de estos flags (banderas), pasa a
ejecutar la rutina de atención a la interrupción o manejador de interrupción, obteniendo el periférico el uso
exclusivo de la CPU. Existe un vector de interrupción en el que se almacenan las direcciones de los manejadores
de interrupciones correspondientes a cada una de las especificadas por el sistema (interrupciones de pantalla,
teclado, reloj…).
Para asegurar una operación correcta, debemos proteger el vector de interrupción para que no sea modificado
por un programa de usuario. Además, también debemos proteger a las rutinas de servicio de interrupción para
que tampoco sean modificadas. De lo contrario, un programa de usuario podría sobrescribir instrucciones en
alguna rutina de servicio con saltos al programa de usuario, obteniendo de esta forma control desde dicha rutina.
Así, vemos que es necesario proporcionar resguardo a la memoria por lo menos para el vector de interrupción y
las rutinas de servicio de las mismas en el sistema operativo. En general, queremos cuidar el sistema operativo
para que los programas de usuario no tengan acceso a él y, además, proteger a los programas de usuario entre
sí. Este amparo debe ser proporcionado por el hardware.
Lo que necesitamos para separar el espacio de memoria de cada programa es la habilidad para determinar el
rango de direcciones legales al que un programa puede acceder, y proteger a la memoria fuera de dicho espacio.
Podemos proporcionar esta protección usando dos registros, por lo general uno base y uno límite. El registro base
contiene la dirección física de memoria menor o inicial válida; el registro límite posee el tamaño del rango. Por
ejemplo, si el registro base abarca 300040 y el registro límite es 120900, entonces el programa puede acceder en
forma válida a todas las direcciones desde 300040 hasta 420940, ambos inclusive.
Esta protección se realiza mediante el hardware de la CPU, comparando cada dirección generada en modo de
usuario con los registros. Cualquier intento de un programa que se está ejecutando en modo de usuario por
acceder a la memoria del monitor o a la memoria de otros usuarios da como resultado que se active una
interrupción que se comunica al monitor, el cual trata el intento como un error fatal. Este esquema impide que el
programa de usuario (accidental o deliberadamente) modifique el código o las estructuras de datos, ya sea del
sistema operativo o de otros usuarios.
Los registros base y límite sólo pueden ser cargados por el sistema operativo, el cual emplea una instrucción
privilegiada especial. Dado que las únicas que pueden ejecutar en modo de monitor son instrucciones
privilegiadas, y debido a que sólo el sistema operativo ejecuta en modo de monitor, únicamente el sistema
operativo puede cargar los registros base y límite. Este esquema permite que el monitor cambie el valor de los
registros, pero impide que los programas de usuario cambien los contenidos de estos.
0
Monitor
256000
Trabajo 1 Registro base
300040
Trabajo 2 Registro límite
420940
Trabajo 3
880000
Trabajo 4
1024000
Al sistema operativo, ejecutado en modo de monitor, se le da acceso sin restricciones tanto a la memoria del
monitor como a la memoria de los usuarios. Esta provisión permite al sistema operativo cargar programas de
usuarios en la memoria de los usuarios, hacer un vaciado de dichos programas en caso de errores, tener acceso
y modificar parámetros de llamadas al sistema, etcétera.
Base Base + límite
Dirección
SI SI
CPU >= <
NO NO
Interrupción al monitor del sistema Memoria

operativo – error de direccionamiento -
4.2. PROTECCIÓN ENTRE PROCESOS CONCURRENTES
A la hora de trabajar con procesos nos damos cuenta que hace falta una serie de mecanismos para controlar el
acceso a memoria de los posibles procesos que se estén ejecutando en un momento dado. De no ser así cada
proceso podría leer y escribir en una zona de memoria compartida a su gusto, pudiendo ocasionar serios
problemas a otros procesos cooperantes.
Cuando alguien intenta acceder a una zona de memoria compartida, tiene que estar seguro que la información
que lee o escribe de ella es exactamente la que se desea, sin que se vea alterada por otros procesos.
4.2.1. CONDICIONES DE COMPETENCIA ENTRE PROCESOS
En algunos sistemas operativos, los procesos que trabajan juntos comparten con frecuencia un espacio común
para almacenamiento, en el que cada uno puede leer o escribir. El espacio compartido puede estar en la memoria
principal o ser un archivo; la localización de la memoria compartida no modifica la naturaleza de la comunicación
o los problemas que puedan surgir. Para examinar la forma en que la comunicación entre procesos se lleva a
cabo en la práctica, consideremos un ejemplo sencillo pero común, un spooler de impresión. Cuando un proceso
desea imprimir un archivo, escribe el nombre del archivo en un directorio spooler particular. Otro proceso,
demonio para paginación, verifica de forma periódica si existen archivos por imprimir y, en caso afirmativo, los
imprime para después eliminar sus nombres de dicho directorio.
Imaginemos que el directorio spooler tiene un enorme número (infinito en potencia) de entradas, numeradas 0, 1,
2… cada una de las cuales puede almacenar el nombre de un archivo. Imaginemos también que existen dos
variables compartidas: out, que apunta hacia el siguiente archivo por imprimir, e in, que apunta hacia la siguiente
entrada libre dentro del directorio. Estas dos variables pueden conservarse en un archivo de dos palabras,
disponible para todos los procesos. En cierto instante, las entradas del 0 al 3 están vacías (los archivos ya se
imprimieron) y las entradas del 4 al 6 están ocupadas (con los nombres de los archivos que esperan turno para la
impresión). De forma más o menos simultánea, los procesos A y B deciden colocar un archivo en la fila de
impresión.
.
.
.
4 Abc
5 Prog. C out = 4
Proceso A 6 Prog. N
7 in = 7
Proceso B
.
.
.
En las jurisdicciones donde la ley de Murphy es aplicable, podría ocurrir lo siguiente. El proceso A lee in y,
almacena su valor, 7, en una variable local llamada next_free_slot. Es entonces cuando ocurre una interrupción
de reloj y la CPU decide que el proceso A ya ha estado en ejecución el tiempo suficiente, por lo que alterna con el
proceso B. El proceso B también lee in, y también obtiene un 7, por lo que almacena el nombre de su archivo en
el espacio 7 y actualiza in con 8. Después, sale y hace otras cosas.
En cierto momento, el proceso A vuelve a ejecutarse, a partir del momento en que se abandonó. Revisa
next_free_slot, encuentra un valor de 7 y escribe el nombre de su archivo en el espacio 7, con lo cual elimina el
nombre que el proceso B acaba de colocar. Después calcula next_free_slot + 1, que es igual a 8, y da a in el valor
de 8.
El directorio spooler tiene consistencia interna, por lo que el demonio para paginación no observará nada raro; sin
embargo, el proceso B nunca obtendrá ningún resultado.
4.2.2. SECCIONES CRÍTICAS
En algunas ocasiones un proceso puede tener acceso a la memoria compartida, y realiza labores críticas que
pueden llevar a conflictos. Esa parte del programa, en la cual se tiene acceso a la memoria compartida se llama
sección crítica. Si podemos arreglar las cosas de forma que no ocurra que dos procesos estén al mismo tiempo
en su sección crítica, podremos evitar las condiciones de competencia.
Aunque esta condición evita conflictos, no es suficiente para que los procesos paralelos cooperen de forma
correcta y usen de modo eficaz los datos compartidos. Necesitamos cuatro condiciones para poder obtener una
buena solución:
□ Dos procesos no deben encontrarse al mismo tiempo dentro de sus secciones críticas (exclusión mutua).
□ No se debe hacer hipótesis sobre la velocidad de la CPU.
□ Ninguno de los procesos que estén en ejecución fuera de su sección crítica puede bloquear a otros
procesos.
□ Ningún proceso debe esperar eternamente para entrar a su sección crítica.
4.2.3. EXCLUSIÓN MUTUA
En este apartado examinaremos varios métodos para lograr la exclusión mutua, de tal forma que si un proceso
está ocupado con la actualización de la memoria compartida en su región crítica, ningún otro proceso entre a su
región crítica y provoque problemas.
En la actualidad la mejor forma de afrontar la exclusión mutua es mediante las herramientas que nos ofrece el
sistema operativo para estos fines. El uso de semáforos, mensajes, etc. son cada vez más utilizados. Pero ahora
explicaremos otros métodos más rudimentarios, ya que se tratan de la base de los actuales.
4.2.3.1. DESACTIVACIÓN DE INTERRUPCIONES
La solución más simple es que cada proceso desactive todas sus interrupciones justo antes de entrar en su
sección crítica y las active de nuevo una vez que saliera de ella. Al desactivar las interrupciones no puede ocurrir
una interrupción de reloj. Después de todo, la CPU sólo se activa de proceso en proceso como resultado del reloj
y otros interruptores, por lo que con las interrupciones desactivadas la CPU no alternará con otro proceso.
Esta solución es poco atractiva ya que dotar a un proceso con la capacidad de desactivar las interrupciones del
sistema es algo muy peligro. Supongamos que las desactiva y que por cualquier circunstancia no las volviera a
activar, el ordenador se quedaría bloqueado.
4.2.3.2. VARIABLES DE CERRADURA
Como un segundo intento, analicemos una solución software. Consideremos el caso en el que tenemos una sola
variable compartida de cerradura. Si se desea que un proceso entre en su región crítica, primero se hace una
prueba de la cerradura. Si ésta es 0, el proceso cambia el valor a 1 y entra a la región crítica. Si ésta ya valía 1, el
proceso sólo se espera hasta que obtiene el valor 0. Así, un 0 indica que ningún proceso se encuentra en su
sección crítica.
Por desgracia, esta idea contiene el mismo error fatal que vimos con el directorio spooler. Supongamos que un
proceso lee la cerradura y obtiene un valor 0. En ese mismo instante se pasa el control de CPU a otro proceso,
que también lee el valor 0, por lo que entra en su sección crítica y la pone la cerradura a 1. Si ahora se pasa el
control al primer proceso, ambos estarían dentro de su sección crítica; incumpliendo de este modo, una de las
condiciones para garantizar la integridad del sistema.
4.2.3.3. SOLUCIÓN DE PETERSON
El matemático holandés T. Dekker, combinó la idea de turnos con las variables de cerradura, y fue el primero en
diseñar una solución software al problema de exclusión mutua.
El algoritmo que propuso Dekker era el siguiente:
#define N 2 /* Número de procesos. */

int turn; /* ¿de quién es el turno? */
int interested[N] /* Los valores iniciales son FALSE */
void enter_region (int process) /* Proceso que entra (0 o 1) */

{
int other; /* Número de los otros procesos */
other = 1 – process; /* El opuesto del proceso */

interested[process] = TRUE; /* Muestra que usted está interesado,*/
turn = process; /* Establece la bandera. */
while (turn == process && interested[other] == TRUE {})
}
void leave_region (int process) /* Proceso quién sale (0 o 1) */
{
interested[process] == FALSE; /* indica salida de la región crítica. */
}
Supongamos que tenemos dos procesos (0 y 1). En un cierto instante de tiempo el proceso 0 quiere entrar en su
región crítica; como no lo ha solicitado ningún otro proceso, indica que está interesado (interested[0] = TRUE) y
entra sin esperar. De pronto el proceso 1 desea también entrar en dicha región, lo indica poniendo interested[1] a
TRUE, pero se queda esperando en el bucle (ya que interested[other] es TRUE). De este modo el proceso 1 no
podrá utilizar la sección crítica hasta que el 0 no haya salido de ella. Ahora supongamos que ambos procesos
intentan entrar en su sección crítica casi al mismo tiempo. Quien ejecuta primero enter_region es el proceso 0,
con lo que actualiza interested[0] a TRUE y pone turn a 0. Pero antes de llegar al bucle, se pasa el control de la
CPU al proceso 1, poniendo interested[1] a TRUE, y cambiando turn a 1 (ya que sólo se guarda el último cambio
de la variable). De este modo, el proceso 0 se quedaría esperando en el bucle hasta que el 1 saliera de la región
crítica.
5. SISTEMAS DE ARCHIVOS
Todas las aplicaciones necesitan almacenar y recuperar la información. Al ejecutarse un proceso, éste puede
almacenar una cantidad limitada de información dentro de su propio espacio de direcciones. Sin embargo, la
capacidad de almacenamiento queda restringida, a lo más, al tamaño del espacio de direcciones virtuales. Para
algunas aplicaciones, este tamaño es adecuado, pero para otras muchas se queda demasiado pequeño.
El segundo problema relativo al almacenamiento de la información dentro del espacio de direcciones es que,
cuando el proceso termina, la información se pierde. En el caso de diversas aplicaciones (por ejemplo, bases de
datos), la información debe conservarse por semanas, meses, o aún para siempre. Desaparecer esta información
al momento de terminación del proceso es inaceptable.
Un tercer problema, en el caso de varios procesos, es que se requiere con frecuencia el acceso a la información
al mismo tiempo. Si tenemos almacenado un directorio telefónico en línea dentro del espacio de direcciones de un
solo proceso, únicamente ese proceso podrá tener acceso a él, por lo que sólo se podrá buscar un número
telefónico a la vez. La forma de resolver este problema es hacer que la propia información sea independiente de
todos los procesos.
Así, tenemos tres condiciones esenciales para el almacenamiento de la información a largo plazo:
□ Debe ser posible almacenar una cantidad muy grande de información.

□ La información debe sobrevivir una vez finalizado el proceso que la utiliza.
□ Debe ser posible que varios procesos tengan acceso concurrente a la información.
5.1. ARCHIVOS
Los archivos son un mecanismo de abstracción. Son una forma de almacenar información en un disco y volver a
leerla más adelante. Esto debe hacerse de forma que el usuario quede protegido contra los detalles de forma y
lugar de almacenamiento de la información.
Muchos sistemas operativos utilizan nombres de archivo con dos partes, separadas por un punto. La parte
posterior al punto es la extensión de archivo e indica por lo general algo relativo al archivo.
Los archivos se pueden estructurar de varias maneras. En la figura adjunta se muestran tres de ellas:
□ Serie no estructurada de bytes. Al sistema operativo no le interesa ni se preocupa por el contenido de los
archivos; cualquier significado debe ser impuesto por los programas de usuario. Tanto UNIX como MS-
DOS utilizan este enfoque. Proporciona una máxima flexibilidad.
□ Secuencia de registro de longitud fija. Cada uno de estos registros tiene su propia estructura interna.
Actualmente su uso se está cayendo en desuso.
□ Árbol de registros. Un archivo consta de un árbol de registros, los cuales no necesariamente tienen la
misma longitud, cada uno de ellos contiene un campo key en una posición fija del registro. El árbol se
ordena mediante este campo, con el fin de poder realizar búsquedas rápidas sobre él.
Árbol
Secuencia de Bytes Secuencia de registros
Los archivos de cualquier sistema operativo tienen asociados una serie de atributos. Algunos de los cuales se
muestran a continuación:
□ Protección. Quién debe tener acceso y de qué forma.

□ Contraseña. Contraseña necesaria para tener acceso al archivo.
□ Creador. Identificador de la persona que creó el archivo.
□ Longitud de registro. Número de bytes de un registro.
□ Tamaño actual. Número de bytes del archivo, etc.
5.2. DIRECTORIOS
Para llevar un registro de los archivos, los sistemas tienen por lo general directorios, los cuales, en muchos
sistemas, son a su vez archivos.
Un directorio contiene varios datos, uno por archivo. Al abrir un archivo, el sistema operativo busca en su
directorio hasta encontrar el nombre del archivo por abrir. Extrae entonces los atributos y direcciones en disco, y
los coloca en una tabla dentro de la memora principal. Todas las referencias subsecuentes al archivo utilizan la
información de la memoria principal.
Cuando el sistema de archivos está organizado en árbol de directorios, se necesita una forma de determinar los
nombres de los archivos. Se utilizan usualmente dos métodos:
□ Ruta de acceso absoluta. Consta de la ruta de acceso desde el directorio raíz.

□ Ruta de acceso relativo. Es relativa a la posición del archivo en el árbol de directorios.
5.3. IMPLANTACIÓN DEL SISTEMA DE ARCHIVOS
El aspecto clave de la implementación del almacenamiento de archivos es el registro de los bloques asociados a
cada archivo. En los siguientes apartados veremos los métodos más utilizados.
5.3.1. ASIGNACIÓN ADYACENTE
Se trata del esquema de asignación más simple. Almacena cada archivo como un bloque adyacente de datos en
el disco. Así, en un disco con bloques de 1K, un archivo de 50K tendría asignado 50 bloques consecutivos.
Sus principales ventajas son:
□ Fácil implementación.
□ Rendimiento excelente.
Pero como en todo, también tiene sus desventajas:
□ No es realizable al menos que se conozca el tamaño máximo del archivo cuando este se crea.
□ Fragmentación del disco. Se desperdicia mucho espacio.
5.3.2. ASIGNACIÓN EN FORMA DE LISTA LIGADA
El segundo método es mantener con cada archivo una lista ligada de bloques en disco; en el que la primera
palabra de cada bloque se utiliza como apuntador al siguiente.
Las ventajas de este método son:
□ Se aprovecha todo el espacio de disco.

□ Basta que la entrada del directorio guarde sólo la dirección del primer bloque.
Pero a su vez tiene algunas desventajas:
□ Aunque la lectura secuencial es directa, el acceso aleatorio es en extremo lento.

□ Se desperdicia espacio en almacenar los apuntadores.
0
Bloque Bloque Bloque Bloque
de de de de
archivo archivo archivo archivo
0 1 2 3
Bloque 4 7 2 10
Físico
5.3.3. ASIGNACIÓN MEDIANTE UNA LISTA LIGADA Y UN ÍNDICE
Las dos desventajas de la asignación mediante una lista ligada se pueden eliminar si se toma la palabra del
apuntador de cada bloque del disco y se coloca en una tabla o índice de memoria. La principal desventaja de este
método es que la tabla con los índices tiene que permanecer continuamente en memoria.
Bloque
Físico
0 14
1
2 10
3 11
El archivo A comienza aquí.
4 7
5
6 3 El archivo B comienza aquí.
7 2
8
9 12
10 14
11 0
12
13 0
14 FIN
En la imagen adjunta, se puede observar cómo se implementa un archivo mediante una lista ligada y un índice. Si
nos fijamos, cada una de las celdas de la tabla contiene el valor de un bloque físico de memoria. La primera
entrada del archivo A en la tabla coincide con el primer bloque físico de dicho archivo. El archivo A comienza en el
bloque 4 (celda número 4) cuyo contenido es un 7, esto quiere decir que el siguiente bloque del archivo A es el 7,
por lo que nos vamos a la celda 7 y obtenemos el siguiente bloque, así sucesivamente hasta que llegamos a una
celda especial que nos indica el final de fichero (celda 14).
5.3.4. NODOS-i
Este otro método consiste en asociar a cada archivo una pequeña tabla, llamada nodo-i (nodo índice), la cual
contiene los atributos y direcciones en disco de los bloques del archivo.
Las primeras direcciones en disco se almacenan en el propio nodo-i, de forma que en el caso de los archivos
pequeños, toda la información necesaria está contenida en el nodo-i. Para los archivos un poco más grandes, una
de las direcciones en el nodo-i es la dirección de un bloque en el disco llamado bloque simplemente indirecto.
Este bloque contiene las direcciones en disco adicionales. Si aún así, no es lo suficientemente grande, otra
dirección en el nodo-i, el bloque doblemente indirecto, contiene la dirección de un bloque que contiene una lista
de los bloques simplemente indirectos. Cada uno de estos bloques simplemente indirectos apunta a unos
centenares de bloques de datos. UNIX utiliza este esquema.
Bloque
Simplemente Bloque Bloque
Atributos indirecto Doblemente Triplemente
indirecto indirecto
Direcciones en disco
6. TECNOLOGÍA PLUG & PLAY (PnP)

La tecnología Plug and Play (PnP) permite a los usuarios añadir nuevas posibilidades insertando tarjetas
adicionales, sin preocuparse de complicados problemas de configuración del sistema. La combinación de un
sistema diseñado para PnP y tarjetas PnP permite la configuración automática de dichas tarjetas. Gracias al PnP,
los usuarios pueden adoptar rápidamente las nuevas tecnologías que de otra forma hubieran rechazado debido a
la complejidad de su configuración.
Una de las bazas más importantes del PC es la capacidad de ampliar las prestaciones del sistema añadiendo
tarjetas adicionales y periféricos. No obstante, la instalación y configuración de estos dispositivos ha venido
siendo un proceso difícil. Los usuarios que añaden una tarjeta ISA tradicional por primera vez suelen confiar en
que sea suficiente con abrir el PC e insertar la tarjeta, pero lo que se encuentran en realidad es que, durante la
instalación, deben de responder a varias preguntas técnicas y enfrentarse con la compleja tarea de configurar la
nueva tarjeta seleccionando el número de IRQ, puertos de E/S y el canal de DMA. Los usuarios deben colocar o
retirar puentes o ajustar conmutadores en las tarjetas adicionales. Deben saber exactamente qué recursos están
ya siendo utilizados por el sistema y encontrar un conjunto determinado de recursos que no entren en conflicto
con los dispositivos que ya están instalados. Y lo que es peor, el usuario no tiene forma de saber si existe algún
problema hasta que enciende el sistema. Si se produce algún conflicto, es posible que el sistema no arranque o
que falle el dispositivo hardware que ha producido el conflicto. Como resultado, el usuario tiene que llamar al
servicio técnico o devolver la tarjeta adicional.
PnP es la tecnología diseñada para evitar problemas de configuración y proporcionar a los usuarios la capacidad
de ampliar fácilmente las prestaciones de su PC. En un entorno PnP, el usuario sólo tiene que conectar la nueva
tarjeta y el sistema la configura para que trabaje correctamente. En este momento existen tres tipos de tarjetas
adicionales PnP: PCI, PCMCIA y PnP ISA.
6.1. FUNCIONAMIENTO DE PLUG & PLAY
La tecnología PnP está formada por cuatro componentes principales:
□ BIOS Plug and Play.
□ Datos de configuración de sistema ampliado ESCD (Extended System Configuration Data).
□ Administrador de configuración CM (Configuration Manager).
□ Unidad de configuración ISA ICU (ISA Configuration Utility).
Aplicaciones
Unidad de Base de datos

Configuración De configuración
ISA Del fabricante
Administrador de Configuración
CM
BIOS Plug & Play ESCD
La figura muestra cómo trabajan conjuntamente los cuatro componentes. La BIOS PnP inicia la configuración
automática de las tarjetas PnP durante el proceso de arranque. Si las tarjetas ya estaban instaladas
anteriormente, la BIOS lee la información de los ESCD, inicializa las tarjetas y, a continuación arranca el sistema.
Durante la instalación de tarjetas PnP nuevas, la BIOS consulta los ESCD para determinar qué recursos del
sistema están disponibles y son necesarios para la tarjeta adicional. Si la BIOS puede encontrar estos recursos,
entonces configurará la tarjeta. Sin embargo, si la BIOS no consigue compaginar los recursos, durante la
inicialización del sistema el CM completa el proceso de configuración automática. En este proceso, el CM
actualiza los registros de configuración (en BIOS Flash) de la tarjeta y permite que la BIOS actualice los ESCD
con los nuevos datos de configuración. El CM se carga automáticamente como un driver cuando se produce un
conflicto con la configuración de la tarjeta y la BIOS es incapaz de resolverlo.
La utilidad de configuración ISA (ICU) es el último componente de todo el sistema PnP. Su propósito principal es
ayudar al usuario a determinar una configuración sin conflictos para las tarjetas ISA estándar. Antes de la
instalación de la tarjeta, el usuario ejecuta esta utilidad para las configuraciones recomendadas. En base a la
selección del usuario, se actualizan los ESCD. La tarjeta se configura automáticamente con esta configuración y
se inserta en el sistema. La ICU se utiliza también para resolver los conflictos que no puedan solucionar la BIOS y
el CM.
6.2. USO DE PLUG & PLAY
PnP ahorra tiempo y reduce los costes de instalación/configuración tanto para el usuario como para el servicio
técnico. Los sistemas PnP pueden trabajar también con tarjetas adicionales existentes que no sean PnP. No
obstante, los usuarios deberían solicitar sistemas preparados para PnP y tarjetas adicionales PnP.
7. INTERFAZ DE USUARIO
Para que el usuario se entienda con la máquina hace falta un intermediario (o un conjunto de intermediarios) entre
ambos. En la "prehistoria" los intermediarios eran unas tarjetas perforadas que se metían en las gigantescas
máquinas y se sacaban otras tarjetas. Afortunadamente esos tiempos han pasado.
El intermediario recibe el nombre de interfaz de usuario y hay tantas posibilidades como quieras imaginar de
interfaz. Pero las dos que realmente se utilizan son:
□ La línea de comandos. Es la más antigua. En la pantalla no aparece nada más que un indicador de dónde
estás más o menos y uno va escribiendo las órdenes (copia este archivo, borra este archivo, ve a este
grupo de archivos, ejecuta este programa...) con el teclado y viendo los resultados.
□ La interfaz gráfica utiliza las ventanas y el ratón y es más moderna que la línea de comandos. Para ser
precisos, que la interfaz sea gráfica no implica que deba ser del tipo WIMP (Windows, Icons, Mouse,
Pointer), pero hoy en día es lo normal. Tiene la ventaja de que su manejo se aprende fácilmente por
medio de la exploración, pero esto no quiere decir que debamos olvidarnos de la otra interfaz de usuario.
La línea de comandos permite hacer con facilidad cosas que la interfaz gráfica no nos deja realizar.
8. SISTEMAS WINDOWS
8.1. INTRODUCCIÓN
En 1981 IBM lanzó el PC de IBM basado en el 8088. El PC venía equipado con un sistema operativo en modo
real de 16 bit monousuario, manejado por línea de comandos, llamado MS-DOS 1.0. Este sistema operativo había
sido proporcionado por Microsoft, una compañía naciente conocida por su intérprete de BASIC para sistemas
8080 y Z-80. Dos años más tarde salió a la luz un sistema operativo mucho más potente, llamado MS-DOS 2.0.
Este sistema incluía un procesador de línea de comandos (shell) con varias características tomadas de UNIX.
Con el paso de los años MS-DOS siguió adquiriendo nuevas funciones pero seguía siendo un sistema orientado a
la línea de comandos.
Inspirado en la interfaz de usuario de la Apple Lisa (la precursora de la Apple Macintosh), Microsoft decidió dar a
MS-DOS una interfaz gráfica, a la que denominó Windows. Windows 1.0 salió al mercado en 1985 pero no fue
hasta 1990 con la versión 3.0 y siguientes que Microsoft alcanzó un gran éxito comercial. Ninguna de estas
versiones cercanas era un sistema operativo sino más bien una interfaz gráfica de usuario colocada encima de
MS-DOS. Todos los programas se ejecutaban en el mismo espacio de direcciones y un error de programación en
cualquiera de ellos podía paralizar el sistema.
Windows 95 salió al mercado en 1995, no eliminó por completo MS-DOS aunque transfirió casi todas sus
funciones a la parte Windows. Juntos Windows 95 y MS-DOS 7.0 contenían casi todas las funciones de un
sistema operativo completo, incluidas memoria virtual, administración de procesos y multiprogramación. Windows
95 contenía grandes fragmentos de código de ensamblador antiguo de 16 bit, más algo en 32 bits, seguía usando
el sistema de archivos de MS-DOS con casi todas sus limitaciones. El único cambio importante al sistema de
archivos fue la adición de nombres de archivo largos en lugar de los nombres de 8+3 caracteres del MS-DOS.
Incluso en Windows 98 que salió al mercado en 1998, seguía presente el MS-DOS 7.1 y ejecutando código de 16
bits. Aunque había migrado más funcionalidad a la parte Windows y usaba de forma estándar una nueva
organización de discos FAT32, en su interior no era muy diferente de Windows 95. El cambio sustancial residía en
la más estrecha integración del escritorio e Internet.
Además de tener una gran parte de código ensamblador antiguo de 16 bits, Windows 98 presenta dos problemas:
□ Aunque Windows 98 era un sistema de multiprogramación, el kernel en sí, no era reentrante, si un

proceso se encontraba manipulando una estructura interna y se agotaba su cuanto de proceso, un
proceso a continuación podía encontrarse la estructura en un estado inconsistente provocando la caída
del sistema. Como solución se adoptó que los procesos, al entrar en el kernel, adquirieran un mutex
(bloqueo exclusivo) gigante que cubría todo el sistema, antes de ponerse a hacer algo. Aunque este
enfoque eliminaba las posibles inconsistencias, también eliminaba en gran parte la utilidad de la
multiprogramación, porque los procesos a menudo se veían obligados a esperar hasta que procesos no
relacionados salieran del kernel, para poder entrar en él.
□ Cada proceso de Windows 98 tenía un espacio de direcciones virtual de 4 GB, de éstos, 2 GB eran
completamente privados de cada proceso, pero el siguiente 1 GB se compartía (de forma escribible) con
todos los demás procesos del sistema. El 1 MB inicial también se compartía entre todos los procesos
para que todos pudieran tener acceso a los vectores de interrupción de MS-DOS. Casi todas las
aplicaciones de Windows 98 usaban de forma intensiva esta área compartida, por lo que un error en un
programa podía borrar estructuras de datos clave empleadas por otro proceso y hacer que todos fallaran.
Peor aún, el último 1 GB se compartía, de forma escribible con el kernel y contenía algunas estructuras
de datos cruciales para él. La solución de no colocar estructuras del kernel en el espacio de usuario no
era factible pues se precisaban para que los programas MS-DOS funcionaran bajo Windows 98.
En el año 2000 Microsoft sacó una modernización menor de Windows 98 llamada Windows ME (Windows
Millenium). Aunque se corregían algunos errores y se añadían unas funciones, en los aspectos internos era en
esencia igual a Windows 98. Las nuevas funciones incluían mejores formas de catalogar y compartir imágenes,
música y películas, más soporte para redes caseras y juegos multiusuario, y más funciones relacionadas con
Internet, como manejo de mensajería instantánea y conexiones de banda ancha. Una nueva función interesante
fue la capacidad de restaurar el ordenador a sus parámetros anteriores después de una configuración errónea.
8.1.1. WINDOWS NT
A finales de los años ochenta, Microsoft decidió producir un sistema operativo de 32 bits completamente nuevo y
compatible con Windows. Este sistema, llamado Windows NT (New Technologies) estaba pensado para
aplicaciones de negocios "de misión crítica" y para usuarios caseros. En 1993 sale la primera versión con la
denominación Windows NT 3.1. La reticencia de los usuarios a cambiarse al nuevo entorno, de mayores
requerimientos de máquina y menos software disponible, llevó a Microsoft a elaborar Windows 95 y después
Windows 98, indicando siempre que esa sería la última versión de un sistema basado en MS-DOS.
La primera modernización importante llegó de la mano de Windows NT 4.0, con un interfaz semejante a Windows
95, en 1996, lo que facilitó la migración desde Windows 95 a este nuevo sistema. Desde el principio NT, se
diseñó para que fuera portable. A continuación se muestra una tabla de diferencias entre Windows 95/98 y NT:
Elemento Windows 95/98 Windows NT

¿Sistema de 32 bits en su totalidad? No Sí
¿Seguridad? No Sí
¿Correspondencia de archivos protegidos? No Sí
¿Espacio de direcc. privado para cada prog. MS-DOS? No Sí
¿Unicode? No Sí
Ejecuta en Intel 80x86 80x86, Alpha…
¿Manejo de multiprocesadores? No Sí
¿Código reentrante dentro del SO? No Sí
¿Plug and Play? Sí No
¿Administración de Energía? Sí No
¿Sistemas de archivos FAT-32? Sí Opcional
¿Sistemas de archivos NTFS? No Sí
¿API Win32? Sí Sí
¿Ejecuta todos los programas MS-DOS antiguos? Sí No
¿Los usuarios pueden escribir datos cruciales del SO? Sí No
8.1.2. WINDOWS 2000
En 1999, Microsoft cambió el nombre de la siguiente versión de Windows NT 5.0 a Windows 2000, buscando
presentar un nombre neutral que todos los usuarios, tanto de Windows NT como de Windows 98 vieran como el
siguiente paso lógico en la evolución de ambos sistemas.
8.1.3. WINDOWS XP
Windows XP es el sistema operativo de Microsoft en el 2003. Existen dos versiones distintas, para los usuarios
domésticos está Windows XP Home Edition, mientras que para los usuarios técnicos está Windows XP
Profesional Edition que además cuenta con posibilidad de sincronización directa con portátiles que tengan esta
versión de este sistema operativo.
Las características más destacables de Windows XP Home Edition son:
□ Diseño visual más atractivo: Con un estilo más elegante y agrupación de ventanas por aplicación cuando
se ha llegado a una cierta cantidad tope.
□ Mayor capacidad multimedia: gestión de fotos, música y videos.
□ Más sencillo que todas las versiones anteriores.
□ Mayor soporte hardware y software.
Mientras que las del XP Profesional Edition son:
□ Más fiable, seguro y eficiente.

□ Privacidad optimizada.
□ Mejores opciones de colaboración (groupware).
□ Soporte más amplio para resolución de problemas y ayuda rápida.
□ Plataforma Microsoft.NET
8.2. VISIÓN GENERAL
Los sistemas operativos de Microsoft para los PCs de escritorio y portátiles pueden dividirse en tres familias: MS-
DOS; Windows para consumidor (Windows 95/98/Me) y Windows NT.
Una visión general de estas familias se ha visto al hablar de la historia de los sistemas Microsoft. Nos
centraremos ahora en Windows 2000 como sistema que supone la concurrencia de ambas familias Windows y el
abandono definitivo de los sistemas basados en MS-DOS.
Aunque es la evolución de Windows NT 4.0, incorpora funciones propias de Windows 98 como el soporte Plug
and Play, bus USB, IEEE 1394 (FireWire), IrDA y administración de energía, entre otras cosas. Se han incluido
además funciones no presentes en ningún sistema anterior de Microsoft como el Servicio de Directorio Activo,
seguridad con Kerberos, manejo de tarjetas inteligentes y una infraestructura para la administración del sistema
y objetos de trabajo. Además se ha extendido el principal sistema de archivos NTFS, para manejar archivos
cifrados, cuotas de ocupación, archivos enlazados, volúmenes dinámicos y el almacén de instancia única,
que funciona de manera que dos usuarios pueden compartir el mismo archivo enlazado hasta que uno de ellos
escribe en él, momento en el cual se crea una copia de forma automática.
Otra mejora muy importante es la internacionalización. Se han sacado las cadenas de texto incorporadas al
código y se han puesto en directorios distintos del sistema operativo. Windows 2000 cuenta con un solo binario
que funciona en cualquier lugar del mundo, decidiéndose en el momento de la instalación el idioma que se
utilizará. Windows 2000 utiliza internamente Unicode para poder manejar idiomas que no usan el alfabeto latino.
Windows 2000 no tiene MS-DOS. Dispone de una interfaz de línea de comandos que es una aplicación de 32 bits
que incluye la funcionalidad del antiguo MS-DOS además de otras funciones.
Por motivos comerciales, existen diferentes niveles de producto, que por ahora son Professional, Server,
Advanced Server y Datacenter Server , si bien el binario es el mismo, en el registro figura el nivel adquirido lo
que limita ciertas características, que se detallan en la siguiente tabla:
Versión RAM máx. CPUs Máx. clientes Tam. clúster Optimizado para
Professional 4 GB 2 10 0 Tiempo de respuesta
Server 4 GB 4 ilimitados 0 Vel. real de Transporte
Advanced Server 8 GB 8 ilimitados 2 Vel. real de Transporte
Datacenter Server 64 GB 32 ilimitados 4 Vel. real de Transporte
Una última diferencia es que los servidores incluyen algo de software adicional y la versión Datacenter cuenta con
herramientas adicionales para administrar trabajos grandes.
Existen tres tipos de componentes de modo de usuario:
DLLs,
subsistemas de entorno y
procesos de servicio.
Estos componentes colaboran para proporcionar a cada proceso de usuario una interfaz distinta de la interfaz de
llamadas al sistema Windows 2000. La tarea de las DLLs y de los subsistemas de entorno es implementar la
funcionalidad de la interfaz publicada. Mientras que la interfaz Win32 es la interfaz oficial, las interfaces POSIX y
OS/2 son, en la práctica subsistemas inútiles por sus limitaciones de funcionalidad, cuya existencia obedece más
a razones de imagen o imposición externa (caso de POSIX, por el gobierno americano) que a una intención de
apertura por parte de Microsoft.
Programa POSIX Programa Win32 Programa OS/2
Modo de usuario
Proceso de
servicio
Subsistema POSIX Subsistema Win32 Subsistema OS/2
Interfaz del sistema (NTDLL.DLL)
Servicios del Sistema
Modo de kernel
Adm. E/S
Adm. Adm. Adm. Adm. Adm. Adm. Adm. Adm. Adm.
Objetos procesos memoria seguridad caché PnP electr. config. LPC
GDI Win32
Sist. Arch
Kernel Control video
Capa de abstracción de hardware (HAL)
Hardware
Dado que el enlace estático de los programas de usuario con las bibliotecas de la API Win32 conllevaría un
tamaño enorme en los programas y un desperdicio de memoria, pues cada programa en ejecución tendría su
copia de estas bibliotecas, todas las versiones de Windows manejan bibliotecas compartidas, llamadas
bibliotecas de vínculos dinámicos (DLLs; Dinamic Link Libraries).
En la figura se muestran algunas de las DLLs más importantes, con indicación del número de funciones de
interfaz que publican y el modo en que se ejecutan.
Archivo Modo Funcs Contenido
hal.dll Kernel 95 Administración de hardware de bajo nivel, por ejemplo, E/S puertos
ntoskrnl.exe Kernel 1209 Sistema Operativo de Windows 2000 (kernel+ejecutivo)
win32k.sys Kernel - Muchas llamadas al sistema, incluidas casi todas las de gráficos.
ntdll.dll Usuario 1179 Despachador de modo de usuario a modo de kernel
csrss.exe Usuario 0 Proceso de subsistema de entorno Win32
kernel32.dll Usuario 823 Casi todas las llamadas al sistema centrales (no de gráficos)
gdi32.dll Usuario 543 Llamadas de fuentes, texto, color, pincel pluma, mapa de bits, paleta, dibujo, etc.
user32.dll Usuario 695 Llamadas de ventana, icono, menú, cursor, diálogo, Portapapeles, etc.
advapi32.dll Usuario 557 Llamadas de seguridad, criptografía, Registro, administración.
Windows necesita mantenerse al tanto de una gran cantidad de información acerca del hardware, el software y
los usuarios. En Windows 3.x esta información se almacenaba en cientos de archivos .ini (de iniciación) dispersos
por todo el disco. A partir de Windows 95, casi toda la información necesaria para arrancar y configurar el sistema
y adaptarlo al usuario actual se reunió en una gran base de datos central llamada Registro (registry).
El registro consiste en una colección de directorios, llamados claves, cada uno de los cuales contiene
subdirectorios (también claves) y entradas, llamadas valores.
Los valores o entradas contienen la información, cada valor tiene tres partes: un nombre, un tipo y los datos. El
nombre no es más que una cadena en Unicode, el tipo identifica los datos, pudiendo utilizar alguno de estos 7
tipos de datos estándar:
REG_BINARY almacena datos binarios arbitrarios, sin ningún tipo de reformato o análisis.
REG_DWORD guarda un valor entero largo de 32 bits (o palabra doble). Se emplea normalmente cuando una
entrada indica una cuenta o intervalo.
REG_SZ almacena una cadena de caracteres ordinaria Unicode. Puede tener cualquier longitud.
REG_EXPAND_SZ al igual que REG_SZ pero admite variables de sustitución predefinidas del sistema,
identificadas como %variable%. El sistema realiza la sustitución cuando se solicita el valor almacenado.
REG_MULTI_SZ es una colección, en un número arbitrario, de cadenas REG_SZ.
REG_FULL_RESOURCE_DESCRIPTOR es un tipo no utilizado por los usuarios directamente, codifica
información sobre los recursos de sistema requeridos por un dispositivo concreto.
REG_NONE es solo un contenedor, se utiliza para permitir la existencia de un valor de registro que no
contenga ninguna información.
En la raíz del registro, hay 5 claves predefinidas:
HKEY_LOCAL_MACHINE (HKLM) almacena todos los parámetros pertenecientes a la máquina local.

HKEY_USERS (HKU) contiene una entrada por cada usuario que haya iniciado una sesión previamente en el
ordenador. Cada entrada contiene los parámetros de configuración específicos de ese usuario.
HKEY_CURRENT_CONFIG (HKCC) guarda información relativa a la configuración actual del inicio del
sistema. Esta clave predefinida es en realidad un apuntador o enlace a una subsección dentro de HKLM.
HKEY_CURRENT_USER (HKCU) es un apuntador o enlace al perfil de usuario almacenado en HKU, para el
usuario que haya iniciado la sesión actual.
HKEY_CLASSES_ROOT (HKCR) enlaza las extensiones de archivo y los identificadores de clases OLE. Es
un apuntador o enlace a HKLM\Software\Classes.
Desde estas claves principales, se desarrolla una estructura jerárquica de claves y valores similar a los directorios
y archivos del sistema de ficheros.
8.3. GESTIÓN DE PROCESOS
Se trata de un verdadero sistema multitarea de 32 bits, con procesos protegidos de manera individual. Cada
proceso tiene un espacio de direcciones virtuales de 32 bits, paginado por demanda.
El sistema operativo se ejecuta en modo kernel, mientras que los procesos de usuario lo hacen en modo usuario,
ofreciendo protección completa. Los procesos pueden tener uno o más subprocesos, que el sistema operativo
puede ver y planificar. Se cuenta con seguridad C-2, del Departamento de Defensa americano, para todos los
archivos, directorios, procesos y demás objetos que pueden compartirse (si se retira el disco flexible y se
desconecta la red). El sistema tiene soporte completo para el multiproceso simétrico en hasta 32 procesadores.
Windows 2000 cuenta, como el resto de los sistemas operativos, con un conjunto de llamadas al sistema que
puede ejecutar. Sin embargo Microsoft nunca ha publicado la lista de llamadas, y además las cambia de una
versión a la siguiente. Lo que ha hecho es definir un conjunto de llamadas a funciones denominado interfaz de
programación de aplicaciones (API) Win32, que se conoce de manera pública y está plenamente
documentado. Se trata de procedimientos de biblioteca que efectúan llamadas al sistema para realizar el trabajo
o, en algunos casos, lo realizan ellos mismos. Las llamadas de la API Win32 existentes no cambian al cambiar de
versión, si bien se suelen añadir algunas nuevas.
Windows 2000 consta de dos componentes principales:
□ El sistema operativo en sí, que se ejecuta en modo kernel, y

□ Los subsistemas de entorno, que se ejecutan en modo de usuario.
Mientras que el kernel es tradicional, en el sentido de que se encarga de la administración de procesos, la

administración de memoria, los sistemas de archivos, etc. Los subsistemas de entorno son procesos individuales
que ayudan a los programas de usuario a realizar ciertas funciones del sistema.
Si bien las primeras versiones de Windows NT siguieron una arquitectura de microkernel, donde los procesos de
usuario interactuaban con los procesos de servidor empleando un modelo cliente-servidor, por razones de
rendimiento a partir de Windows NT 4.0, casi todo el sistema operativo volvió a ponerse en modo de kernel,
diseño que se ha perpetuado en Windows 2000. Desde la versión 4.0 de Windows NT ni ésta ni Windows 2000
se pueden considerar arquitecturas microkernel. Windows 2000 mantiene una cierta estructura interna, donde
el sistema está dividido en varias capas, cada una de las cuales usa los servicios de las que están abajo.
En la parte superior del sistema operativo, por encima del denominado kernel y de los controladores de
dispositivos (pero ejecutándose en modo kernel) se halla el ejecutivo (executive). Consta de 10 componentes,
cada uno de los cuales es un conjunto de procedimientos que colaboran para alcanzar una meta.
El administrador de procesos es uno de los componentes del ejecutivo, dentro del sistema operativo. Cada
proceso contiene al menos un subproceso o hebra (thread), el cual contiene al menos una fibra (subproceso
ligero). Los procesos se pueden agrupar en trabajos para ciertos fines de administración de recursos, pues en
Windows 2000 se han implementado, a nivel del sistema operativo las cuotas de procesador y la contabilidad
de procesador, pudiendo por un lado limitar el uso excesivo del procesador, por parte de ciertos trabajos
(conjunto de procesos) y por otra llevar cuenta de los recursos de proceso consumidos.
Los procesos se inician con una llamada al sistema con el nombre de un ejecutable. Cada proceso se inicia con
un subproceso, los subprocesos son la base de la planificación de la CPU. El sistema operativo escoge el
subproceso a ejecutar, no el proceso. El subproceso es un concepto de planificación, los recursos están a nivel
de proceso. Cuando terminan todos los subprocesos de un proceso éste termina. La conmutación de
subprocesos es costosa pues requiere ingresar en modo kernel y salir luego de él.
El límite de 32 CPUs como máximo para el Windows 2000 en multiproceso, es fijo porque se usan varios mapas
de bits para llevar el control de consumo interno de CPU de una sola palabra (la versión de 64-bit debería poder
manejar hasta 64 procesadores).
Windows 2000 no cuenta con un subproceso planificador central. Cuando un subproceso no puede seguir
ejecutándose, ingresa en modo kernel y ejecuta el planificador, él mismo, para ver cuál subproceso cambiar. Las
condiciones para que un subproceso que se está ejecutando active el código de planificación son:
□ El subproceso se bloquea por un semáforo, mutex, suceso, E/S, etc.

□ El subproceso envía una señal a un objeto.
□ El cuanto del subproceso se agota.
El planificador también se puede invocar cuando se cumplen otras dos condiciones:
□ Termina una operación de E/S.

□ Expira un plazo de espera.
Windows 2000 es apropiativo en su funcionamiento.
El algoritmo de planificación está basado en prioridades con alguna modificación dinámica de las mismas.
Cada proceso recibe una prioridad base para todos sus subprocesos. Los valores permitidos son: tiempo real,
alta, mayor que la normal, normal, menor que la normal e inactiva. A su vez, cada subproceso puede variar
su prioridad relativa al resto de subprocesos de un proceso en los siguientes valores: tiempo crítico, más alta,
mayor que la normal, normal, menor que la normal, más baja e inactiva. En total un subproceso puede tener
una prioridad de las 42 combinaciones posibles.
El sistema se basa en 32 prioridades del 0 al 31, se establece una correspondencia entre las 42 combinaciones
anteriores y estas 32 prioridades, obteniéndose la prioridad base del proceso. Las prioridades 16 a 31 están
reservadas al sistema operativo y a procesos colocados explícitamente por el administrador o usuario autorizado.
Las prioridades 1 a 15 son las reservadas para los procesos de usuario. la prioridad 0 es para el subproceso
cero que se ejecuta en segundo plano y tiene como misión exclusiva rellenar de ceros las páginas que asignará
el administrador de memoria. Existe un subproceso, denominado subproceso inactivo con prioridad -1 que se
ejecuta cuando no se puede ejecutar ningún otro proceso en el sistema.
Las prioridades forman una tabla cuyas entradas apuntan a listas enlazadas de subprocesos de igual prioridad. El
planificador funciona accediendo a la tabla por el proceso de prioridad 31 y viendo si tiene subprocesos listos para
ejecutar. Si los hay toma el primero de la lista y lo ejecuta durante un cuanto de tiempo. Al finalizar coloca el
proceso al final de la lista y toma el siguiente de la misma prioridad, de manera que, dentro de una misma
prioridad sigue un algoritmo Round Robin. Mientras existan procesos preparados de una prioridad superior, el
sistema les concederá todo el tiempo que precisen. Este comportamiento se repite para cada una de las entradas
de la tabla de prioridades.
En ciertas condiciones un subproceso puede ver incrementada su prioridad base, pero nunca por encima de la
prioridad 15 y nunca para subprocesos de prioridad mayor de 15. Si una operación de E/S libera un subproceso,
este ve incrementada su prioridad base de modo que pueda ejecutarse pronto. También se produce aumento de
prioridad si el subproceso estaba esperando por un semáforo, mutex u otro suceso. Estas elevaciones de
prioridad van disminuyendo a medida que uno subproceso beneficiado va consumiendo por completo su cuanto
de tiempo, hasta volver a situarse en su prioridad base.
Hay un caso especial en que dos subprocesos trabajando juntos en un esquema productor-consumidor, donde el
productor tiene una prioridad mayor que el consumidor, alcanzan un estado en el que el productor, se encuentra
bloqueado por la inactividad del consumidor. Si aparece un subproceso cualquiera de prioridad intermedia, que no
permite la ejecución del subproceso consumidor se produce una situación que Windows 2000 resuelve de una
forma poco elegante: el sistema lleva cuenta del tiempo que un proceso listo lleva sin ejecutarse, si este tiempo
excede de un cierto umbral, el subproceso se pasa a prioridad 15 durante dos cuantos de tiempo y después se
devuelve, de manera abrupta, a su prioridad inicial. Este problema se conoce como inversión de prioridad.
Windows 2000 permite ajustar el valor del cuanto por el administrador, entre dos posibles valores: priorizar las
aplicaciones (interactivo) o los servicios (segundo plano). Priorizar las aplicaciones conlleva el empleo de cuantos
más pequeños de tamaño variable; priorizar los servicios supone emplear cuantos más grandes de tamaño fijo.
8.4. GESTIÓN DE LA MEMORIA
El administrador de memoria, componente del ejecutivo, implementa la arquitectura de memoria virtual

paginada por demanda de Windows 2000.
En Windows 2000, cada proceso tiene su propio espacio de direcciones virtual de 32 bit, por lo que tiene 4 GB de
espacio de direcciones. Los 2 GB inferiores están disponibles para el código y los datos de proceso; los 2 GB
superiores se hacen corresponder con la memoria del kernel en forma protegida. El espacio de direcciones virtual
se pagina por demanda con tamaño fijo de páginas (4 KB en el Pentium). No se maneja segmentación en ninguna
de sus modalidades.
Todos los procesos de usuario comparten los 2 GB superiores, con excepción de las tablas de página, que son
exclusivas de cada proceso.
Windows 2000 utiliza un algoritmo de paginación doble, por demanda y anticipada, leyendo un número variable
de páginas según que el fallo se produzca en una página de código (lee más) o de datos.
El mecanismo de paginación se apoya mucho en el concepto de conjunto de trabajo. Cada proceso (no
subproceso) tiene un conjunto de trabajo que consiste en las páginas con correspondencia que están en la
memoria y a las que, por tanto, es posible acceder sin provocar un fallo de página. Las páginas de memoria real
(mejor dicho los marcos de página) o están en un conjunto de trabajo o se encuentran en alguna de las cuatro
listas de páginas libres: de páginas modificadas, de páginas en reserva, de páginas libres o de páginas en
ceros. Existe una quinta lista de páginas de RAM defectuosas donde se mantienen las páginas con algún
defecto para que no se empleen en ningún proceso. Diferentes subprocesos del sistema se encargan del
mantenimiento de esta lista, buscando optimizar y minimizar la paginación a disco.
8.5. ENTRADA/SALIDA
El administrador de E/S, componente del ejecutivo, proporciona un marco para administrar dispositivos de E/S y
presta servicios genéricos de E/S. Este componente proporciona al resto del sistema E/S independiente del
dispositivo. También es el lugar donde residen todos los controladores de dispositivos. Desde un punto de vista
técnico, los sistemas de archivos son controladores de dispositivos bajo el control del administrador de E/S.
Existen dos sistemas de archivos distintos para los sistemas FAT y NTFS, independientes entre sí y cada uno
controlando diferentes particiones del disco.
El administrador de E/S colabora estrechamente con el administrador de Plug-and-Play. La idea básica del Plug-
and-Play es la de un Bus enumerable de tal modo que, el administrador de Plug-and-Play pueda enviar una
solicitud a cada ranura pidiendo al dispositivo que está ahí que se identifique. Una vez que ha descubierto qué
dispositivos están conectados, dicho administrador asigna recursos de hw, localiza los controladores apropiados y
los carga en la memoria.
Una característica interesante de Windows 2000 es su manejo de volúmenes dinámicos que pueden abarcar
múltiples particiones e incluso múltiples discos y reconfigurarse sobre la marcha, sin necesidad de reiniciar el
sistema. Otro aspecto importante es la posibilidad de manejo de E/S asíncrona. Un subproceso puede iniciar una
operación de E/S y luego seguir ejecutándose en paralelo con la E/S.
El nuevo modelo de controladores de Windows 2000 (WDM Windows Driver Model) permite que los sistemas
operativos Windows 2000 y Windows 98 utilicen los mismos controladores, lo que supone una ventaja para los
fabricantes, los administradores e incluso los usuarios.
8.6. SISTEMAS DE ARCHIVOS
Windows 2000 reconoce varios sistemas de archivos, siendo los más importantes FAT-16, FAT-32 y NTFS (NT
File System). FAT-16 es el antiguo sistema de archivos de MS-DOS; usa direcciones de disco de 16 bits, lo que lo
limita a particiones de disco de un máximo de 2 GB. FAT-32 emplea direcciones de disco de 32 bits y maneja
particiones de disco de hasta 2 TB. NTFS es un nuevo sistema de archivos, creado específicamente para
Windows NT y que se ha trasladado a Windows 2000. Utiliza direcciones de disco de 64 bits y puede (en teoría)
manejar particiones de hasta 264 bytes. Windows 2000 también reconoce sistemas de solo lectura para CD-ROM
y DVD. Windows 2000 ha dejado de soportar el sistema HPFS que mantenía por compatibilidad con el sistema
operativo OS/2.
Con la nueva versión del sistema de archivos NTFS 5, se han incorporado nuevas funcionalidades como la
incorporación de cuotas de disco, el sistema de cifrado de archivos (EFS Encrypting File System), si bien esta
funcionalidad la realiza un controlador, con este nombre, que está situado entre el NTFS y el proceso de usuario,
las capacidad nativa de desfragmentación de volúmenes y el Servicio de seguimiento de enlaces distribuidos,
que asegura a los usuarios finales la capacidad de encontrar archivos por la red que han sido movidos de sus
ubicaciones originales por los administradores.
En NTFS, los nombres de archivo individuales están limitados a 255 caracteres; las rutas completas se limitan a
32.767 caracteres. Los nombres de archivo están en Unicode. NTFS distingue entre mayúsculas y minúsculas,
pero la API Win32 no reconoce bien esta diferencia, y nunca en los directorios.
Un archivo NTFS no es solo una sucesión lineal de bytes, como los archivos FAT-32 y UNIX. Más bien, un
archivo consiste en múltiples atributos, cada uno de los cuales se representa con un flujo de bytes. Casi todos los
archivos tienen unos cuantos flujos cortos, como el nombre del archivo y su identificador de objeto de 64 bits, y un
flujo largo (sin nombre) que contiene los datos. Sin embargo un archivo puede tener dos o más flujos de datos
(largos). Cada flujo tiene un nombre que consta del nombre del archivo, un signo de dos puntos y el nombre del
flujo, por ejemplo archivo:flujo. Cada flujo tiene su propio tamaño y se puede bloquear con independencia de
todos los demás flujos. Esta idea se tomó de la Apple Macintosh, donde los archivos tienen dos flujos: la rama de
datos y la rama de recursos.
La principal estructura de datos de cada volumen es la tabla maestra de archivos MFT (Master File Table), que
es una sucesión lineal de registros de tamaño fijo (1 KB). Cada registro de MFT describe un archivo o un
directorio, contiene los atributos del archivo, como su nombre y marcas de tiempo, y la lista de direcciones de
disco donde están sus bloques. Si un archivo es demasiado grande puede ser necesario emplear más de un
registro MFT para contener la lista de todos los bloques. En este caso al primer registro se le denomina registro
base, y apunta a los demás registros MFT.
Como la MFT es un archivo, puede ser colocada en cualquier lugar del disco, por lo que no está limitada a la
primera pista del disco. Cada registro MFT es una secuencia de pares (encabezado de atributo, valor).
Windows 2000 incluye como novedad el Sistema de Archivos Distribuido (DFS), que permite a un
administrador crear un árbol de directorios que consista en particiones de distintos sistemas de la red. El DFS
soporta tolerancia a fallos y balanceo de carga, así como replicación para mantener sincronizados los datos.
8.7. SEGURIDAD
El administrador de seguridad, componente del ejecutivo, hace que se respete el complejo mecanismo de
seguridad de Windows 2000, que satisface los requisitos C-2 del Libro Naranja del Departamento de Defensa de
Estados Unidos. El Libro Naranja especifica un gran número de reglas que debe cumplir un sistema, desde
validar los inicios de sesión hasta administrar el control de acceso y llenar con ceros las páginas virtuales antes
de reutilizarlas.
Cada usuario y grupo de Windows 2000 se identifica con un SID (Security ID) único a nivel mundial. Cada
proceso lleva asociado una ficha de acceso que especifica su SID y otras propiedades.
Cada objeto tiene asociado un descriptor de seguridad que indica quién puede realizar qué operaciones con él.
Un descriptor de seguridad está formado por un encabezado, seguido de una DACL (discretionary Access Control
List) con uno o más elementos de control de acceso (ACE). Los más importantes son Allow y Deny. Ademas
del DACL el descriptor tiene una SACL (System Access Control List) que no especifica quién puede usar el objeto
sino qué operaciones con el objeto se asientan en el registro de sucesos de seguridad del sistema.(funcion de
auditoria).
En un sistema autónomo la validación corre por cuenta del proceso winlogon y la configuración de seguridad
almacenada en la propia máquina en las claves del registro: SECURITY y SAM. Donde la primera establece las
politicas globales de seguridad y la segunda la seguridad específica de cada usuario.
En un sistema en red, la autenticación de los usuarios está centralizada en ciertos servidores denominados
controladores del dominio. Los equipos se organizan dentro de Dominios, pudiendo éstos estar gestionados
mediante el empleo del Active Directory.
Windows 2000 es el primer sistema de Windows que dispone de administración centralizada de certificados. En
las versiones anteriores se confiaba que cada aplicación mantenía su propia lista de claves o CA confiables.
El protocolo KERBEROS (RFC 1510), que es un estándar de Internet para autenticación, es el método nativo que
emplean los sistemas Windows 2000. Cualquier servidor del Directorio Activo, automáticamente, tiene el servicio
del Centro de distribución de claves de Kerberos (KDC- Kerberos Key Distribution Center).
8.8. LA INTERFAZ HOMBRE-MÁQUINA
Una característica muy importante en Windows 2000 es la incorporación de los servicios de terminal, lo que
permite que un sistema sea multiusuario. Eso ha obligado a Windows 2000 a una reconstrucción del subsistema
win32 para llevar control de los diferentes usuarios del sistema conectados en un momento dado.
Todos los sistemas operativos de la familia Windows, son de tipo GUI (Graphics User Interface). Sus elementos
principales son las ventanas gráficas, los menus, el teclado y el dispositivo apuntador, usualmente un ratón.
En el caso de Windows, la interfaz gráfica constituye el mayor empeño y complejidad de todo el sistema
operativo, siendo parte integrante de él.
Windows es una familia de sistemas operativos basados en navegación por menús, aunque disponen de una
aplicación de consola de comandos que admite comandos en línea, éstos son solamente un conjunto muy
reducido de órdenes (en la versiones Windows 95/98/Me son un juego de instrucciones MS-DOS).
8.9. ADMINISTRACIÓN DEL SISTEMA
Windows 2000, provee de herramientas para facilitar las tareas de administración de los sistemas. Uno de los
puntos fundamentales es la iniciativa de Administración Nula para Windows que intenta reducir el TCO (Total
Cost Ownership) que supone un coste muy elevado para grandes compañías con una implantación importante de
los sistemas informáticos. Una de las tecnologías empleadas se denomina IntelliMirror, que busca garantizar la
disponibilidad de la información de los usuarios frente a posibles fallos de las redes y servidores. Otra tecnología
es el RIS (Remote Installation Service) -Sistema de Instalación Remota-, para iniciar sistemas de escritorio sin
que tengan instalado el sistema operativo. El SIS (Single Instance Store) -Almacenamiento de Instancia Ünica-,
otra tecnología incluida en IntelliMirror, sirve para reducir el espacio en disco necesario cuando se almacenan
archivos duplicados en un sistema, sustituyendo las copias duplicadas por referencias a una única copia maestra.
Casi todas las herramientas de Administración del Sistema se presentan como extensiones de un nuevo entorno,
Iniciado en WindowsNT 4.0 denominado Consola de Gestión de Microsoft MMC (Microsoft Management
Console). Esta consola admite extensiones que realizan diferentes actividades de administración de los
sistemas.
Otras Características incorporadas en Windows 2000 para la administración del sistema son: WMI (Windows
Management Instrumentation) y el WSH (Windows Scripting Host) que forman parte de la infraestructura de
administración de Microsoft. Son componentes no visuales que utilizan otras herramientas o aplicaciones para
utilizar la información que manejan.
WMI: Se refiere a la administración de dispositivos. Se busca que todos los controladores de dispositivos
dispongan de interfaces definidas por WMI, disponiendo de un medio estandarizado para su interacción que
además registren elementos como contadores de rendimiento, estadísticas de error y avisos de fallo del
dispositivo.
WSH: Normalmente se utiliza para crear herramientas de administración, aunque tiene otras capacidades.
Representa la primera mejora de arquitectura para la programación con scripts desde que se crearon los archivos
de lotes para MS-DOS. WSH no es, en sí mismo, un lenguaje. Es un marco que permite que cualquier intérprete
de un lenguaje se conecte con el sistema Windows 2000. El papel de WSH es coger el archivo de script y los
parámetros asociados, trasladarlos al intérprete del lenguaje apropiado y ordenar las ventanas necesarias, de
entrada o salida, para que las utilice el script. Microsoft provee intérpretes para VBScript, JavaScript y Ms JScript.
8.9.1. ESPACIOS DE NOMBRES
Windows 2000 trabaja con 3 espacios de nombres: DNS, WINS y el Directorio Activo. El directorio activo permite
a los clientes localizar objetos en la red mediante el LDAP Protocolo ligero de acceso a los directorios. Se soporta
sobre una base de datos distribuida y puede guardar una significativa cantidad de datos. El directorio activo sirve
para sustituir las funciones de dominio.
Un directorio es una lista de objetos. El directorio activo utiliza la tecnología DNS para localizar objetos. El
directorio activo proporciona un catálogo global GC como único lugar donde buscar cualquier objeto de la red de
una organización.
8.9.2. EL DIRECTORIO ACTIVO
Realizar el seguimiento de todo lo que ocurre en una red es una tarea que lleva mucho tiempo. Resulta imposible
administrar redes medianas a grandes sin algún tipo de directorio de red, donde figuren los diferentes recursos
disponibles. En versiones anteriores de Windows, los usuarios y administradores disponían de servicios de ayuda
para descubrir los recursos de la red, administrar usuarios, etc.
Todos estos objetos residen en un contenedor común: el dominio de Windows NT. El dominio Windows NT
funciona bien en redes pequeñas a medianas, en grandes entornos era preciso crear varios dominios
enlazándolos mediante relaciones de confianza. Windows 2000 introduce el Directorio Activo (Active Directory)
para sustituir las funciones del dominio. El Directorio Activo se puede replicar en varios controladores de dominio,
por lo que ya no hay un único sistema crítico. Los datos cruciales se guardan en el directorio activo que es a la
vez redundante y con balanceo de carga.
El Directorio Activo guarda información sobre organizaciones, lugares, sistemas, usuarios, particiones, recursos
compartidos y cualquier otro objeto componente de la red.
El Directorio Activo proporciona un espacio de nombres para relacionar los nombres de los objetos de la red con
dichos objetos. Todo lo que se guarda en el Directorio Activo se considera un objeto. Los atributos describen los
objetos del Directorio activo. El conjunto de atributos de un tipo de objeto dado se denomina esquema. La
información de un esquema se guarda en el Directorio Activo. Un contenedor es un tipo especial de objeto para
organizar el Directorio activo. No representa nada físico, se usa para agrupar objetos, un contenedor se puede
anidar dentro de otro contenedor. Todos los objetos del Directorio Activo tienen un nombre, que es un nombre
distinguido de LDAP ("/O=Internet/DC=COM/DC=Microsoft/CN=Users…").
El término árbol se utiliza para describir un conjunto de objetos del Directorio Activo. Cuando se combinan
jerárquicamente objetos y contenedores, tienden a formar ramas, de aquí el término. Un término relacionado es el
subárbol contiguo, que se refiere a una rama conectada del árbol.
El término bosque describe los árboles que no forman parte de un mismo espacio de nombres pero comparten
un esquema, configuración o catálogo global común. Los árboles de un bosque confían unos en otros, por lo que
si la seguridad se lo permite todos los usuarios pueden utilizar los objetos de estos árboles. Las organizaciones
divididas en múltiples dominios deberían agrupar los árboles en un único bosque.
Un sitio (Site) es una localización geográfica, definida en el Directorio Activo. Los sitios se corresponden con
subredes lógicas de IP y las aplicaciones pueden utilizarlas para localizar al servidor más cercano en la red.
Los dominios siguen siendo el modelo de organización de los sistemas en red, sin embargo, bajo el Directorio
Activo, la Seguridad se gestiona de manera centralizada, todos los dominios comparten una relación de confianza
bidireccional y transitiva (A-confia->B-confia->C entonces A-confia->C), lo que no ocurría en Windows NT.
Aparece el concepto de Unidad Organizativa como forma de organización dentro de un dominio, y la delegación
de administración, que permite a un administrador asignar tareas de administración a otros usuarios sin
concederles más capacidades de las necesarias. La delegación se puede asignar a objetos concretos o
subárboles contiguos del directorio activo.
9. SISTEMAS UNIX
9.1. EVOLUCIÓN HISTORICA
A finales de los años sesenta, sobre 1968, un conjunto de investigadores provenientes de AT&T Bell, del MIT y
General Electric emprenden el desarrollo de un sistema operativo multiusuario al cual llamaron MULTICS
(Multiplexed Information and Computing System). MULTICS poseía gran parte de las características que tiene hoy
en día cualquier versión de UNIX como son la multitarea, la gestión de archivos y la interacción con usuarios. Sin
embargo MULTICS nunca llegaría a completarse debido a numerosos contratiempos y retrasos en su
implementación, ya que una de las mayores desventajas era la complejidad del software y hardware necesario
para completar tareas cotidianas y sencillas para los usuarios.
Posteriormente, Ken Thompson y Dennis Ritchie, unos de los investigadores que se involucraron en el proyecto
MULTICS retoman la idea y desarrollan en 1969 en los laboratorios Bell el sistema operativo multiusuario UNIC
(Uniplexion Information and Computing System), una revisión del sistema operativo MULTICS, escrito en un
lenguaje ensamblador; y ejecutándose en una máquina DEC PDP-7, que posteriormente se adapto a un
ordenador PDP-11. UNIC simplificaba las tareas de su antecesor.
Mas tarde, el nombre sufre diferentes cambios hasta llegar al UNIX, tal y como se conoce hoy en día, con lo cual
se puede deducir que UNIX surge de una versión reducida del proyecto MULTICS, si bien también ha sido
influenciado por otros sistemas operativos como el CTSS (Compatible Time Sharing System) del MIT y el sistema
XDS-940 de la Universidad de California de Berkeley.
Recuerdese que en esos años cuando se compraba un ordenador, se tenía que comprar el sistema operativo
proveído por el fabricante del equipo, por consiguiente posteriormente también se tenían que comprar las
aplicaciones proporcionadas por el fabricante ya que son las que conocían como interactuar con el sistema
operativo, y esas aplicaciones tenían un precio bastante alto, es decir, los usuarios estaban encadenados al
fabricante del ordenador, era como el pez que se come la cola.
Además, ciertas restricciones legales impedían a dichos laboratorios fabricar ordenadores, por lo que se
dedicaban a comprar el hardware a otras empresas, necesitando algún mecanismo para portar el sistema
operativo a distintas máquinas.
El hecho de que UNIX estuviese escrito en ensamblador impedía la portabilidad a diferentes ordenadores.
Thompson desarrolló un nuevo lenguaje de alto nivel: B, pero Dennis Ritchie en el 1973 lo mejora y le llama
lenguaje C, rescribiendo UNIX totalmente en este lenguaje de alto nivel (muy apto para escribir sistemas
operativos), haciendo por tanto el código casi totalmente independiente del tipo de máquina, permitiendo la
instalación de UNIX en diferentes plataformas, logrando así una popularidad sin precedentes en el mundo de los
sistemas operativos.
Inicialmente los laboratorios AT&T Bell, consideran que UNIX era más bien un proyecto de investigación y lo llegó
a distribuirse de forma gratuita entre departamentos informáticos de las universidades, los cuales lo podían
modificar y adaptar a sus necesidades.
La gran demanda del sistema operativo hace que los laboratorios Bell iniciara su venta a través de distribuciones
oficiales concediendo a los usuarios que lo requerían licencias de uso.
La primera versión de UNIX disponible fuera de los laboratiros Bell fue la Versión 6, ea el año 1976. En 1978 se
distribuyó la Versión 7, que fue adaptada a otros PDP-11 y a una nueva línea de ordenadores de DEC
denominada VAX. La versión para VAX se conocía como 32V.
Tras la distribución de la Versión 7, UNIX se convirtió en un producto y no sólo ea una herramienta de

investigación o educacional, debido a que el UNlX Support Group (USG) asumió la responsabilidad y el control
administrativo del Research Group en la distribución de UNIX dentro de AT&T.
En el periodo comprendido entre 1977 y 1982, los laboratorios BeIl combinó varios sistemas UNIX, desarrollados
deatro de AT&T, con características de la Versión 7 y de la 32V, dando lugar aun único sistema cuyo nombre
comercial fue UNIX System III. Ésta fue la primera distribución externa desde USG.
Los Laboratorios Bell más tarde añadieron muchas características nuevas al UNIX System III, llamando al nuevo
producto UNIX System V, y AT&T anunció su apoyo oficial al System V en Enero de 1983.
La modularidad, la sencillez de diseño y el pequeño tamaño de UNIX, hicieron que muchas empresas se pusieran
a trabajar sobre él. La Universidad de Berkeley en Califomia creo una variante del sistema UNIX para máquinas
VAX. Esta variante incorporaba varias características interesantes, tales como memoria virtual, paginación por
demanda y sustitución de página, con lo cual se permitía la ejecución de programas mayores que la memoria
física.
A esta variante, desarrollada por Bill Joy y Ozalp Babaoglu, se la conoció como 3BSD (Berkeley Software
Distribution). Esto llevo a que la Defense Advanced Research Projects Agency (DARPA) ayudase
económicamente a Berkeley en el desarrollo de un sistema UNIX estándar el 4BSD.
Los trabajos en 4BSD para DARPA fueron dirigidos por expertos en redes y UNIX, ya que la intención era que
4BSD incluyera la pila de protocolos TCP/IP.
9.2. CARACTERÍSTICAS
Las características más relevantes del sistema son:
□ UNIX ha sido diseñado como un sistema multiusuario en tiempo compartido; es decir, un sistema en el
que pueden trabajar varios usuarios simultáneamente entre los cuales se reparten los recursos del
sistema hardware, pensando cada usuario que tiene acceso exclusivo a la máquina. Proporciona
protección de los datos privados sobre ficheros y también ofrece protección del entorno de ejecución
□ Portabilidad: Tal y como se comento anteriormente, UNIX fue escrito en el lenguaje C, un lenguaje de alto
nivel, lo cual hace que sea relativamente fácil de leer, entender, modificar y transportar a otras máquinas
con una arquitectura física diferente.
□ Interfaz de usuario simple e interactiva: el intérprete de órdenes (shell) es un programa independiente que
el usuario puede sustituir. La sintaxis de utilización es idéntica para todas las órdenes.
□ Modularidad: Proporciona primitivas que permiten construir grandes programas a partir de otros más
sencillos, asi como librerías para linkaje.
□ Posee bibliotecas compartidas para facilitar el enlace dinámico.
□ Protecciones de memoria.
□ Soporta diferentes sistemas de archivos, incluidos los de Microsoft Window
□ Sistema de archivos con estructura de árbol invertido (de múltiples niveles que permite un fácil
mantenimiento) y jerárquico (permite la unión de diversos sistemas de ficheros con el sistema principal, y
una separación de directorios).
□ Todos los archivos de usuario son simples secuencias de bytes (8 bits), no tienen ningún formato
predeterminado.
□ Independencia de dispositivos: Los discos y los dispositivos de entrada y salida (E/S) se tratan todos de la
misma manera: como meros archivos. Las peculiaridades de los dispositivos se mantienen en el núcleo
(kernel).
□ La arquitectura de la máquina es completamente transparente para el usuario, lo que permite que los
programas sean fáciles de escribir y transportables a otras máquinas con hardware diferente
□ UNIX no incorpora diseños sofisticados; de hecho, la mayoría de los algoritmos han sido seleccionados
por su sencillez y no por su rapidez o complejidad.
□ Incorpora todos los servicios de red, TCP/IP, DNS, sendmail, etc.
□ Proporciona un completo entorno de programación: los filtros son utilidades simples que se concentran en
realizar bien una sola función. Pueden combinarse de forma muy flexible utilizando las pipes y las
redirecciones de E/S según las necesidades y preferencias de cada usuario.
□ Mantenimiento fácil: consecuencia directa de la modularidad. El sistema sigue evolucionando y se
perfecciona y enriquece con nuevas funcionalidades.
□ Carácter abierto: permite ampliar fácilmente la funcionalidad con nuevos componentes sin tener que
depender de un único fabricante.
9.3. TIPOS DE SHELL
9.3.1. INTRODUCCIÓN
Una gran parte del uso del Sistema UNIX consiste en que el usuario emitir órdenes y UNIX responder, para
realizar esta labor, el usuario no se comunica directamente con el núcleo de UNIX sino que lo hace a través del
intérprete de comandos o shell.
Por lo tanto, el shell no es más que un intermediario entre el núcleo de UNIX y el usuario. Cuando se emite una
orden nos relacionamos con el shell, la parte del Sistema UNIX a través de la cual se controlan los recursos del
sistema operativo UNIX. El shell proporciona muchas de las características que hacen al Sistema UNIX un
entorno potente y flexible. Se trata de un intérprete de órdenes, un lenguaje de programación, y más. Como
intérprete de órdenes, el shell lee los comandos que se le introducen y dispone lo necesario para que se ejecuten.
Además se puede utilizar el lenguaje de órdenes del shell como un lenguaje de programación de alto nivel para
crear programas denominados guiones (scripts).
Existen varios tipos de shell:
□ El considerado estándar es el Bourne Shell (sh); es el que distribuye AT&T con el UNIX. La versión
original fue desarrollada por Stephen Bourne en los Laboratorios Bell.
□ Otro de los más difundidos es el C Shell (csh), desarrollado en la Universidad de Berkeley en su mayor
parte por Bill Joy. Fue diseñado teniendo en cuenta que los usuarios serían programadores en lenguaje
C.
□ Otra versión ampliamente difundida es el Korn Shell (ksh), interfase escrita por David Korn.
□ Por ultimo existe el shell BASH (Bourne Again Shelll) que unifica las características del csh y ksh junto
con la version inicial del Bourne Shell (sh)
Nos vamos a centrar en el shell del Sistema V (sh). El UNIX Sistema V Versión 4 (SVR4) también proporciona
otros dos shells, el shell C (csh) y el shell Korn (ksh), que ofrecen varias ampliaciones valiosas al shell del
Sistema V. Los conceptos y características que describiremos también se aplican al shell Korn, y la mayor parte
de ellos se aplican al shell C.
El shell C y el shell Korn se desarrollaron para disponer de características y capacidades adicionales que no
ofrecía el sh. Comparado con sh, tanto csh como ksh disponen de un número de ampliaciones valiosas. Entre
ellos están la edición de línea de orden, que posibilita editar las líneas de órdenes cuando se introducen; las listas
de historias de órdenes, que permite revisar las órdenes que se han venido utilizando durante una sesión, y los
alias de órdenes, que se pueden utilizar para dar a las órdenes nombres más convenientes.
csh y ksh también proporcionan la posibilidad de utilizar órdenes desde una lista de comandos ya introducidos
para simplificar la creación de órdenes nuevas, la protección de sobreescritura accidental en archivos existentes
cuando se redirige la salida hacia ellos, un número de características convenientes y capacidades de
programación del shell extendidas.
9.3.2. SHELL DEL SYSTEM V: (sh)
Cuando usted se presenta al sistema, se inicia automáticamente un programa de shell. Este es el shell de
presentación. El programa de shell particular que se ejecuta cuando se inicia sesión está determinado por su
entrada en el archivo /etc/passwd.
Cuando se inicia su shell de presentación, se ejecuta un archivo denominado .profile que se encuentra en su
directorio de presentación. Su .profile contiene órdenes que personalizan su entorno, por similitud sería como el
fichero autoexec.bat en el sistema operativo MS-DOS® . El shell lee este archivo y lleva a cabo las instrucciones
que contiene.
El .profile es un ejemplo simple de guión de shell o script puesto que contiene a su vez órdenes o instrucciones
para el shell y se utiliza para la personalización del entorno de trabajo: la definición de la variable PATH, fijar el
tipo de terminal, cambiar el prompt por defecto, etc.
El shell le informa que está listo para recibir su entrada visualizando una petición de orden. Por defecto, sh utiliza
el signo dólar, $, como signo de petición de orden principal o primaria para los usuarios y el signo sostenido #
como signo de petición de ordenes para el root o administrador.
Para terminar la sesión en UNIX se teclea CTRL+D, o la orden exit.
Muchas de las iteraciones con UNIX tienen la forma de dialogo con el shell. Este diálogo sigue una secuencia
simple repetida una y otra vez.
□ El shell solicita una orden y espera su introducción

□ Se introduce una orden tecleando una línea de orden.
□ El shell procesa la línea de orden para detenninar las acciones que debe llevar a cabo y visualiza el
resultado.
□ Después de finalizar el programa, el shell solicita otra orden comenzando otro ciclo.
La parte de este ciclo que realiza el trabajo real es el paso tercero, cuando el shell lee y procesa la línea de orden
y ejecuta las instrucciones que contiene.
9.3.2.1. ORDENES DE ENTRADA
En general, una línea de orden contiene un comando y argumentos. Cada línea de orden finaliza con un
NEWLINE, que es el término de UNIX para el carácter que se produce cuando se teclea RETURN. El shell no
comienza a procesar la línea de orden hasta que recibe un RETURN .
Los argumentos de la línea de orden son opciones que modifican lo que hace una orden y cómo lo hace, y la
información que necesita, como puede ser el nombre de un archivo del que obtener datos. Las opciones
normalmente se indican con un signo.
A menudo la línea de orden incluye argumentos y símbolos que son realmente instrucciones para el shell. Por
ejemplo, cuando se utiliza el símbolo > para dirigir la salida de una orden a un archivo, o el símbolo de cauce, I,
para utilizar la salida de una orden como entrada a otra, o el ampersand, &, para ejecutar una orden en el modo
subordinado, realmente se están dando instrucciones al shell.
Normalmente se coloca una única orden o un cauce de dos o más órdenes en una única línea. Si es necesario se
pueden introducir varias órdenes de una vez en una línea separándolas con punto y coma. Por ejemplo, la línea
de orden siguiente dice al shell que ejecute en primer lugar date, y después ls, de la misma forma que se hubiese
hecho tecleando cada una de las órdenes en una línea independiente.
$ date; ls
Esta forma de introducir órdenes es muy conveniente cuando hay que escribir una secuencia completa de
órdenes antes de ejecutar ninguna de ellas.
9.3.2.2. UTILIZACIÓN DE COMODINES PARA ESPECIFICAR ARCHIVOS
El shell proporciona una forma de abreviar los nombres de archivos mediante el uso de patrones especiales o
comodines que se utilizan para especificar uno más archivos sin tener que escribir los nombres completos. Se
pueden utilizar comodines para especificar de una sola vez un conjunto completo de archivos, o para buscar un
archivo cuando sólo s e conoce parte de su nombre. Por ejemplo, se puede utilizar el comodín * para listar todos
los archivos del directorio actual con la extensión rpm:
$ ls *.rpm.
El shell proporciona tres comodines para nombres de archivos: *, ? y [. ..].
□ El asterisco identifica a una cadena de cualquier número de caracteres (incluyendo cero caracteres); por
ejemplo: *data identifica a cualquier nombre de archivo terminado en "data", incluyendo data y file.data.
□ El signo de interrogación identifica a cualquier carácter simple; por ejemplo: .memo? identifica a cualquier
nombre de archivo que conste de "memo" seguido por exactamente un carácter.
□ Los corchetes se utilizan para definir clases de caracteres que identifican a cualquiera perteneciente al
conjunto que engloba. Por ejemplo: [Jj]mf identifica a los nombres de archivos jmf o Jmf.
Se puede indicar un rango o secuencia de caracteres entre corchetes con un -. Por ejemplo: temp [a-c]
identifica a tempa, tempb y tempc.
Existe una excepción importante a la declaración de que * identifique a cualquier secuencia de caracteres. No con
un . (punto) al comienzo de un nombre archivo. Para identificar un nombre de archivo que comienza con. (punto),
hay que incluir un punto en el patrón.
La necesidad de indicar explícitamente un . inicial es consistente con el hecho de que los archivos con nombres
que comienzan con . son tratados como archivos ocultos, que se utilizan para mantener información necesitada
por el sistema o por órdenes particulares, pero que normalmente no se necesita visualizar .
Cuando el shell procesa una línea de orden, sustituye en forma ordenada cualquier palabra que contenga
comodines de nombres de archivos por los nombres de archivos identificados.
Si no existen nombres de archivos que se identifiquen con el patrón especificado, el shell no realiza ninguna
sustitución.
9.3.2.3. ENTRADA Y SALIDA ESTÁNDAR
Una de las características del Sistema UNIX es la forma general y flexible de tratar los archivos y la facilidad con
la que se puede controlar el lugar desde donde los programas obtienen la entrada y envían la salida. La salida de
una orden puede enviarse a la pantalla, almacenarse en un archivo o utilizarse como entrada a otra orden.
Análogamente, la mayor parte de las órdenes aceptan entrada desde teclado, desde un archivo almacenado o
desde la salida de otra orden.
La orden no necesita saber de dónde viene la entrada o a dónde va la salida. Es el shell el que establece estas
conexiones, en base a las instrucciones de la línea de orden.
Una de las funciones más importantes del shell consiste en gestionar la entrada y salida estándar, de manera que
sólo se necesite especificar de dónde obtiene el comando la entrada ya dónde debe enviar la salida. Esto se
realiza mediante el mecanismo de redirección de entrada y salida
REDIRECCIONES
La siguiente tabla lista los símbolos utilizados para decir al shell dónde obtener la entrada y adónde enviar la
salida. A éstos se les denomina operadores de redirección del shell.
Símbolo Ejemplo Función

< cmd < file La entrada del comando será el fichero no el teclado
> cmd > file La salida del comando se envía a fichero no a pantalla. Si el fichero no existe
se crea, si existe se machaca el contenido
>> cmd >> file La salida del comando se añade a fichero no a pantalla. Si el fichero no existe
se crea, si existe se añade la salida del comando al final del mismo
| cmd1 | cmd2 Envía la salida del comando1 al comando 2
Operadores de redirección
□ Redirección de la salida. Se utilizan dos operadores:

à Operador > hace que el shell envíe la salida de un comando determinado a un fichero. Si ya existe un
archivo con ese nombre en el directorio actual, se sobreescribe. Si no existe un archivo con ese
nombre, el shell crea uno antes de ejecutar la orden.
à Operador » lo mismo que el anterior solo que añade datos a un archivo sin eliminar los ya existentes.
□ Redirección de la entrada. se utiliza el operador < que le indica al shell que utilice el archivo siguiente
como entrada estándar de una orden.
□ Tuberías o cauces: Es otra forma de redirección de la salida proporcionada por el shell. El símbolo del
cauce, I, dice al shell que tome la salida estándar de una orden y la utilice como entrada estándar de otra
orden. Se pueden utilizar combinaciones de herramientas simples unidas mediante cauces para toda
clase de tareas.
9.3.2.4. VARIABLES DEL SHELL
El shell dispone de un mecanismo para definir variables que se utilizan para almacenar información utilizada por
los programas del sistema o por el usuario. Las variables del shell se pueden utilizar para personalizar o
particularizar la información relativa a nombres de directorios y de archivos que necesitan los programas y para
personalizar la forma en la que los programas (incluyendo el propio shell) interactúan con el usuario.
VARIABLES COMUNES DEL SHELL
A continuación se muestran algunas de las variables del shell más comunes, incluyendo aquellas que fija
automáticamente el sistema.
□ HOME contiene el nombre de camino absoluto del directorio de recepción. HOME es definida
automáticamente. El propio shell utiliza esta información para determinar el directorio al que cambiar
cuando se teclea la orden cd sin argumento
□ PATH lista, en orden, los directorios en los que el shell busca para encontrar el programa a ejecutar
cuando se teclea una orden. PATH contiene una lista de nombres de directorios, separados por dos
puntos.
Un PATH por defecto es puesto por el sistema, pero la mayor parte de los usuarios lo modifican para
añadir directorios de órdenes adicionales. Un campo vacío en la cadena PATH significa buscar en el
directorio actual (un campo vacío es aquel con dos puntos, pero sin nombre de directorio).
□ CDPATH es similar a PATH. Lista en orden los directorios en los que busca el shell para encontrar un
subdirectorio a cambiar cuando se utiliza la orden cd. Los directorios que busca el shell se listan de la
misma forma que los directorios de su PATH.
□ PSl y PS2 definen los signos de sus peticiones de orden primaria y secundaria, respectivamente. Sus
valores por defecto son $ para PSl y > para PS2.
□ LOGNAME contiene su nombre de presentación. Lo fija automáticamente el sistema.
□ MAIL contiene el nombre del directorio en el que se coloca el correo nuevo. El shell utiliza esta variable
para notificar cuándo se añade nueva información en su directorio.
□ MAILFILE se utiliza para saber dónde colocar el nuevo correo.
□ SHELL contiene el nombre de su programa de shell. Es utilizado por el editor vi y por otras órdenes
interactivas para determinar qué programa de shell ejecutar cuando se trabaja en modo control.
□ TERM es utilizada por vi y otros programas orientados a pantalla para obtener información sobre el tipo
de terminal que se está utilizando. Esta información es necesaria para permitir a los programas que
comparen su salida con las capacidades del terminal y para interpretar su entrada correctamente.
Obtención del valor de una variable de shell
Además de fijar valores, a veces se necesita obtener el valor de una variable del shell. Para obtener el valor de
una variable del shell, se precede el nombre de la variable con un signo dólar, $. Cuando el shell lee una línea de
orden, interpreta cualquier palabra que comienza con $ como una variable y la sustituye con el valor de la
variable.
Para ver el valor de una variable, puede utilizar la orden echo. Esta orden produce eco (imprime) de la entrada
estándar en su salida estándar.
Se puede utilizar la orden set para ver todas las variables actuales del shell y sus valores. Por ejemplo:
DEFINICIÓN DE LAS VARIABLES DEL SHELL
Aunque HOME, PS1, PS2 y otras variables comunes son fijadas automáticamente por el sistema, a otras no les
ocurre esto y se pueden definir sus valores. TERM y MAILFILE son ejemplos de variables del shell que no se
definen automáticamente.
Una variable del shell se define escribiendo su nombre seguido por un signo = y su valor. Para poner la variable
de terminal a vt100, se utiliza la orden:
$ TERM=vtlOO
De Ia misma formas se pueden redefinir algunas de las variables actuales, como HOME y PS1.
Siempre que se le dan valores a las variables no deben existir espacios entre el nombre de la variable, el signo =
y el valor. El valor puede contener un espacio o incluso uno o más NEWLINES pero si los contiene, debe ir entre
comillas. Por ejemplo, se puede definir una petición de orden de dos palabras:
$ PS1="hi there:"
Para eliminar una variable se utiliza la orden unset.
DEFINICIÓN DE SUS PROPIAS VARIABLES DEL SHELL
Se trata de una forma conveniente de almacenar información utilizada con frecuencia en líneas de órdenes. Por
ejemplo, si se mueve con frecuencia archivos a un directorio particular, se puede definir una variable con el
nombre del directorio.
Cuando el shell lee una línea de orden, sustituye cualquier palabra que comience con un $ con el valor de la
variable que tiene ese nombre.
VARIABLES DEL SHELL Y EL ENTORNO
Cuando se ejecuta una orden, el shell pone a disposición del programa un conjunto de variables del shell y sus
valores. El programa puede entonces utilizar esta información para personalizar sus acciones. La colección de
variables y valores de un programa se denomina el entorno.
El entorno incluye las variables fijadas por el sistema, tales como HOME, LOGNAME y PATH. Se pueden
visualizar sus variables de entorno con la orden: env
Algunas de las variables definidas por el sistema son incluidas automáticamente en su entorno. Pero para
ponerlas a disposición de otras órdenes diferentes de las del propio shell deben ser exportadas. Algunas de las
variables estándar descritas anteriormente se exportan automáticamente al entorno. Pero otras, incluyendo
cualquier variable que defina el usuario y cualquier valor de una variable estándar que se cambie, no.
Se utiliza la orden export para hacer que el valor de una variable esté disponible a otros programas.
9.3.3. El C-SHELL (csh)
El shell C proporciona casi todas las características del shell estándar descritas anteriormente. Existen sin
embargo algunas diferencias básicas en el vocabulario del lenguaje de órdenes y en la sintaxis:
□ Presentación e iniciación. Cuando se inicia sh, mira en su .profile órdenes iniciales y definiciones de
variables. El shell C sigue un procedimiento similar, pero utiliza dos archivos, denominados. cshrc y .login.
csh lee .login sólo cuando el usuario inicia sesión. El archivo .login deberá contener órdenes y
definiciones de variables que sólo necesitan ser ejecutadas al comienzo de la sesión.
El archivo. cshrc es un archivo de iniciación. La "rc" significa "read commands" (órdenes de lectura). Para
programas convencionales se busca normalmente la información de iniciación en archivos que finalizan
en "rc".
La diferencia entre .cshrc y .login es que el csh lee .login sólo en la presentación, pero lee .cshrc tanto al
comienzo de una sesión como cuando se le invoca desde el shell de presentación -por ejemplo, cuando
se ejecuta un guión de shell-. El archivo .cshrc incluye órdenes y definiciones que se necesitan ejecutar
cada vez que entra en un shell, no sólo al principio.
.cshrc debería incluir las definiciones de variables que utiliza el shell pero que no son variables de
entorno. Las variables de entorno deben definirse en. login.
□ Variables del shell C. El shell C dispone de variables, incluyendo variables estándar definidas por el
sistema y variables definidas por el usuario. Diferencias con sh:
à Para definir una variable en csh se utiliza la orden set.
à csh permite espacios entre el nombre de la variable, el signo = y el valor; sh no.
à csh utiliza letras minúsculas para las variables ordinarias; la práctica usual en sh es utilizar letras
mayúsculas.
□ Variables especiales del shell C. El shell C utiliza un número de variables especiales. Algunas de ellas
son directamente equivalentes a las variables de sh. Las siguientes son algunas variables especiales del
shell C que usted debería conocer.
à cwd mantiene el nombre completo del directorio de trabajo actual. Proporciona la información que
utiliza la orden pwd para visualizar su directorio actual
à home es el nombre de camino completo de su directorio de presentación. Corresponde a la variable
HOME utilizada en sh y ksh.
à path mantiene la lista de directorios en los que busca el shell C para encontrar un programa cuando
ejecuta sus órdenes. Corresponde a PATH.
à cdpath es la variable del shell C equivalente a la variable CDPATH del shell del Sistema V.
à prompt es la equivalente a PSl del shell del Sistema v. El valor por defecto de la petición de orden
(prompt) del shell C es %, o a veces system%, donde system es el nombre de su sistema UNIX.
à mail informa al shell de la frecuencia con que tiene que chequear el correo nuevo y dónde buscarlo,
por ejemplo: set mail = ( 60 $home/mail )
□ Variables multievaluadas El shell C utiliza paréntesis para agrupar distintas palabras que representan
distintos valores de una variable. Esto permite definir y utilizar las variables del shell C como arrays.
□ Variables de conmutación para activar características del shell C. El shell C utiliza variables especiales
denominadas de conmutación para activar o desactivar ciertas características. Las variables de
conmutación son variables que tienen sólo dos valores: activas y desactivas. Cuando se define con la
orden set una variable de conmutación, activa la correspondiente característica. Para desactivarla se
utiliza unset. Variables de conmutación importantes son noclobber, ignoreeof y notify.
à noclobber impide sobrescribir un archivo existente cuando se redirige la salida desde una orden. Se
puede indicar explícitamente a csh que realmente quiere sobrescribir el archivo, colocando un signo
de exclamación después del símbolo de redirección: % ls -1 >! temp
à .ignoreeof impide que accidentalmente se salga de la sesión tecleando CTRL-D. Sin ignoreeof, un
CTRL-D al comienzo de una línea de orden termina su shell y sale del sistema. Si activa ignoreeof, el
shell ignora CTRL-D.
à notify informa de cuándo termina un trabajo en modo subordinado. Si la variable notify está activa, el
shell visualizará un mensaje de finalización del trabajo cuando termine la ejecución un trabajo en
modo subordinado. Esta variable de conmutación se fija por defecto, pero si usted no quiere obtener
mensajes de terminación de trabajos, puede des activarla.
□ Variables de entorno. Una variable de entorno es una variable que está disponible a las órdenes como
parte del entorno que mantiene el shell. Recuerde que sh define variables de entorno de la misma forma
que las otras variables y utiliza export para incluir una variable en el entorno.
à El shell C no utiliza la orden export para colocar una variable en el entorno. En lugar de ello, utiliza
una orden especial, setenv, para definir variables que son parte del entorno. Para definir variables de
entorno no existe signo = entre el nombre de la variable y su valor. Por ejemplo, setenv term vt100
à Puede ver todo lo referente a las variables de entorno con la orden env
à Para eliminar una variable de entorno se utiliza unsetenv.
□ Historia de órdenes. El shell C mantiene un registro o lista de todas las órdenes que se introdujeron
durante una sesión. Se puede examinar la lista de historia para buscar órdenes particulares.
à Con la orden history se puede visualizar la lista de las últimas líneas de órdenes.
□ Alias. El shell C permite definir alias de órdenes simples. Un alias de una orden es una palabra (el alias)
y algún texto que es sustituido por el shell cuando la palabra se utiliza como orden. Se pueden utilizar
alias para incluir automáticamente opciones particulares cuando se ejecuta una orden y para dar nombres
cortos a órdenes que usted teclea con frecuencia.
□ Abreviatura de directorios de presentación. El shell C proporciona una forma fácil de abreviar el nombre
de camino del directorio de recepción que es utilizando el símbolo tilde (~) al comienzo de una palabra en
la línea de orden. Esto hace que el shell la sustituye con el nombre completo de camino del directorio de
recepción. Por ejemplo, rm -/newfile es la forma abreviada de teclear rnv $home/newfile
□ Redirección del error estándar en el shell C. csh proporciona una forma para redirigir tanto la salida
estándar como el error estándar al mismo archivo.
Por ejemplo, $ find .-type f -print >& output-file & # C shell
ejecuta find en el modo subordinado y envía la salida estándar y los mensajes de error a output-file. Sin
embargo, el shell C no permite que se redirija el error estándar independientemente de la salida estándar.
□ Terminación del nombre de archivo. La característica de terminación de nombre de archivo del shell C
proporciona una forma conveniente para introducir nombres de archivos en órdenes. Para ello es
necesario activar la variable de conmutación filec. Con filec, si se teclea la primera letra o letras de un
nombre de archivo y después se teclea CTRL-D, csh expandirá el nombre parcial para hacerlo coincidir
con un nombre de archivo del directorio actual.
9.3.4. EL SHELL KORN (ksh)
El shell Korn proporciona un superconjunto altamente compatible de características del shell del Sistema V.
Incorpora la mayor parte de las ampliaciones que se encuentran en el shell C, así como muchas otras
características potentes, conservando la sintaxis y características básicas del sh. Los programas de shell escritos
para sh corren generalmente sin modificación bajo ksh.
□ Presentación e iniciación. Como el shell C, el shell Korn utiliza dos archivos de iniciación -uno sólo para la
presentación, el otro cada vez que se ejecuta ksh.
De la misma forma que sh, ksh lee el archivo .profile para buscar las órdenes que se quieren ejecutar en
inicia de sesión y las variables y valores que se requiere que estén activas a lo largo de la sesión.
Además de leer el .profile, cada vez que inicializa ksh también lee un archivo de entorno. El archivo de
.entorno es análogo al archivo .cshrc del shell C. A diferencia de csh, ksh no supone que este archivo
tiene un nombre o posición particular. El nombre y posición se definen con la variable ENV, de .profile.
□ Variables del shell Korn. El shell Korn implementa todas las características del shell estándar
relacionadas con variables e incluye todas las variables del shell estándar. Se pueden defInir o redefinir
variables, exportarlas al entorno y obtener sus valores. El shell Korn utiliza algunas de las variables del
shell del Sistema V, entre las que se encuentran: CDPATH, HOME, LOGNAME, MAIL, MAILCHECK,
MAILPATH, PATH, PSI, PS2, SHELL y TERM.
Algunas variables utilizadas por el shell Korn que no se utilizan en sh son:
à ENV dice a ksh dónde encontrar el archivo de entorno que se lee en la iniciación.
à HISTSIZE dice a ksh cuántas órdenes guardar en el archivo de historia-
à TMOUT dice a ksh cuántos segundos esperar antes de producirse un fuera de tiempo si no se pulsa
una orden.
Para ver las variables de shell actuales y sus valores se utiliza la orden set.
□ Fijación de las opciones del shell Korn. El shell Kom proporciona un número de opciones que activan
características especiales. Estas incluyen las opciones noclobber e ignoreeof que son idénticas a las
proporcionadas por las variables de conmutación del shell C, así como una opción para activar la edición
de línea de orden.
□ Historia de órdenes. El shell Kom mantiene una historia de las órdenes que se van introduciendo al
trabajar en una sesión. Para ver las últimas órdenes que se introdujeron tecleando history. El número de
líneas de órdenes que mantiene ksh viene controlado por la variable del shell HISTSIZE.
□ Alias. De la misma forma que el shell C, el shell Kom permite definir alias de órdenes simples. Los alias
se definen en el shell Kom de la misma forma que se definen las variables. En particular, como ocurre con
las variables del shell, no deben existir espacios entre el nombre del alias, el signo = y su valor. También,
si el valor incluye espacios (por ejemplo, un nombre de orden y opciones), deben ir entre comillas.
□ Abreviatura de los directorios de presentación. El shell Kom proporciona una forma fácil para abreviar los
nombres de caminos de los directorios de trabajo usando el símbolo tilde ~.
9.4. ESTRUCTURA DE ARCHIVOS
Un pilar básico del Sistema UNIX es el sistema de archivos jerárquico.
El sistema de archivos proporciona una forma potente y flexible de organizar y gestionar los datos contenidos en
el ordenador. Aunque muchas de las características del sistema de archivos se inventaron originalmente para el
Sistema UNIX, su estructura ha resultado ser tan útil que se ha adoptado por muchos otros sistemas operativos.
Por ejemplo, DOS adoptó muchos de sus atributos importantes.
Un archivo es la estructura básica utilizada para almacenar información en el Sistema UNIX. El nombre de archivo
identifica de manera unívoca al archivo. El sistema operativo UNIX conoce dónde está localizado el archivo y
guarda además otro tipo de información sobre el archivo.
Se puede definir formalmente el término archivo como un conjunto de datos con un nombre asociado. Los
archivos suelen residir en dispositivos de almacenamiento secundario, tales como cintas, discos rígidos o
disquetes.
La razón de asignar un nombre a cada archivo es que de este modo tanto los usuarios como los programas
pueden hacer referencia a los mismos de una forma lógica.
Los procesos o programas en ejecución disponen de un conjunto de funciones proporcionadas por el sistema
operativo para poder manipular esos archivos. Ese conjunto de funciones se conoce con el nombre de llamadas
al sistema.
El concepto de llamada al sistema es más amplio, pues engloba también funciones relacionadas con la
manipulación de procesos y dispositivos.
Un proceso es un programa en ejecución que puede escribir datos en un archivo mediante la llamada al sistema
write y leerlos más tarde, o bien dejarlos allí para que otros procesos puedan leerlos mediante la llamada al
sistema read. También los procesos tienen la posibilidad de crear archivos, añadir o eliminar información en ellos,
desplazarse dentro para consultar la información deseada, etc. a partir del correspondiente conjunto de llamadas
al sistema.
En cierto modo, se puede entender un archivo como una extensión del conjunto de datos asociados a un proceso,
pero el hecho de que estos datos continúen existiendo aunque el proceso haya terminado, los hace
especialmente útiles para el almacenamiento de información a largo plazo.
Todo el trabajo de los usuarios de un Sistema UNIX está almacenado en archivos. En algunos sistemas podría
ser difícil e incluso imposible encontrar un archivo. El Sistema UNIX tiene varias capacidades que facilitan mucho
este trabajo. Algunas de estas capacidades tienen que ver con la naturaleza básica del sistema de archivos.
Otras tienen que ver con los programas de utilidad disponibles en el Sistema UNIX.
Algunos sistemas operativos imponen a todos sus archivos una estructura determinada bien definida. En UNIX un
archivo no es más que una secuencia de bytes (8 bits). Algunos programas esperan encontrar estructuras de
diferentes niveles, pero el núcleo (kernel) no impone ninguna estructura sobre los archivos. Por ejemplo, los
editores de texto esperan que la información guardada en el archivo se encuentre en formato ASCII, pero el
núcleo no sabe nada de eso.
Un sistema de archivos se puede definir como aquella parte del sistema responsable de la administración de los
datos en dispositivos de almacenamiento secundario. El sistema de archivos debe proporcionar los medios
necesarios para un almacenamiento seguro y privado de la información y, a la vez, la posibilidad de compartir esa
información en caso de que el usuario lo desee.
9.4.1. CARACTERÍSTICAS SISTEMA DE ARCHIVOS
Entre las características más relevantes del sistema de archivos UNIX podemos citar las siguientes:
□ Los usuarios tienen la posibilidad de crear, modificar y borrar archivos y directorios.

□ Para cada archivo se definen tres tipos de acceso diferentes: acceso de lectura, acceso de escritura y
acceso de ejecución. Estos tres tipos de acceso se le aplican al creador del archivo, al grupo al que
pertenece y al resto de los usuarios del sistema; con esto los archivos se pueden compartir.
□ Proteger los datos de los archivos. Cada archivo tiene una serie de derechos asociados, los cuales
determinan y limitan los posibles accesos por parte de otras personas.
□ Cada usuario puede estructurar sus archivos como desee, el núcleo de UNIX no impone ninguna
restricción, ya se encargan los programas de darle un sentido a los ficheros.
□ UNIX ofrece herramientas para realizar copias de seguridad de ficheros para prevenir la pérdida de la
información.
□ Proporciona la posibilidad de cifrado y descifrado de información. Eso se puede hacer para que los datos
sólo sean útiles para las personas que conozcan la clave de descifrado.
□ El usuario tiene una visión lógica de los datos, es el sistema el encargado de manipular correctamente los
dispositivos y darle el soporte físico deseado ala información. El usuario no tiene que preocuparse por los
dispositivos físicos, es el sistema el que se encarga de la forma en que se almacenan los datos en los
dispositivos y de los medios físicos de transferencia de datos desde y hacia los mismos.
□ Tratar a los dispositivos de entrada salida como si fuesen archivos.
□ Tiene una estructura jerárquica en forma de árbol invertido.
□ Realizar un tratamiento consistente de los datos de los archivos.
□ Es un sistema de archivos dinámico porque permite crear, modificar y eliminar ficheros.
□ Los archivos aumentan su tamaño dinámicamente, no teniendo el usuario que especificar previamente un
tamaño.
En UNIX los archivos están organizados en lo que se conoce como directorios. Un directorio no es más que un
archivo algo especial, el cual contiene información que permite localizar otros archivos. Los directorios pueden
contener, a su vez, nuevos directorios, los cuales se denominan subdirectorios.
A la estructura resultante de esta organización se la conoce con el nombre de estructura en árbol invertido.
En el árbol, todos los archivos y directorios dependen de un único directorio denominado directorio raíz o root, el
cual se representa por el símbolo slash "/". En caso de que tengamos vatios dispositivos físicos de
almacenamiento secundario en el sistema (normalmente discos o particiones de disco), todos deben depender del
directorio raíz, y el usuario tratará cada uno de los discos como un subdirectorio que depende, directa o
indirectamente,
9.4.2. ALMACENAR DATOS.
Al almacenar los datos de un fichero en un disco existen dos fórmulas:
□ Asignación continua: Se colocan los k bytes que ocupa un fichero consecutivamente en el disco, Esta
solución tiene el problema de que si el fichero crece será necesario mover el fichero a otra ubicación, es
decir, tendremos fragmentación externa.
□ Asignación discontinua: Los k bytes que ocupa el fichero se dividen en x bloques de un tamaño z y se
colocan de forma no contigua en el disco en bloques. Esto tiene el problema que si el tamaño del bloque
es muy grande se produce fragmentación interna y si el tamaño del bloque es muy pequeño se aumenta
el tiempo de acceso. Generalmente, el tamaño del bloque es de 512, 1024 o 2048 bytes.
Unix utiliza asignación discontinua
9.4.3. NOMBRES DE ARCHIVO
Un nombre de archivo puede ser casi cualquier secuencia de caracteres (generalmente dos nombres de archivos
se consideran el mismo si coinciden en los primeros catorce caracteres, de manera que se debe tener cuidado si
se excede en este número de caracteres. Sin embargo, esto sólo ocurre para ciertos tipos de archivos).
El Sistema UNIX coloca pocas restricciones sobre cómo nombrar archivos. Se pueden utilizar caracteres ASCII,
aunque es muy necesario no incluir caracteres no imprimibles (tecla ctrl., alt, etc), espacios en blanco, tabulador,
y los meta caracteres del shell.
En cuanto a la extensión decir que UNIX es indiferente a la extensión, aunque es recomendable darle la extensión
que espera la aplicación que trata el fichero, por ejemplo el compilador de java espera un .java
Cuando se crean archivos y directorios, está trabajando con un programa importante del Sistema UNIX
denominado el shell. Debería evitar utilizar caracteres en los nombres de archivos que tengan significado especial
para el intérprete de órdenes shell.
9.4.4. TIPOS DE ARCHIVOS
UNIX distingue cinco tipos de archivos: archivos sencillos, directorios, enlaces simbólicos o vinculos, archivos de
dispositivos, y tuberías (pipes) con nombre.
Archivos ordinarios. Se utilizan para almacenar información en dispositivos de almacenamiento secundario

como discos duros, disquetes, cdrom, etc. Los archivos ordinarios pueden almacenar datos, imágenes, código,
ejecutables.
UNIX no asocia ninguna estructura ni ningún significado al contenido del archivo, ya que para él un archivo no es
mas que una ristra de bytes. La encargada de darle un significado a esa ristra de bytes es la aplicación que
maneja el fichero. Por ejemplo el editor de textos vi espera que el contenido de un fichero sea caracteres ASCII,
un navegador web espera que el contenido sea una pagina html, etc.
Vínculos. Un vínculo no es una clase de archivo, sino un segundo nombre para un archivo. Si dos usuarios
necesitan compartir la información de un archivo, ellos pueden tener copias separadas de este archivo. Un
problema al mantener copias separadas es que las dos copias pueden rápidamente perder la consistencia. Por
ejemplo, un usuario puede realizar cambios que el otro podría no conocer.
Un vínculo proporciona la solución a este problema. Con un vínculo, dos usuarios pueden compartir un único
archivo. Ambos usuarios parecen tener copias del archivo, pero solamente existe un archivo con dos nombres.
Los cambios que cualquier usuario realiza tienen lugar sobre la versión común. Este vínculo no solamente ahorra
espacio al tener una única copia de un archivo, sino que asegura que la copia que cada uno utiliza es la misma.
A este tipo de vínculo también se le denomina vínculos duros (hard links).
Sin embargo, existen un tipo especial de vínculos denominado “Vínculos simbólicos”: Los vínculos se pueden
utilizar para asignar más de un nombre a un archivo. Pero tienen algunas limitaciones importantes. No se pueden
utilizar para asignar a un directorio más de un nombre. y no se pueden utilizar para vincular nombres de archivos
sobre computadoras diferentes. Esto es un fallo importante de los vínculos, ya que la Versión 4 proporciona dos
sistemas de archivos distribuidos, NFS y RFS, que hacen posible la compartición de archivos entre
computadoras.
Estas limitaciones pueden eliminarse utilizando vínculos simbólicos, introducidos en el UNIX Sistema V Versión 4
procedente de BSD. Un vínculo simbólico es un archivo que sólo contiene el nombre de otro archivo. Cuando el
sistema operativo opera sobre un vínculo simbólico, éste se dirige al archivo al que apunta el vínculo simbólico.
Los vínculos simbólicos no sólo se pueden utilizar para asignar más de un nombre a un archivo, sino que pueden
usarse para asignar más de un nombre a un directorio.
Los vínculos simbólicos también pueden ser utilizados por vínculos que residen en sistemas de archivos físicos
diferentes. Esto hace posible que un árbol de directorio lógico incluya archivos que residen sobre computadoras
diferentes que están conectadas a través de una red.
Es análogo a lo que Microsoft Windows® denomina accesos directos.
Directorios. Un directorio es un archivo que contiene información sobre las localizaciones y atributos de otros
archivos. Básicamente un directorio es un contenedor de un grupo de archivos organizados de la forma deseada.
Es el concepto de carpetas de otros sistemas operativos.
Sobre el Sistema UNIX, un directorio también puede contener otros directorios. Un directorio dentro de otro
directorio se denomina subdirectorio. Se puede subdividir un directorio en tantos subdirectorios como desee, y
cada uno de ellos puede contener tantos subdirectorios como quiera.
La estructura del directorio es la siguiente:
Cada entrada en el directorio contiene el nombre del archivo y su número de inode. La cantidad de bytes
reservada para el nombre del archivo suele ser 256 caracteres. Toda la información relativa al archivo está
almacenada en su inode. Todos los directorios en UNIX son archivos y pueden contener cualquier número de
entradas, además no existe limitación en el número de archivos o subdirectorios que se pueden almacenar en un
directorio.
Numero de inode Nombre del archivo
Entrada de un directorio
Archivos de dispositivos.
UNIX se comunica con los dispositivos periféricos por medio de los archivos de dispositivo, por lo tanto se puede
ver un archivo de dispositivo como un archivo especial que representa un dispositivo fisico. Puede ser un terminal,
un tarjeta de red, disco duro SCSI o IDE, etc, es decir, es el medio utilizado para acceder a dispositivos hardware,
estando por tanto, cada hardware asociado a un archivo especial.
Desde la perspectiva del usuario, el Sistema UNIX trata los archivos especiales como archivos ordinarios; esto es,
puede leer o escribir los dispositivos exactamente como lee y escribe los archivos ordinarios. Sin embargo no
contienen datos sino información de la ubicación del dispositivo y de cómo se va a comunicar UNIX con el mismo.
Esta forma de tratar el hardware del sistema tiene una consecuencia importante para los usuarios del Sistema
UNIX. Puesto que UNIX trata casi todo como si fuese un archivo, no se necesita aprender las particularidades del
hardware de la computadora. Una vez que se aprende a manejar los archivos del Sistema UNIX, se sabe cómo
manejar todos los objetos del Sistema UNIX.
Los archivos de dispositivos se almacenan en un directorio especial de UNIX: /dev pudiendo ser de dos tipos:
□ Archivos de dispositivo en modo carácter

□ Archivos de dispositivo en modo bloque.
Archivos de dispositivo en modo bloque:
Los archivos de dispositivo modo bloque son aquellos que manejan dispositivos en modo bloque. Los dispositivos
modo bloque transfieren datos en bloques de longitud fija a través de buffers de entrada salida. Los dispositivos
que usan estos archivos son dispositivos de almacenamiento y acceso aleatorio, es decir, discos, cdroms, etc
Para crear este tipo de archivos se utiliza el comando mknod
Archivos de dispositivo en modo carácter:
Los archivos de dispositivo en modo carácter son aquellos que manejan dispositivos en modo carácter. Los
archivos de dispositivo de tipo carácter son aquellos que la entrada salida se realiza carácter a carácter no
necesitando de ningun tipo de sistema de archivos en especial, por lo tanto no se utilizan los buffers. Algunos
ejemplos de este tipo de archivos son: monitores, impresoras, etc. Al igual que los archivos de dispositivo modo
bloque, estos archivos se crean mediante la llamada al sistema mknod
Algunos de los archivos de dispositivos más relevantes son:
□ /dev/dsk Archivo de dispositivo modo bloque de las unidades de disco duro.

à En Linux los discos duros tienen como archivo de dispositivo IDE el archivo /dev/hdxy, donde “x” es
una letra que varia en función de la interfaz IDE a la que este conectado el dispositivo en placa y a la
configuración de este (maestro y esclavo):
a para el dispositivo conectado al IDE 1 como maestro
b para el dispositivo conectado al IDE 1 como esclavo
c para el dispositivo conectado al IDE 2 como maestro
d para el dispositivo conectado al IDE 2 como esclavo
e “y” es un numero que indica la partición del disco:
hdb1 partición primera del disco duro conectado al IDE1 como esclavo.
hdb2 partición secundaria del disco duro conectado al IDE1 como esclavo.
□ /dev/sdxy Archivo de dispositivo modo bloque para los discos de tipo SCSI (Small Computer Standard
Interface). xy identifica el número de disco y su partición correspondiente.
□ /dev /fdx Archivo de dispositivo correspondiente al disco flexible x.
□ /dev /ttyNN Archivo correspondiente al terminal NN.
□ /dev/lpx Archivo correspondiente a la impresora x.
□ /dev/cdrom Archivo de dispositivo asociado al CD-ROM.
Estos archivos, al hacer un listado del directorio /dev, se identifican por su nombre y por dos números, llamados
número mayor (major numbetr) y número menor (minor number). El primero de ellos coincide para todos los
dispositivos del mismo tipo y con el segundo se diferencia entre distintos dispositivos de la misma familia. Ambos
números son empleados por el núcleo.
Tuberías con nombre (pipes)
Son mecanismos de comunicación que permiten la transferencia de datos entre dos procesos.
A continuación se vera como crear archivos de dispositivo, pipes o sockets.

Tanto los ficheros especiales orientados a caracter como los orientados a bloque, y tambien los pipes, se crean
con la orden mknod (MaKe NODe).
La sintaxis básica de mknod es la siguiente: mknod <fichero> [tipo] major minor
donde:
□ <fichero> nombre que queremos asignarle al archivo.

□ [tipo] Contiene los valores:
à p (pipe)
à c (character)
à b (block),
□ major corresponden a lo que se denomina major number, número principal de un archivo de dispositivo y
designa un tipo de periférico (impresoras, discos duros, terminales...),
□ minor corresponden a lo que se denomina minor number, número secundario de un archivo de dispositivo
hace referencia a un elemento de dicha clase de dispositivo (la impresora conectada a lp0, la terminal
número 3...).
9.4.5. ESTRUCTURA INTERNA DEL SISTEMA DE ARCHIVOS
En la estructura del sistema de archivos de un UNIX versión System V se distinguen cuatro partes:
□ El bloque de arranque.
□ El super bloque.
□ La lista de nodos índice
□ Los bloques de datos.
Vamos a describir a continuación cada una de estas partes.
9.4.5.1. EL BLOQUE DE ARRANQUE
Se sitúa al comienzo del sistema de archivos, en el primer sector, y contiene el código de arranque que es un
programa que se encarga de buscar el sistema operativo y cargarlo en memoria para iniciar la máquina.
9.4.5.2. EL SÚPER BLOQUE
El súper bloque ocupa el primer bloque lógico del disco y describe el estado de un sistema de archivos
El súper bloque es la pieza mas importante en cualquier sistema de archivos, tanto que si se daña se pierden
todos los datos almacenados en el: sistema de archivos que representa. Para evitar esto, el superbloque es
redundante, es decir, existen varias copias del mismo, distribuidas por el disco para evitar los inconvenientes de
su pérdida
En el súper bloque se almacena la siguiente información:
□ Tamaño del sistema de archivos.
□ Tamaño de cada bloque de disco.
□ Lista de bloques libres.
□ Índice del siguiente bloque libre en la lista de bloques libres.
□ Tamaño de la lista de inodes.
□ Número de inodes libres
□ Lista de inodes libres
□ Índice del siguiente inode libre en la lista de inodes libres
□ Bandera (flag) que indica si el super bloque se ha modificado o no.
9.4.5.3. LA LISTA DE NODOS INDICE
Se encuentra a continuación del super bloque.
Esta lista tiene una entrada (denominada inode) por cada archivo del sistema de archivos donde se guarda la
descripción del mismo.
Durante el arranque del sistema, el núcleo lee la lista de inodes del disco y carga una copia en memoria conocida
como tabla de inodes.
Los inodes contienen toda la información acerca del archivo que representan. Esta información incluye
propietario, derechos de acceso, tamaño, localización en el sistema de archivos, etc. A continuación se muestran
aquellos campos componentes de un inode más relevantes:
□ Identificador del propietario del archivo y del grupo al que pertenece.

□ Tipo de archivo.
□ Derechos de acceso. Se reservan nueve bits para representar los derechos de lectura, escritura y
ejecución (rwx) para el propietario, el grupo y el resto, y otros tres bits para definir si están o no activas las
banderas setuid, setgid y sticky bit.
□ Fecha de la última modificación.
□ Contador de enlaces (links).
□ Tamaño del archivo.
□ Entradas para los bloques de dirección. Las entradas que apuntan a los bloques de datos son 13. Los 10
primeros punteros apuntan a bloques directos; así, los datos de archivos pequeños (a lo sumo 10 bloques
de disco) pueden ser referenciados inmediatamente, puesto que mientras el archivo esta abierto se
mantiene una copia de su inode en memoria principal.
Los tres apuntadores siguientes apuntan a bloques indirectos.
El primero de ellos es un puntero indirecto simple,
El segundo un puntero indirecto doble
El tercero es un puntero indirecto triple.
La estructura comentada aparece representada en la siguiente Figura 2.
Tabla de inode bloques de datos
bloques de datos
SIMPLE
DOBLE
TRIPLE
bloques de datos
bloques de datos
bloques de datos
Figura 2. Estructura Tabla de Inodes
9.4.5.4. BLOQUES DE DATOS
Comienzan a continuación de la lista de nodos índice y ocupan el resto del sistema archivos. En los bloques de
datos se almacena el contenido de los archivos referenciados por un inode.
9.4.5.5. CREACIÓN DE UN SISTEMA DE ARCHIVOS
Para crear un sistema de archivos se utiliza la orden mkfs cuya sintaxis es la siguiente
mkfs [-vct] dispositivo tamaño. Donde
□ Dispositivo es el archivo de dispositivo utilizado para acceder al periférico

□ Tamaño indica el número de bloques que tiene el sistema de archivos
□ Las opciones vct significan
à v modo verboso.
à c indica que se realice una comprobación con objeto de verificar que todos los bloques son correctos.
à t sirve para indicar el tipo de sistema de archivos que desamos crear.
Una vez creado el sistema de ficheros, hay que incorporarlo a la estructura jerárquica de Unix, lo que
habitualmente se denomina montar un sistema. Para ello, utilizaremos la orden mount.
Hay que montar los sistemas de archivos en directorios que tienen que estar vacios y a ese directorio se le llama
punto de montaje
La sintaxis básica es la siguiente:
mount –tahvrw dispositivo directorio
à t indica el tipo de sistema de archivos que montamos

à a monta todos los sistemas de archivos incluidos en el fichero /etc/fstab
à h ayuda
à v modo verboso
à r monta el sistema de archivos en modo lectura
à w monta el sistema de archivos en modo lectura-escritura.
Una vez que se acaba de trabajar con un sistema de archivo previamente montado hay que desasociarlo de la
estructura jerarquica, a esto se le llama desmontarlo y para ello se utiliza la orden umount, que recibe como
parámetro bien el directorio a desmontar o bien el dispositivo asociado a ese directorio
9.4.6. ESTRUCTURA EXTERNA DEL SISTEMA DE ARCHIVOS
La estructura externa del sistema de archivos de Unix es jerárquica en forma de árbol invertido. Al directorio raíz
se le denomina con el símbolo “/” y dentro de el puede haber tantos archivos como directorios se quiera.
Se puede observar que de esta forma se da una relación padre-hijo, al igual que en cualquier árbol genealógico.
Todos los directorios tienen dos entradas especiales que son:
□ El punto . denota al propio directorio

□ El punto punto .. que denota al directoro padre
Al conectarnos al sistema UNIX, nos colocamos en un directorio especial denominado directorio de recepcion o
de partida, este directorio no se debe de confundir con el directorio donde se trabaja en un momento dado, al cual
se le llama directorio de trabajo.
En esta estructura, todo archivo o directorio se define por una ruta, por lo tanto la ruta no es mas que la forma de
localizar un archivo o directorio en el sistema de archivos. Existen dos tipos de rutas:
□ Rutas absolutas: son aquellas que siempre parten del directorio raiz
□ Rutas relativas: son aquellas que parten del directorio de trabajo.
9.4.6.1. DIRECTORIOS Y ARCHIVOS ESTÁNDAR
En los sistemas operativos tipo UNIX existen una serie de archivos y directorios estándar. Los directorios
estándar contienen archivos concretos.
□ Directorio raíz ( / ) es el origen de la jerarquía del sistema de archivos. Contiene algunos archivos y
directorios estándar.
□ /bin es el directorio donde se encuentran los ejecutables de la mayoría de las órdenes de UNIX, entre las
cuales se cuentan cat, chmod, cp, csh., date, echo, kill, ksh, In, Is, mail, mkdir, more, mv, ping, ps, pwd,
rm, rmdir, sh, stty, tar, vi, y zcat. Todos los archivos de este directorio son archivos ejecutables, o bien
vínculos simbólicos que llevan a archivos ejecutables ubicados en otros directorios
□ /dev Es el directorio de dispositivos, y contiene archivos que corresponden a los dispositivos del sistema
(terminales, unidades de disco, lector de CD-ROM, impresora, etc.) Entre los archivos de este directorio
están:
à cdrom: el lector CD-ROM
à fd: la unidad de disquete
à hd: dispositivo IDE
à sd: dispositivo SCSI
à isdn: RDSI
à Ip: impresora
à tty terminal.
□ /etc El directorio /etc, contiene archivos para la administración y configuración del sistema, estando
restringidos su utilización a los usuarios. Entre los archivos residentes en este directorio están
à inetdconf
à passwd
à printcap
à profile
à services
à shadown
□ /lib contiene las imágenes de las librerías compartidas. Estos ficheros contienen código que compartirán
muchos programas. En lugar de que cada programa contenga una copia propia de las rutinas
compartidas, estas son guardadas en un lugar común, en /lib. Esto hace que los programas ejecutables
sean menores y reduce el espacio usado en disco
□ /lost+found contiene todos los archivos que no están relacionados con ningún directorio. Estos archivos
se buscan mediante una herramienta de UNIX, fsck (chequeo del sistema de archivos), que se emplea
para comprobar sistemas de archivos.
□ /tmp Usado por distintas órdenes y aplicaciones, el directorio /tmp contiene archivos temporales. Todos
los archivos de este directorio se borran periódicamente, para que el disco no se llene de archivos
temporales. La duración de los archivos residentes en el directorio /tmp será establecida por el
administrador del sistema
□ /users Dotado de un cierto tipo de organización, el directorio /users se utiliza normalmente para
almacenar los directorios iniciales de todos los usuarios del sistema.
□ /usr Contiene Contienen una serie de subdirectorios que contienen a su vez algunos de los más
importantes y útiles programas y ficheros de configuración usados en el sistema. Algunos de estos
subdirectorios son:
à /usr/X386 contiene el sistema X Window. El sistema X Window es un entorno gráfico grande y
potente el cual proporciona un gran número de utilidades y programas gráficos, mostrados en
"ventanas" en su pantalla. El directorio /usr/X386 contiene todos los ejecutables de X Window,
ficheros de configuración y de soporte.
à /usr/bin es el almacén real de programas del sistema UNIX. Contiene la mayoría de los programas
que no se encuentran en otras partes como /bin.
à /usr/etc Como /etc contiene diferentes ficheros de configuración y programas del sistema,
/usr/etc contiene incluso más que el anterior. En general, los ficheros que se encuentran en /usr/etc/
no son esenciales para el sistema, a diferencia de los que se encuentran en /etc, que si lo son.
à /usr/include contiene los ficheros de cabacera para el compilador de C. Estos ficheros (la mayoría de
los cuales terminan en .h, de "header") declaran estructuras de datos, subrutinas y constantes usados
en la escritura de programas en C. Los ficheros que se encuentran en /usr/include/sys son
generalmente usados en la programación de UNIX a nivel de sistema.
à /usr/g++-include contiene ficheros de cabecera para el compilador de C++ (muy parecido a
/usr/include).
à /usr/lib contiene las librerías equivalentes "stub" y "static" a los ficheros encontrados en /lib. Al
compilar un programa, este es "enlazado" con las librerías que se encuentran en /usr/lib, las cuales
dirigen al programa a buscar en /lib cuando necesita el código de la librería. Además, varios
programas guardan ficheros de configuración en /usr/lib.
à /usr/local es muy parecido a /usr contiene programas y ficheros no esenciales para el sistema, pero
que hacen el sistema más divertido y excitante. En general, los programas que se encuentran en
/usr/local son específicos de su sistema, esto es, el directorio /usr/local difiere bastante entre
sistemas UNIX.
à /usr/man Este directorio contiene las páginas de manual. Hay dos subdirectorios para cada
página "sección" de las páginas (use la orden man man para más detalles). Por ejemplo,
/usr/man/man1 contiene los fuentes (es decir, los originales por formatear) de las páginas de manual
de la sección 1, y /usr/man/cat1 las páginas ya formateadas de la sección 1.
□ /var contiene directorios que a menudo cambian su tamaño o tienden a crecer. Muchos de estos
directorios solian residir en /usr, pero los directorios que cambian a menudo han sido llevados a /var.
Algunos de estos directorios son:
à /var/adm contiene varios ficheros de interés para el administrador del sistema, especificamente
históricos del sistema, los cuales recogen errores o problemas con el sistema. Otros ficheros guardan
las sesiones de presentación en el sistema, así como los intentos fallidos.
à /var/spool contiene ficheros van a ser pasados a otro programa. Por ejemplo, el correo de llegada
será almacenado en /var/spool/mail hasta que lo lea o lo borre. Artículos nuevos de las news se
encuentran en /var/spool/news, etc.
□ /unix contiene la imagen binaria del núcleo de UNIX que se carga al arrancar el sistema. El UNIX BSD
tiene la imagen en /vmunix.
□ /etc/passwd Es un fichero que contiene la información anterior acerca de los usuarios. Cada línea del
fichero contiene información acerca de un único usuario; el formato de línea es:
nombre:clave encriptada:UID:GID:info_usuario:dir_inicio:shell
à nombre: es el login del usuario que introduce para conectarse.
à clave: contiene la contraseña encriptada en los sistemas antiguos de UNIX; actualmente la clave
encriptada aparece en /etc/shadow, con lo que este campo del fichero /etc/passwd aparece en
blanco.
à UID: numero asignado al usuario; su rango está entre 0 y 65535, estando reservado el 0 al root y del
1 al 99.
à GID: numero asignado al grupo al que pertenece el usuario; su rango está entre 0 y 65535, estando
reservado del 0 al 99.
à Info_usuario: contiene información relativa al usuario: nombre, telefono, etc.
à Dir_inicio: contiene la ruta absoluta del directorio de recepción del usuario.
à Shell: contiene la ruta absoluta del shell de conexión.
9.4.7. OPERACIONES CON ARCHIVOS Y DIRECTORIOS
Cambio de directorios. Se puede mover entre directorios utilizando la orden cd (change directory), con una ruta
absoluta o relativa.
Si se emite la orden cd sin ningún camino, se moverá al directorio de recepción
Creación de un directorio. Se puede crear nuevos directorios en el sistema de archivos con la orden mkdir
(make directory).
Movimiento y renombrado de archivos. Un archivo se mueve desde un directorio hasta otro con mv.
Movimiento de directorios. Otra nueva característica de la Versión 4 es la posibilidad de utilizar mv para mover
directorios. Una única orden mv se puede utilizar para mover un directorio y todos sus archivos y subdirectorios,
de la misma forma que se mueve un único archivo
Copia de archivos. Un motivo corriente para copiar un archivo es la seguridad, de manera que uno pueda
modificar un archivo sin preocuparse de la pérdida del original. La orden cp es similar a mv, excepto que copia
archivos en lugar de moverlos o renombrarlos.
Copia del contenido de un directorio. Una característica nueva de cp en la Versión 4 es la opción -r (recursive),
que permite copiar una estructura de directorio completa en otro directorio.
Eliminación de archivos. Para suprimir archivos que no se quieren o no se necesitan más se utiliza la orden rm
(remove). La orden rm acepta varios argumentos y toma varias opciones.
□ Si se especifica más de un nombre de árchivo, elimina todos los archivos nombrados.

□ Si quiere evitar la eliminación accidental de archivos, puede utilizar rm con la opción -i (interactive).
Eliminación de un directorio. Existen dos formas para eliminar o borrar un directorio.
□ Si el directorio está vacío (no contiene ni archivos ni subdirectorios), puede utilizar la orden rmdir
(remove directory).
□ Si el directorio no esta vacío se utiliza la orden rm –r
Vinculación de archivos. La orden ln crea vínculos entre entradas de directorio,
Vínculos simbólicos. La orden In puede vincular archivos dentro de un único sistema de archivos. En la Versión
4 se pueden vincular archivos entre sistemas de archivos utilizando la opción -s (symbolic) con In.
Visualización de archivos y directorios

Para ver los archivos de un directorio, se introduce la orden ls (list):
UNIX mantiene infomlación complementaria de los archivos, que se puede obtener utilizando las opciones de la
orden ls. Existen muchas opciones con la orden ls. Se utilizan para obtener infomlación complementaria de los
archivos y para controlar el formato de visualización de esta infomlación.
Los archivos con nombres que comienzan con un punto están ocultos en el sentido de que nomlalmente no se
visualizan cuando se listan los archivos de un directorio. Para evitar confusión, ls supone que no se quieren listar
estos ficheros a menos que explícitamente se solicite. Es decir, ls no visualiza ningún nombre de archivo que
comience con un . (punto).
Para ver todos los archivos de un directorio, incluidos los ocultos utilice ls -a.
Cuando se utiliza la orden ls no se sabe si un nombre hace referencia aun archivo ordinario, a un programa
ejecutable o a un directorio. Si se ejecuta la orden ls -F, produce una lista donde los nombres se marcan con
símbolos que indican la clase de archivo a que cada nombre hace referencia:
□ Archivos ejecutables: se listan con * seguidos por sus nombres.

□ Directorios se listan con / seguidos de sus nombres.
□ Vínculos simbólicos se listan con @ seguidos por sus nombres.
□ Los archivos ocultos no se listan.
Por defecto, ls en la Versión 4 visualiza los archivos en columnas múltiples, en orden descendente. Existen
algunas opciones frecuentemente utilizadas con la orden ls que controlan el fomlato utilizado para visualizar los
nombres de archivos.
Se puede utilizar la opción -x para visualizar los nombres de los archivos horizontalmente, en tantas líneas como
sea necesario, en orden ASCll. Se puede utilizar la opción -1 (uno) para hacer que los archivos se visualicen una
línea por fila, en orden alfabético.
Para obtener información más detallada sobre los archivos, se utiliza la opción -l (longformat) de ls.
Por ejemplo,:
$ ls -1
tota128
drwxr-xr-x 3 you group1 362 Nov 29 02:34 ficher1
lrwxr-xr-x 2 you group1 666 Apr 1 21:17 ficher2
-rwxr-xr-x 1 you group1 82 Feb 2 08:08 ficher3
La primera línea ("total 28") de la salida da la cantidad en bloques de espacio de disco utilizado
El resto de las líneas del listado muestran información sobre cada uno de los archivos del directorio.
Cada línea del listado contiene siete campos.
El primer carácter de cada línea informa de la clase de archivo que es:
□ – Archivo ordinario
□ d Directorio
□ b Archivo de bloques especiales
□ c Archivo de caracteres
□ l Vinculación simbólica
□ p Archivo especial de cauce nombrado
El resto del primer campo, es decir, los nueve siguientes caracteres, contienen información sobre las
autorizaciones de los archivos. Las autorizaciones determinan quién puede operar con un archivo o un directorio y
cómo puede utilizarlo. Las autorizaciones son una parte importante del sistema de archivos de UNIX.
El segundo campo de la izquierda contiene la cuenta de vinculación
Los campos tercero y cuarto de la izquierda muestran el propietario del archivo (en este caso los archivos
pertenecen al nombre you y el grupo al que pertenece group1).
El quinto campo refleja el tamaño en bytes.
El sexto campo indica la fecha en la que se creó o modificó por última vez el archivo.
El séptimo campo indica el nombre del archivo.
Contenido de un archivo. La forma más simple y más básica de inspeccionar un archivo es con la orden cat. cat
(de concatenate) toma cualquier archivo que se le especifica y lo visualiza sobre la pantalla.
9.5. INTERFACES GRAFICAS.
La interfaz grafica de UNIX es el sistema X-Window (ojo no se dice X-Windows), o familiarmente conocido por X.
El nacimiento de X deriva del diseño de un entorno de ventanas denominado W para el sistema operativo V en la
Universidad de Stanford. Al mismo tiempo en el MIT se trabajaba en el proyecto Atenea, que intentaba conseguir
una interfaz gráfica independiente de una plataforma hardware concreta y que fuera capaz de comunicarse en
red.
Los dos proyectos se juntaron en uno solo, dando lugar a la primera versión de X-Window en el 1986,
denominándose esta primera versión X10
IBM, Sun, AT&T, MIT y DEC forman un grupo denominado X Consortium, para promocionar y estandarizar X
Window. Este grupo de grandes organizaciones supervisa la creación y lanzamiento de nuevas versiones de X11.
La versión actual de X es la X11R6 (X11 Release 6). La mayor parte de los UNIX actuales incorporan el sistema
de ventanas X Windows diferenciandose en el gestor de ventanas que utilizan.
Para ser más concretos en la definición hay que decir que X está desarrollado bajo el modelo cliente-servidor.
□ El software servidor gestiona todo el acceso al hardware, encargandose de controlar los dispositivos
que se utilizarán en la interfaz grafica: raton, teclado y pantalla. El servidor X recibe los eventos
generados por este hardware y tambien es el encargado de mostrar los gráficos e iconos en el monitor.
Más explícitamente, las tareas del servidor son:
à Manipulación a bajo nivel de ventanas (operaciones de creación y destrucción de las mismas), sin
confundirlo con el manejo que posteriormente podemos hacer mediante el gestor escogido.
à Servir como gestor de recursos del sistema para las aplicaciones a ejecutar.
à Procesar órdenes para el dibujo de gráficos.
à Notificar a las aplicaciones los eventos ocurridos (pulsado de una tecla, movimiento del ratón,
errores...)
à Monitorizar y comunicar a las aplicaciones los errores que se pueden generar.
à Control de la pantalla.
à Comunicación entre los diferentes clientes (cortar y pegar...)
□ El software cliente son todos los programas que utilizan el servidor X para interactuar con los usuarios,
estableciendo para ello una conexión con el servidor X por la cual le dicen al servidor que es lo que
quieren mostrar en la pantalla y el servidor les envia las ordenes del usuario. Ejemplo de clientes son
xterm (simula un terminal en una ventana), xman, xview, Mosaic (existe una versión para LINUX), etc..
cada uno de lo que coloquialmente denominamos "programas para X " ó "programas para ejecutar bajo
X" (aunque con xterm también podemos ejecutar cualquier otro software que no esté concebido para X).
La comunicación con el servidor se realiza mediante el denominado protocolo X Network que especifica una
serie de normas y convenios sobre como se envia la información entre los clientes y los servidores.
Gracias a este protocolo X y a la distinción entre clientes y servidores, es posible ejecutar un cliente X en un
ordenador remoto.
Por encima del programa de implementación del protocolo X Network está una interfaz de bajo nivel, que se
encuentra entre el sistema base de red y los programas de más alto nivel. Esta interfaz de bajo nivel se llama
Xlib. Los programas de aplicación normalmente utilizan funciones de Xlib en vez de otras funciones de bajo nivel.
Por ultimo decir que XFree86 es la implementación del X Window disponible para LINUX (y otras
implementaciones del UNIX) en su versión 3.1.2, basada en el servidor X386 desarrollado por el MIT destinado a
plataformas de Intel 386/486 y Pentium además de la configuración hardware común a este tipo de procesadores.
Para conocer más detalles del software instalado podemos ejecutar el comando 'xdpyinfo' en una ventana de
terminal el cual nos mostrará información detallada sobre la versión y características del entorno gráfico.
XFree86 está distribuido bajo una licencia que permite disponer libremente tanto de software que lo forma en
forma de código fuente como en formato binario. Está desarrollado, mantenido y distribuido por grupo XFree86
Project Inc., cuyo fin es el desarrollar el servidor X Window para cualquier UNIX ejecutable en plataformas PC
(http://www.xfree.org).
9.5.1. Gestor de ventanas
Un gestor de ventanas no es mas que un programa cliente que se encarga de aportar a todas las ventanas un
aspecto común en base a bordes de ventana, estilo de los botones, barras de desplazamiento, barra de titulo, etc.
Las distribuciones de UNIX (al igual que las de Linux) traen consigo diversos gestores de ventanas dandole la
oportunidad al usuario que escoga el que más le gusta o el que se acople mejor a su máquina, etc.
Algunas de sus tareas son:
□ Permitir redimensionar las ventanas.

□ Mover las ventanas a cualquier posición de la pantalla.
□ Convertir una ventana en un icono y viceversa.
□ Decorar ventanas con barras de títulos y desplazamiento, bordes, botones, etc.
□ Control de todas las ventanas abiertas en un determinado momento.
□ Lanzamiento de aplicaciones.
Gestores de ventanas son los famosos GNOME y KDE para Linux, CDE para Solaris, fwdm para Unix, aunque
existen muchos más disponibles en internet
9.6. IMPLEMENTACIONES COMERCIALES Y SOFTWARE LIBRE
Las compañías que distribuyen el sistema operativo UNIX, al portarlo a sus propias máquinas, también le dan un
nombre propio. A continuación y en forma de tabla se muestra una lista de alguna de las compañías que
distribuyen UNIX en sus equipos.
Nombre empresa Nombre sistema operativo UNIX

AT&T UNIX SVR3
AT&T UNIX SVR4
Sun Microsystems/SunSoft SunOS
Sun Microsystems/SunSoft Interactive UNIX
Hewlet Packard (HP) HP-UX
Data General DG-UX
Novell UnixWare
Santa Curz Operation (SCO) UnixWare
Santa Curz Operation (SCO) XENIX
Santa Curz Operation (SCO) OpenServer
IBM AIX
Silicon Graphics (SGI) IRIX
Digital Equipment Corp (DEC) ULTRIX
Digital Equipment Corp (DEC) Digital UNIX
NCR NCR UNIX
Siemens Nixdorf Reliant UNIX
Caldera Caldera OpenLinux
RedHat Software RedHat Linux
Otras compañías no tienen una vocación tan comercial como las anteriores. Ejemplos de estas compañias son:
Nombre empresa Nombre sistema operativo UNIX

UC Berkeley BSD (Berkeley Software Distribution)
FreBSD Project FreeBSD
Free Software Foundation GNU/Linux
Linux Trovalds Linux Kernel
Debian Debian GNU/Linux
Hay otras implementaciones de UNIX para el 80386 y 80486. La arquitectura 80386 se presta al diseño de UNIX y
buen un número de vendedores han sacado ventaja de este factor.
Todas las versiones no comerciales de UNIX soportan básicamente el mismo software, entorno de programación,
y características de red. Sin embargo, hay algunas fuertes diferencias entre las versiones comerciales de UNIX.
En primer lugar, las versiones no comerciales soportan un rango de hardware diferente de las implementaciones
comerciales, es decir, soportan la mayoría de dispositivos hardware conocidos, sin embargo, los vendedores de
UNIX comercial por lo general tienen una base de soporte menos amplia, reduciendose a su propio hardware
En lo que concierne a estabilidad y robustez, muchos usuarios han comentado que las versiones no comerciales
son al menos tan estables como los sistemas UNIX comerciales.
El factor más importante a considerar por muchos usuarios es el precio. El software no comercial es gratis, si se
tiene acceso a Internet. Si no tiene acceso a Internet, tiene la opción de comprarlo pidiéndolo por correo en
disquetes, cinta o CD-ROM.
El valor de las implementaciones comerciales de UNIX incluye el precio del software en sí, mas la documentación,
el soporte, y relativamente una calidad. Estos factores son muy importantes para grandes instituciones, pero los
usuarios de ordenadores personales pueden no necesitar esos beneficios.
10. CONCLUSIÓN
En este tema hemos intentado mostrar una imagen clara de qué es un sistema operativo, cuáles son sus
funciones principales, y cómo se implementa cada uno de sus componentes.
Hemos definido sistema operativo como el intermediario entre el hombre y el hardware de un ordenador. De este
modo, el usuario no tiene que preocuparse del funcionamiento de su hardware, ya que es el sistema operativo el
que se encarga de controlar todos los recursos y dispositivos el ordenador.
También se ha repasado dos de las familias más importantes de sistemas operativos en la actualidad: Sistemas
Windows y Sistemas UNIX.
El sistema operativo Windows es el más conocido por la mayoría de los usuarios informáticos. Ha evolucionado
mucho desde Windows 3.11, pasando por Windows 95, Windows 98, Windows 2000, Windows ME, Windows
2003 y Windows XP. Durante este proceso de cambio se ha mejorado la interfaz para hacerla más amigable y
fácil de usar, la robustez del sistema de archivos, pasando del VFAT al NTFS y otros aspectos como la seguridad
del sistema y su estabilidad. La existencia de múltiples versiones no se debe únicamente al progreso del sistema
también pueden coexisitir para adaptarse más finamente a las necesidades de cada usuario final: así por ejemplo
Windows XP Home Edition es para el usuario no técnico, mientras que Windows XP Professional Edition para el
más experto, Windows CE para el usuario de dispositivos portátiles de pequeño tamaño y Windows 2003 Server
para los que necesitan un servidor.
11. BIBLIOGRAFÍA
□ P. Brinch Hansen: Operating System Principles.
□ Juan A. Pérez-Campanero: Concepto de sistemas operativos.
□ A. Burns y G. Davies: Programación Concurrente.
□ H. M. Deitel: An Introduction to Operating Systems.
□ Peterson y Silberschatz: Sistemas Operativos: Conceptos fundamentales.
□ Thurrott, P.: Características de Windows 2000 Profesional
□ Pellegrini, F.: Introducción a Windows NT
□ James C. Amstrong Jr.: Los secretos de UNIX.
□ M. Catalina Gallego y A. Catalina Gallego: Iniciación y Referencia Unix/Linux
□ Steve Moritsugu: La Biblia de UNIX.
□ Syed M. Sarwar, Robert Koretsky, Syed A. Sarwar: El libro de UNIX.
□ www.microsoft.com
12. ESQUEMA – RESÚMEN
SISTEMAS OPERATIVOS
Cuando hablamos de sistema operativo, nos referimos al intermediario entre el usuario y el ordenador. Es el
encargado de dar una visión transparente del sistema al usuario. De este modo el usuario no tiene que
preocuparse de las características técnicas de los componentes de la computadora que está utilizando.
Básicamente el sistema operativo tiene ocho funciones (componentes) bien delimitadas:
□ Administración de procesos. Los ordenadores actuales son capaces de realizar varias cosas al mismo
tiempo, y esto se debe esencialmente a la capacidad que tiene el sistema operativo para gestionar los
procesos:
à Crea y elimina procesos de usuario y procesos del sistema.
à Suspende y continúa procesos.
à Proporciona mecanismos para la sincronización de procesos.
à Proporciona mecanismos para la comunicación de procesos.
□ Administración de la memoria principal. El sistema operativo se encarga del flujo de información desde la
memoria al disco, para que se puedan ejecutar los programas.
□ Administración de archivos. El sistema operativo ofrece al usuario la posibilidad de trabajar con ficheros,
para una mayor comodidad a la hora de almacenar la información.
□ Administración del sistema de E/S. Por lo normal, un ordenador dispone de varios periféricos conectados
a él, el funcionamiento de los cuales es desconocido por el usuario; por lo que el sistema se encarga de
aplicar los mecanismos necesarios para su funcionamiento.
□ Administración del almacenamiento secundario. Es el encargado de llevar el control del almacenamiento
en disco.
□ Operación en red. Ofrece al usuario una apariencia de ordenador único.
□ Sistema de protección. Encargado de proteger los datos entre usuarios, así como la información asociada
a cada uno de sus procesos.
□ Sistema de intérprete de comandos. Sin él, el usuario no podría comunicarse con la máquina.
En la actualidad, lo más normal es encontrarnos ante sistemas capaces de soportar la ejecución simultánea de
programas. A estos sistemas se les denomina Sistemas Multitarea. La clave principal en este entorno, es sin duda
alguna, el concepto de proceso. Un proceso es un programa en ejecución que tiene asociada cierta información:
estado de la pila, contador de programa, valor de los registros…
Un proceso puede tener uno de los siguientes estados:
□ En ejecución: utiliza la CPU en el instante dado.

□ Listo: se detiene en forma temporal para que se ejecute otro proceso
□ Bloqueado: no se puede ejecutar debido a la ocurrencia de algún evento externo.
El sistema operativo es el encargado de llevar a cabo la alternancia entre los procesos, de tal manera que sólo
uno se encuentre en estado de ejecución en un ciento instante. Los procesos se comunican entre sí mediante el
envío de mensajes de unos a otros.
Todo sistema operativo que se precie tiene que tener un buen sistema de protección de memoria. Principalmente
hay que proteger dos partes:
□ Vector de interrupciones del sistema. Para ello el sistema asigna a cada proceso un rango de direcciones
para almacenar lo que le haga falta. De este modo no puede tener acceso a una dirección que se
encuentre fuera de dicho rango.
□ Memoria compartida entre procesos. Implantación por parte del sistema de rutinas capaces de llevar el
control de los procesos y de su acceso a memoria: semáforos, mensajes…
Para solucionarlo hay que tener en cuenta que:
à Dos procesos no deben encontrarse al mismo tiempo dentro de sus secciones críticas (exclusión
mutua).
à No se debe hacer hipótesis sobre la velocidad de la CPU.
à Ninguno de los procesos que estén en ejecución fuera de su sección crítica puede bloquear a otros
procesos.
à Ningún proceso debe esperar eternamente para entrar a su sección crítica.
Otro factor clave cuando hablamos de sistemas operativos se trata del sistema de archivos. Éste es el encargado
de almacenar en disco la información necesaria. La unidad esencial de este sistema es el archivo.
A su vez los archivos se agrupan en directorios, para una fácil localización dentro del disco. Los archivos se
pueden implementar de varias formas, algunas de ellas se explican a continuación:
□ Asignación adyacente. Almacena cada archivo como un bloque adyacente de datos en el disco.
Sus principales ventajas son:
à Fácil implementación.
à Rendimiento excelente.
Y sus desventajas:
à No es realizable al menos que se conozca el tamaño máximo del archivo en su creación.

à Fragmentación del disco. Se desperdicia mucho espacio.
□ Asignación en forma de lista ligada. Mantiene para cada archivo una lista ligada de bloques en disco; en
el que la primera palabra de cada bloque se utiliza como apuntador al siguiente.
Las ventajas de este método son:
à Se aprovecha todo el espacio de disco.

à Basta que la entrada del directorio guarde sólo la dirección del primer bloque.
Pero a su vez tiene algunas desventajas:
à Aunque la lectura secuencial es directa, el acceso aleatorio es muy lento.

à Se desperdicia espacio en almacenar los apuntadores.
□ Asignación mediante una lista ligada y un índice. Las dos desventajas de la asignación mediante una lista
ligada se pueden eliminar si se toma la palabra del apuntador de cada bloque del disco y se coloca en
una tabla o índice de memoria. La principal desventaja de este método es que la tabla con los índices
tiene que permanecer continuamente en memoria.
□ Nodos-i. Consiste en repartir la información del archivo en pequeñas tablas de direcciones a datos. En
caso que no sea suficiente, una de sus celdas apunta a otra tabla (nodo-i) que a su vez contiene
direcciones a datos, y así sucesivamente hasta conseguir el espacio necesario.
La ampliación de los ordenadores mediante tarjetas u otros dispositivos se ha visto favorecida con la aparición de
la tecnología Plug & Play, capaz de liberar al usuario de la compleja configuración de estos dispositivos. La
tecnología PnP está formada por cuatro componentes principales: BIOS Plug and Play, datos de configuración de
sistema ampliado ESCD, administrador de configuración CM, utilidad de configuración ISA ICU.
SISTEMAS WINDOWS
Visión General
à Niveles de producto: Professional, Server, Advanced Server y Datacenter Server
à Registro (registry): base de datos central que guarda la información necesaria para arrancar y
configurar el sistema y adaptarlo al usuario actual.
Gestión de los Procesos
à Sistema multitarea de 32 bits, con procesos protegidos de manera individual. Cada proceso tiene un
espacio de direcciones virtuales de 32 bits, paginado por demanda.
à El sistema operativo se ejecuta en modo kernel, mientras que los procesos de usuario lo hacen en
modo usuario
à Planificación por prioridades (32 niveles) y apropiativo en su funcionamiento.
Gestión de la Memoria
à Cada proceso tiene su propio espacio de direcciones virtual de 32 bit (4 GB de espacio de
direcciones).
à Algoritmo de paginación doble, por demanda y anticipada, leyendo un número variable de páginas
según que el fallo se produzca en una página de código (lee más) o de datos
Sistema de Archivos
à Soporta: FAT-16, FAT-32 y NTFS (NT File System)
Seguridad
à El administrador de seguridad satisface los requisitos C-2 del Libro Naranja del Departamento de
Defensa de Estados Unidos.
Administración del sistema
à Iniciativa de Administración Nula para Windows que intenta reducir el TCO
à IntelliMirror busca garantizar la disponibilidad de la información de los usuarios frente a posibles
fallos de las redes y servidores
à Otras Características incorporadas en Windows 2000 para la administración del sistema son: WMI
(Windows Management Instrumentation) y el WSH (Windows Scripting Host) que forman parte de la
infraestructura de administración de Microsoft.
SISTEMAS UNIX
Unix es un sistema operativo totalmente aceptado en el mundo de la informatica y sobre todo como servidor de
red, debido a sus características inherentes. Existen sobre todo dos versiones de UNIX principales
□ UNIX System V de AT&T

□ BSD de la Universidad de Berkeley
Como características principales a destacar resaltan:
□ El sistema está escrito en un lenguaje de alto nivel, haciéndolo fácil de leer, comprender, cambiar, y
mover a otras máquinas.
□ Posee una simple interfase de usuario con el poder de dar los servicios que los usuarios quieren.
□ Provee de primitivas que permiten construir programas complejos a través de programas simples.
□ Usa un sistema de archivos jerárquico que permite un mantenimiento fácil y una implementación eficiente.
□ Usa un formato consistente para los archivos, el flujo de bytes, haciendo a los programas de aplicación
más fáciles de escribir.
□ Provee una simple y consistente interfase a los dispositivos periféricos.
□ Es un sistema multiusuario y multitarea; cada usuario puede ejecutar varios procesos simultáneamente.
□ Oculta la arquitectura de la máquina al usuario, haciendo fácil de escribir programas que se ejecutan en
diferentes implementaciones hardware
En cuanto a los interpretes de comandos en modo texto destacan sobre todo 4:
□ Bourne Shell (sh); es el que distribuye AT&T con el UNIX.

□ C Shell (csh), desarrollado en la Universidad de Berkeley basado en el lenguaje C.
□ Korn Shell (ksh), interface escrita por David Korn.
□ BASH (Bourne Again Shelll) que unifica las características del csh y ksh junto con la versión inicial del
Bourne Shell (sh)
En todos los shells se pueden realizar las siguientes tareas:
□ Los modos de invocar una orden son:

à Teclear el comando y pulsar enter
à ampersand, &, para ejecutar una orden en el modo subordinado.
à ; para invocar varias ordenes desde una unica linea.
□ Utilizar comodines para los nombres de archivos (*, ? , [ ])
□ Cambiar la salida y la entrada estándar con los operadores de redirección ( >,>>,< y | )
El shell dispone de un mecanismo para definir variables que se utilizan para almacenar información utilizada por
los programas del sistema o por el usuario. Algunas de esas variables son.
□ HOME contiene el nombre de camino absoluto del directorio de recepción.

□ PATH lista, en orden, los directorios en los que el shell busca para encontrar el programa a ejecutar
cuando se teclea una orden.
□ PSl y PS2 definen los signos de sus peticiones de orden primaria y secundaria, respectivamente.
□ LOGNAME contiene su nombre de presentación. Lo fija automáticamente el sistema.
□ SHELL contiene el nombre de su programa de shell.
□ TERM contiene información sobre el tipo de terminal que se está utilizando. Esta información es
necesaria para permitir a los programas que comparen su salida con las capacidades del terminal y para
interpretar su entrada correctamente.
El sistema de archivos de UNIX permite organizar y gestionar la información contenida en el equipo. Aunque
muchas de las características del sistema de archivos se inventaron.
Las características del sistema de archivos son:
□ Para cada archivo se definen 3 tipos de acceso diferentes: lectura, escritura y ejecución.
□ UNIX no impone ninguna restricción a la organización interna de un fichero.
□ UNIX ofrece herramientas para realizar copias de seguridad de ficheros
□ Tratar a los dispositivos de entrada salida como si fuesen archivos.
□ Tiene una estructura jerárquica en forma de árbol invertido.
□ Realizar un tratamiento consistente de los datos de los archivos.
En UNIX existen cinco tipos de archivos:
□ Archivos ordinarios: Almacenar información en dispositivos de almacenamiento secundario

□ Directorios: archivo que contiene información sobre las localizaciones y atributos de otros archivos
□ Vinculo: forma de que un archivo tenga dos nombres distintos
à Vinculo simbolico: Equivale al acceso directo en windows
□ Archivos de dispositivos: archivo especial que representa un dispositivo fisico
à Archivos de dispositivo en modo carácter. Transfieren datos carácter a carácter.
à Archivos de dispositivo en modo bloque: Transfieren datos en bloques.
□ Tuberías (pipes) con nombre: Mecanismo de comunicación para transferencia de datos entre 2 procesos
En la estructura del sistema de archivos de un UNIX versión System V se distinguen cuatro partes:
□ El bloque de arranque: contiene el programa busca el sistema operativo y lo carga en memoria para
iniciar la máquina.
□ El super bloque. Muestra el estado de un sistema de archivos
□ La lista de nodos índice: tiene una entrada (denominada inode) por cada archivo del sistema de archivos
donde se guarda la descripción del mismo.
□ Los bloques de datos. Almacenan el contenido de los archivos referenciados por un inode.
La interfaz gráfica de UNIX es el sistema X-Window basado en el modelo cliente servidor. Conceptos importantes
□ El servidor X gestiona todo el acceso al hardware, encargándose de controlar los dispositivos que se
utilizarán en la interfaz grafica: ratón, teclado y pantalla. El servidor X recibe los eventos generados por
este hardware y también es el encargado de mostrar los gráficos e iconos en el monitor.
□ El software cliente programas que utilizan el servidor X para interactuar con los usuarios
□ Protocolo X: Dicta las normas a seguir para lograr una comunicación cliente servidor.
□ Gestor de ventanas: Ofrece una apariencia común a todas las ventanas.

Tema 05. Sistemas Operativos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 05. Sistemas Operativos

Cargado por

Copyright:

Formatos disponibles

T05 - SISTEMAS OPERATIVOS.

1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS.................................................................................................. 3

1.1. CONCEPTO DE SISTEMA OPERATIVO

Para poder ejecutar un programa, éste debe ser consciente

Desde este punto de vista es dónde nace el concepto de Sistema

Ahora ya nos encontramos en situación de dar una definición:

1.2. EVOLUCIÓN DE LOS SISTEMAS OPERATIVOS

Si se aprovechan los tiempos de inactividad de la CPU en la ejecución de otros programas simultáneamente, se

2. COMPONENTES DEL SISTEMA

2.1. ADMINISTRACIÓN DE PROCESOS

□ Crear y eliminar procesos de usuario y procesos del sistema.

2.2. ADMINISTRACIÓN DE LA MEMORIA PRINCIPAL

2.3. ADMINISTRACIÓN DE ARCHIVOS

□ Crear y eliminar archivos.

El subsistema de E/S consta de:

□ Un componente de administración de memoria que incluye manejo de buffers, asignación de caché y

2.5. ADMINISTRACIÓN DEL ALMACENAMIENTO SECUNDARIO

□ Administración del espacio libre.

2.6. OPERACIÓN EN RED

Un sistema distribuido es un conjunto de procesadores que no comparten memoria, dispositivos periféricos ni un

2.8. SISTEMA DE INTÉRPRETE DE COMANDOS

3.1. CONCEPTO DE PROCESO

3.2. BLOQUE DE CONTROL DEL PROCESO

Cada proceso se representa en el sistema operativo mediante un bloque de Estado

3.3. ESTADOS DE PROCESO

Los posibles estados de un proceso son:

□ En ejecución: utiliza la CPU en el instante dado.

Son posibles cuatro transiciones entre estos estados:

3.4. COMUNICACIÓN ENTRE PROCESOS

Un enlace de comunicación en este esquema tiene las siguientes propiedades:

3.4.2. COMUNICACIÓN INDIRECTA

□ Send (A, mensaje). Enviar un mensaje al buzón A.

Entre sus principales propiedades cabe destacar:

3.4.3. USO DE BUFFERS

4.1. PROTECCIÓN DEL SISTEMA OPERATIVO MEDIANTE HARDWARE

Trabajo 1 Registro base

Trabajo 2 Registro límite

Base Base + límite

Interrupción al monitor del sistema Memoria

4.2. PROTECCIÓN ENTRE PROCESOS CONCURRENTES

4.2.1. CONDICIONES DE COMPETENCIA ENTRE PROCESOS

4.2.2. SECCIONES CRÍTICAS

4.2.3.1. DESACTIVACIÓN DE INTERRUPCIONES

4.2.3.2. VARIABLES DE CERRADURA

4.2.3.3. SOLUCIÓN DE PETERSON

El algoritmo que propuso Dekker era el siguiente:

#define N 2 /* Número de procesos. */

void enter_region (int process) /* Proceso que entra (0 o 1) */

other = 1 – process; /* El opuesto del proceso */

void leave_region (int process) /* Proceso quién sale (0 o 1) */

□ Debe ser posible almacenar una cantidad muy grande de información.

Secuencia de Bytes Secuencia de registros

□ Protección. Quién debe tener acceso y de qué forma.

□ Ruta de acceso absoluta. Consta de la ruta de acceso desde el directorio raíz.

5.3.1. ASIGNACIÓN ADYACENTE

Sus principales ventajas son:

Pero como en todo, también tiene sus desventajas:

5.3.2. ASIGNACIÓN EN FORMA DE LISTA LIGADA

Las ventajas de este método son:

□ Se aprovecha todo el espacio de disco.

Pero a su vez tiene algunas desventajas:

□ Aunque la lectura secuencial es directa, el acceso aleatorio es en extremo lento.

6. TECNOLOGÍA PLUG & PLAY (PnP)

6.1. FUNCIONAMIENTO DE PLUG & PLAY