SISTEMAS OPERATIVOS CON MINIX (2)

el sistema operativo como una extension del computador

Como se mencionó anteriormente, la arquitectura (conjunto de instrucciones, organización de la memoria, E/S y estructura de bus) de la mayoría de las computadoras a nivel de lenguaje máquina es primitiva y difícil de programar, especialmente para la entrada/salida. Para ver este punto más concretamente, veamos brevemente qué tan flexible es la operativa de E/S del disco que se realiza utilizando los chips de controlador compatible con NEC PD765 utilizado en muchas computadoras personales. El PD765 tiene 16 comandos, cada uno especificado cargando entre 1 y 9 bytes en un registro del dispositivo. Estos comandos son para leer y escribir datos, mover el brazo del disco,
y formatear pistas, así como inicializar, detectar, restablecer y recalibrar el controlador
y las unidades. Los comandos más básicos son de lectura y escritura, cada uno de los cuales requiere 13 parámetros, empaquetados en 9 bytes. Estos parámetros especifican elementos tales como la dirección del bloque de disco que se leerá, el número de sectores por pista, el modo de grabación utilizado en el medio físico, la intersección de espaciado, y qué hacer con una marca de dirección de datos eliminados. Si no entiendes estos tecnicismos, no se preocupe; ese es precisamente el punto, es bastante complejo. Cuando la operación es completada, el chip controlador devuelve 23 campos de estado y error empaquetados en 7 bytes. Como si esto no fuera suficiente, el programador de disquetes también debe estar constantemente consciente de si el motor está encendido o apagado. Si el motor está apagado, debe encenderse (con un retraso de arranque prolongado) antes de que los datos se puede leer o escribir. Sin embargo, el motor no se puede dejar encendido demasiado tiempo o el disquete se desgastará. Por tanto, el programador se ve obligado a lidiar con la compensación entre retrasos prolongados en el inicio y desgastando los disquetes (y perdiendo los datos en ellos). Sin entrar en detalles reales, debería quedar claro que el programador promedio probablemente no quiera involucrarse demasiado íntimamente con la programación de disquetes (o discos duros, que es igual de compleja y bastante diferente). En cambio, lo que el programador quiere es un sencillo nivel de abstracción para tratar. En el caso de los discos, una abstracción típica sería que el disco
contenga una colección de archivos con nombre. Cada archivo se puede abrir para leer o escribir, luego leer o escrito, y finalmente cerrarlo. Detalles como si la grabación debe usar o no frecuencia modulada y cuál es el estado actual del motor no debe aparecer en la API de abstracción presentada al usuario.

El programa que oculta la verdad sobre el hardware al programador y presenta una operativa mas simple de archivos con nombre que se pueden leer y escribir es, por supuesto, el sistema operativo. Ya que el sistema operativo oculta al programador del hardware del disco y presenta una simple interfaz orientada a archivos, también oculta una gran cantidad de asuntos desagradables relacionados con interrupciones, temporizadores, administración de memoria y otras características de bajo nivel. En cada caso, la abstracción ofrecida por el sistema operativo es más simple y fácil de usar que el que ofrece el hardware subyacente.
En esta vista, la función del sistema operativo es presentar al usuario el equivalente de un
máquina extendida o máquina virtual que es más fácil de programar que el hardware subyacente. Cómo el sistema operativo logra este objetivo es una larga historia, que estudiaremos en detalle a lo largo de estos posts. Para resumirlo en pocas palabras, el sistema operativo proporciona una variedad de servicios que los programas pueden obtener mediante instrucciones especiales denominadas llamadas al sistema. Examinaremos algunas de estas llamadas al sistema más comunes más adelante en este post.

el sistema operativo como gestor de recursos

El concepto de sistema operativo que proporciona principalmente a sus usuarios una interfaz conveniente es una vista de arriba hacia abajo. Una vista alternativa, de abajo hacia arriba, sostiene que el sistema operativo está ahí para gestionar todas las piezas de un sistema complejo. Las computadoras modernas constan de procesadores, memorias, temporizadores, discos, ratones, interfaces de red, impresoras y una amplia variedad de dispositivos. En la vista alternativa, el trabajo del sistema operativo es proporcionar un sistema ordenado y controlado de asignación de procesadores, memorias y dispositivos de E/S entre los diversos programas que compiten para ellos.
Imagínese lo que sucedería si tres programas que se ejecutan en alguna computadora intentaran imprimir su salida simultáneamente en la misma impresora. Las primeras líneas de impresión pueden ser del programa 1, las siguientes del programa 2, luego algunos del programa 3, y así sucesivamente. El resultado sera un caos. El sistema operativo puede poner orden en el caos potencial almacenando en búfer toda la salida
destinada a la impresora en el disco. Cuando finaliza un programa, el sistema operativo puede copiar su salida del archivo de disco donde se ha almacenado en la impresora, mientras que al mismo tiempo el otro programa puede continuar generando más salida, ajeno al hecho de que la salida realmente no va a la impresora (todavía). Cuando una computadora (o red) tiene varios usuarios, la necesidad de administrar y proteger la memoria, los dispositivos de E/S y otros recursos es incluso mayor, ya que los usuarios podrian interferir entre sí. Además, los usuarios a menudo necesitan compartir no solo el hardware, sino información (archivos, bases de datos, etc). En resumen, esta visión del sistema operativo sostiene que su tarea principal es realizar un seguimiento de quién está utilizando qué recurso, otorgar solicitudes de recursos, tener en cuenta el uso y mediar solicitudes en conflicto de diferentes programas y usuarios. La gestión de recursos incluye multiplexar (compartir) recursos de dos formas: en el tiempo y en espacio. Cuando un recurso se multiplexa en el tiempo, diferentes programas o usuarios se turnan para usarlo. Primero uno de ellos llega a usar el recurso, luego otro, y así sucesivamente. Por ejemplo, con solo una CPU y varios programas que quieren ejecutarse en él, el sistema operativo primero asigna la CPU a un programa,dspues de que se haya ejecutado el tiempo suficiente, otro puede usar la CPU, luego otro, y luego, finalmente, el primero de nuevo. Determinar cómo se multiplexa el recurso en el tiempo siguiente y durante cuánto tiempo es la tarea del sistema operativo. Otro ejemplo de multiplexación de tiempo es compartir la impresora. Cuando se ponen en cola varios trabajos de impresión para imprimir en una sola impresora, se debe tomar una decisión sobre cuál se imprimirá a continuación. El otro tipo de multiplexación es la multiplexación espacial. En lugar de que los clientes se turnen, cada uno obtiene parte del recurso. Por ejemplo, la memoria principal normalmente se divide entre varios programas en ejecución, por lo que cada uno puede ser residente al mismo tiempo (por ejemplo, para tomar turnos usando la CPU). Suponiendo que haya suficiente memoria para almacenar varios programas, es más
eficiente mantener varios programas en la memoria a la vez en lugar de dar a cada uno de ellos toda la memoria, para despues quitar de la memoria este programa y cargar otro, especialmente si solo necesita una pequeña fracción del total. Por supuesto, esto plantea problemas de equidad, protección, etc., y depende del sistema operativo resolverlos. Otro recurso es el espacio multiplexado es el disco (duro). En muchos sistemas, un solo disco puede contener archivos de muchos usuarios al mismo tiempo. Asignar espacio en disco y realizar un seguimiento de quién usa qué bloques de disco es una tarea típica de gestión de recursos del sistema operativo.

historia de los sistemas operativos

Los sistemas operativos han ido evolucionando a lo largo de los años. En las siguientes secciones, miramos brevemente algunos de los aspectos más destacados. Dado que históricamente los sistemas operativos han estado estrechamente vinculados a la arquitectura de las computadoras en las que se ejecutan, veremos generaciones sucesivas de computadoras para ver cómo eran sus sistemas operativos.
La primera computadora digital verdadera fue diseñada por el matemático inglés Charles Babbage (17921871). Aunque Babbage pasó la mayor parte de su vida y su fortuna tratando de construir su “maquina analítica“, nunca la hizo funcionar correctamente porque era puramente mecánico, y la tecnología de su día no pudo producir las ruedas y engranajes requeridos con la alta precisión que era necesaria. No hace falta decir que la maquina analitica no tenía un sistema operativo. Como una parte interesante, Babbage se dio cuenta de que necesitaría software para su maquina analitica, por lo que contrató a una joven llamada Ada Lovelace, que era la hija del famoso poeta británico Lord Byron, como la primera programadora del mundo.

LA PRIMERA GENERACION. TUBOS DE VACIO Y PANELES DE CONEXION

Después de los infructuosos esfuerzos de Babbage, se avanzó poco en la construcción de computadoras digitales hasta la Segunda Guerra Mundial. A mediados de la década de 1940, Howard Aiken de la Universidad de Harvard, John von Neumann en el Instituto de Estudios Avanzados de Princeton, J. Presper Eckert y John Mauchley en la Universidad de Pensilvania y Konrad Zuse en Alemania, entre otros, lograron la construcción de maquinas de cálculo. Las primeras usaban relés mecánicos pero eran muy lentos, con tiempos de ciclo medidos en segundos. Posteriormente, los relés fueron reemplazados por tubos de vacío. Estas maquinas eran enormes, llenando habitaciones enteras con decenas de miles de tubos de vacío, pero todavía eran millones de veces más lentas que las computadoras personales más baratas disponibles en la actualidad.
En estos primeros días, un solo grupo de personas diseñó, construyó, programó, operó y
mantuvo cada máquina. Toda la programación se realizó en lenguaje de máquina, a menudo por de tableros de conexiones para controlar las funciones básicas de la máquina. Los lenguajes de programación eran desconocidos (incluso el lenguaje ensamblador era desconocido). Los sistemas operativos eran desconocidos. El modo de operación habitual era que el programador se registrara en un bloque de tiempo en la hoja de registro en la pared, luego bajaba a la sala de máquinas, insertaba su tablero en la computadora, y pasaba las próximas horas esperando que ninguno de los 20,000 tubos de vacío se quemara durante la ejecucion. Prácticamente todos los problemas eran calculos numéricos sencillos, como rectificar tablas de senos, cosenos y logaritmos. A principios de la década de 1950, la rutina había mejorado un poco con la introducción de tarjetas perforadas. Ahora era posible escribir programas en tarjetas y leerlas en lugar de utilizar placas de conexión pero el procedimiento era el mismo.

LA SEGUNDA GENERACION. TRANSISTORES Y SISTEMAS POR LOTES

La introducción del transistor a mediados de la década de 1950 cambió radicalmente el panorama. Los ordenadores se volvieron lo suficientemente confiables como para poder ser fabricados y vendidos a clientes que pagan con la expectativa de que continuarían funcionando el tiempo suficiente para realizar un trabajo útil. Por primera vez, hubo una clara separación entre diseñadores, constructores, operadores, programadores y personal de mantenimiento.
Estas máquinas, ahora llamadas mainframes, estaban encerradas en habitaciones con aire acondicionado especial, con personal de operadores profesionales especialmente capacitados para ejecutarlas. Solo las grandes corporaciones o las principales agencias gubernamentales o universidades podrían pagar sus servicios a precios multimillonarios. Al querer ejecutar un trabajo (es decir, un programa o conjunto de programas), un programador primero escribiría el programa en papel (en FORTRAN o posiblemente incluso en lenguaje ensamblador), y luego perforaba las tarjetas. Luego llevaba el lote de tarjetas a la sala de entrada y la entregaba a uno de los operadores y esperaba a que estuviera lista. Cuando la computadora terminaba cualquier trabajo que estaba ejecutando, un operador examinaba la impresora, recogía las tarjeta de salida y las llevaba a la sala de salida, de modo que el programador podría recogerlas más tarde. Luego tomaría una de las tarjetas que habían traído de sala de entrada y las leeria. Si se necesitaba el compilador FORTRAN, el operador tendría que obtenerlo de un archivador y leerlo. Se perdia mucho tiempo de computadora mientras los operadores caminaban
alrededor de la sala de máquinas. Dado el alto costo del equipo, no es sorprendente que la gente buscara rápidamente formas de reducir el tiempo perdido. La solución generalmente adoptada fue el sistema por lotes. La idea detrás era recoger una bandeja llena de trabajos en la sala de entrada y luego leerlos en una cinta magnética utilizando una computadora pequeña (relativamente) económica, como la IBM 1401, que era muy buena leyendo tarjetas, copiando cintas e imprimiendo resultados, pero nada buena en cálculos numéricos. Otras máquinas mucho más caras, como la IBM 7094, se utilizaron para la informática real.

Ciclo de trabajo del sistema batch

Después de aproximadamente una hora de recolectar un lote de trabajos, la cinta se rebobina y se lleva a la sala de máquinas, donde se monta en una unidad de cinta. El operador luego carga un programa especial (el antepasado del sistema operativo actual), que lee el primer trabajo de la cinta y lo ejecuta. La salida se escribe en una segunda cinta, en lugar de imprimirse. Una vez terminado cada trabajo, el sistema operativo lee automáticamente el siguiente trabajo de la cinta y comienza a ejecutarlo. Cuando el computador ejecuta todo el lote, el operador quita las cintas de entrada y salida, y las reemplaza con el siguiente lote, y lleva la cinta de salida a una 1401 para imprimir fuera de línea (es decir, no conectado a la computadora principal).
La estructura de un trabajo de entrada típico se muestra en la figura de abajo. Comienza con una tarjeta $JOB, especificando el tiempo de ejecución máximo en minutos, el número de cuenta que se cargará y el nombre del programador. Luego sigue con una tarjeta $ FORTRAN, que le dice al sistema operativo que cargara el compilador FORTRAN de la cinta del sistema. Sigue el programa a compilar, y luego una tarjeta $LOAD, qie ordena al sistema operativo que cargue el programa objeto recién compilado. (Los programas compilados a menudo se escribían en cintas de memoria virtual y tenían que cargarse explícitamente). Luego viene la tarjeta $RUN, para decirle al sistema operativo que ejecute el programa con los datos siguientes. Finalmente, la tarjeta $END marca el final del trabajo. Estas tarjetas de control primitivas fueron las precursoras de los lenguajes de control de los trabajos modernos y de los intérpretes de comandos.

Estructura de un trabajo por lotes

Las computadoras grandes de segunda generación se utilizaron principalmente para cálculos científicos y de ingeniería, como resolver las ecuaciones diferenciales parciales que ocurren a menudo en física e ingeniería. Estos fueron programados en gran parte en FORTRAN y lenguaje ensamblador. Los sistemas operativos típicos eran FMS (el Fortran Monitor System) e IBSYS, el sistema operativo de IBM para el 7094.

LA TERCERA GENERACION. ICs Y MULTIPROGRAMACION

A principios de la década de 1960, la mayoría de los fabricantes de computadoras tenían dos líneas de productos distintos y totalmente incompatibles Por un lado estaban las computadoras científicas a gran escala orientadas a palabras como el 7094, que se utilizaba para cálculos numéricos en ciencia e ingeniería. Por otro lado, estaban las computadoras comerciales orientadas a caracteres, como la 1401, que fueron ampliamente utilizados para la clasificación e impresión de cintas por bancos y compañías de seguros. Desarrollar, mantener y comercializar dos líneas de productos completamente diferentes fue una tarea costosa para los fabricantes de computadoras. Además, muchos nuevos clientes de computadoras inicialmente necesitaba una máquina pequeña pero luego las necesidades obligaban a querer una máquina más grande que tuviera la misma arquitectura para que se pudieran ejecutar todos los programas antiguos, pero más rápidamente. IBM intentó resolver ambos problemas de un solo golpe al presentar el System / 360. El 360 era una serie de máquinas compatibles con software que iban desde el 1401 hasta las mucho más potentes que el 7094. Las máquinas solo se diferenciaban en precio y rendimiento (memoria maxima, velocidad del procesador, número de dispositivos de E/S permitidos, etc.) Dado que todas las maquinas tenían la misma arquitectura y el mismo conjunto de instrucciones, los programas escritos para una máquina podían ejecutarse en todos las demás, al menos en teoría. Además, el 360 fue diseñado para manejar tanto computacion científica (es decir, numérico) como computación comercial. Así, una sola familia de máquinas podría satisfacer las necesidades de todos los clientes. En los años siguientes, IBM presento sucesores compatibles con la línea 360, utilizando tecnología más moderna, conocida como las series 370, 4300, 3080, 3090 y Z. El 360 fue la primera línea de computadoras importante en utilizar circuitos integrados (CI) (a pequeña escala), por lo que proporcionaron una importante ventaja de precio y rendimiento sobre las máquinas de segunda generación, que se construyeron a partir de transistores individuales. Fue un éxito inmediato, y la idea de una familia de computadoras compatibles pronto fueron adoptadas por todos los demás fabricantes importantes. Los descendientes de estas máquinas todavía se utilizan en los centros informáticos en la actualidad. Hoy en día se utilizan a menudo para administrar enormes bases de datos (por ejemplo, para sistemas de reserva de aerolíneas) o como servidores para sitios web que deben procesar miles de solicitudes por segundo.
La mayor fortaleza de la idea de “una familia” fue simultáneamente su mayor debilidad. La intención era que todo el software, incluido el sistema operativo, OS/360, tuviera que funcionar en todos modelos. Tenía que ejecutarse en sistemas pequeños, que a menudo simplemente reemplazaban a los 1401 para copiar tarjetas en cinta, y en sistemas muy grandes, que a menudo reemplazan a los 7094 para hacer predicciones meteorológicas y
otra informática pesada. Tenía que ser bueno en sistemas con pocos periféricos y en sistemas con muchos periféricos. Tenía que funcionar en entornos comerciales y en entornos científicos. Sobre todo, tenía que ser eficaz para todos estos diferentes usos.
No había forma de que IBM (o cualquier otra persona) pudiera escribir una pieza de software para cumplir con todos esos requisitos contradictorios. El resultado fue una operación enorme y un sistema extraordinariamente complejo, probablemente dos o tres órdenes de magnitud más grande que FMS. Consistía en millones de líneas de lenguaje ensamblador escrito por miles de programadores, y contenía miles y miles de errores, que necesitaban un flujo continuo de nuevos lanzamientos en un intento de corregirlos. Cada nueva versión corrigió algunos errores e introdujo otros nuevos, por lo que la cantidad de errores probablemente se mantuvo constante en el tiempo.
Uno de los diseñadores de OS/360, Fred Brooks, posteriormente escribió un libro ingenioso e incisivo describiendo sus experiencias con OS/360 (Brooks, 1995). Si bien sería imposible
resumir el libro aquí, basta decir que la portada muestra una manada de bestias prehistóricas pegadas en un pozo de alquitrán. La portada de Silberschatz et al. (2004) hace un punto similar sobre los sistemas operativos siendo dinosaurios.
Los sistemas producidos por otros fabricantes de computadoras realmente satisfacían a la mayoría de sus clientes de forma razonablemente bien. También popularizaron varias técnicas clave ausentes en ls sistemas operativos de segunda generación. Probablemente el más importante de ellos fue la multiprogramación. En el 7094, cuando el trabajo actual se detenia para esperar a que se completara una cinta u otra operación de E/S, la CPU
simplemente permanecia inactiva hasta que finalizaba la operacion de E/S. Con cálculos científicos fuertemente ligados a la CPU, la E/S es poco frecuente, por lo que este tiempo perdido no es significativo. Con el procesamiento de datos comerciales, la E/S espera el tiempo que a menudo puede ser el 80 o el 90 por ciento del tiempo total, por lo que se tuvo que hacer algo para evitar tener la CPU (cara) estar inactiva tanto tiempo. La solución que evolucionó fue dividir la memoria en varias partes, con un trabajo diferente en cada
partición, como se muestra en la Figura de abajo. Mientras un trabajo estaba esperando que se completara la E/S, otro trabajo podría estar usando la CPU. Si se pudieran tener suficientes trabajos en la memoria principal a la vez, la CPU podría mantenerse
ocupado casi el 100 por ciento de tiempo. Tener varios trabajos de forma segura en la memoria a la vez requiere hardware especial para proteger cada trabajo contra el espionaje y las travesuras de los demás, y el 360 y otros sistemas de tercera generación fueron equipados con este hardware.

Sistema multiprogramacion con tres trabajos en memoria

Otra característica importante presente en los sistemas operativos de tercera generación fue la capacidad de leer trabajos de las tarjetas al disco tan pronto como se llevaban a la sala de informática. Entonces, siempre que un trabajo en ejecución terminaba, el sistema operativo podría cargar un nuevo trabajo desde el disco en la ahora vacía partición y ejecutarlo. Esta técnica se llama spooling y también se utiliza para la salida. Con el spooling, las 1401 ya no eran necesarias y gran parte del transporte de cintas desapareció.
Aunque los sistemas operativos de tercera generación eran adecuados para grandes cálculos científicos y ejecuciones masivas de procesamiento de datos comerciales, seguían siendo básicamente sistemas por lotes. Muchos programadores suspiraban por los días de la primera generación cuando tenían la máquina para ellos solos unas pocas horas, para que pudieran depurar sus programas rápidamente. Con sistemas de tercera generación, el tiempo entre el envío de un trabajo y la devolución del resultado eran a menudo horas, por lo que un solo error podría hacer que una compilación fallara y que el programador desperdiciara medio día. Este deseo de un tiempo de respuesta rápido allanó el camino para el tiempo compartido, una variante de multiprogramación, en la que cada usuario dispone de un terminal online. En un sistema de tiempo compartido, si 20 usuarios están conectados y 17 de ellos están pensando, hablando o tomando café, la CPU puede ser asignada a su vez a los tres puestos de trabajo que desean servicio. Dado que las personas que depuran programas emiten comandos cortos en lugar de comandos largos (por ejemplo, ordenar un archivo de millones de registros), la computadora puede proporcionar un servicio rápido e interactivo a varios usuarios y quizás también trabaje en grandes lotes de trabajo en segundo plano cuando la CPU está inactiva. El primero de los sistemas de tiempo compartido serio, CTSS (Compatible Time Sharing System), fue desarrollado en M.I.T. en un 7094 especialmente modificado (Corbató et al., 1962). Sin embargo, el tiempo compartido no se convirtió realmente popular hasta la tecnica de la proteccion de hardware que se convirtio en standar durante la tercera generacion.

Después del éxito del sistema CTSS, MIT, Bell Labs y General Electric (entonces un importante fabricante de computadoras) decidió embarcarse en el desarrollo de una “utilidad informática”, una máquina que admitiría cientos de usuarios de tiempo compartido simultáneos. Su modelo fue el Sistema de distribución de electricidad. Los diseñadores de MULTICS (Servicio de Informática e Información MULTiplexada), imaginaron una máquina enorme proporcionando potencia informática para todos el área de Boston. MULTICS fue un éxito desigual. Fue diseñado para admitir cientos de usuarios en una sola máquina ligeramente más potente que una PC basada en Intel 80386, aunque tenía mucha más capacidad de E/S. Esto no es tan loco como parece, ya que la gente sabía cómo escribir programas pequeños y eficientes en esos días, una habilidad que posteriormente se ha perdido. Hubo muchas razones por las que MULTICS
no se apoderó del mundo, no menos importante es que fue escrito en PL/I, y el compilador PL/I legaba años tarde y apenas funcionaba cuando finalmente llegó. Además, MULTICS fue enormemente ambicioso para su época, muy parecido al motor analítico de Charles Babbage en el siglo XIX. MULTICS introdujo muchas ideas seminales en la literatura informática, pero convertirlas en un producto serio y con éxito comercial fue mucho más difícil de lo que nadie esperaba. Bell Labs se fue del proyecto, y General Electric abandonó el negocio de las computadoras por completo. Sin embargo, M.I.T. persistió y finalmente consiguió que MULTICS funcionara. Finalmente fue vendido como producto comercial por
la compañía que compró el negocio de computadoras de GE (Honeywell) y la instaló alrededor de 80 empresas y universidades de todo el mundo. Si bien su número era pequeño, los usuarios de MULTICS fueron ferozmente leales como General Motors, Ford y la Agencia de Seguridad Nacional de EE. UU., Por ejemplo, solo cerraron sus sistemas MULTICS a finales de la década de 1990. El último MULTICS corriendo, en el Departamento de Defensa Nacional de Canada, cerro en octubre de 2000. A pesar de su falta de éxito, MULTICS tuvo una gran influencia en los sistemas operativos posteriores. Una gran cantidad de información existe al respecto (Corbató et al., 1972; Corbató y Vyssotsky, 1965; Daley y Dennis, 1968; Organick, 1972; y Saltzer, 1974). También tiene un sitio web activo,
http://www.multicians.org, con una gran cantidad de información sobre el sistema, sus diseñadores y su usuarios.

La frase “utilidad informática” ya no se escucha, pero la idea ha cobrado nueva vida en los últimos años. En su forma más simple, las PC o estaciones de trabajo (PC de gama alta) en una empresa o un aula se pueden conectar a través de una LAN (red de área local) a un servidor de archivos en el que todos los programas y datos se almacenan. Luego, un administrador tiene que instalar y proteger solo un conjunto de programas y datos, y puede reinstalar fácilmente el software local en una PC o estación de trabajo que funciona mal sin preocuparse por recuperar o preservar datos locales. En entornos más heterogéneos, una clase de software llamado middleware ha evolucionado para cerrar la brecha entre los usuarios locales y los archivos, programas y bases de datos que se utilizan en servidores remotos. El middleware hace que las computadoras en red parezcan PCs locales o estaciones de trabajo de usuarios individuales y presenta una interfaz de usuario consistente. Puede haber una amplia variedad de servidores, PC y estaciones de trabajo diferentes en uso. La World Wide Web es un ejemplo. Un navegador web presenta documentos a un usuario de manera uniforme y un documento como el que se ve en el navegador de un usuario puede consistir en texto de un servidor y gráficos de otro servidor, presentados en un formato determinado por una hoja de estilo en otro servidor. Las empresas y las universidades suelen utilizar una interfaz web para acceder a las bases de datos y ejecutar programas en una computadora. En otro edificio o incluso en otra ciudad, el middleware puede ser un sistema operativo distribuido, pero en realidad no es un sistema operativo en absoluto, y está fuera del alcance de estos posts. Para obtener más información sobre sistemas distribuidos, consulte Tanenbaum y Van Steen (2002).
Otro acontecimiento importante durante la tercera generación fue el fenomenal crecimiento de las minicomputadoras, comenzando con la Digital Equipment Company (DEC) PDP-1 en 1961. La PDP-1 tenía sólo 4 K de palabras de 18 bits, pero a $ 120000 por máquina (menos del 5 por ciento del precio de una 7094), se vendió como rosquillas. Para ciertos tipos de trabajo no numérico, fue casi tan rápido como 7094 y dio a luz a una industria completamente nueva. Fue seguido rápidamente por una serie de otros PDP
(a diferencia de la familia de IBM, todos incompatibles) culminando en el PDP-11. Uno de los informáticos de Bell Labs que había trabajado en el proyecto MULTICS, Ken Thompson, posteriormente encontró una pequeña minicomputadora PDP-7 que nadie estaba usando y se dispuso a escribir una versión simplificada para un solo usuario de MULTICS. Este trabajo más tarde se convirtió en el sistema operativo UNIX, que se hizo popular en el mundo académico, agencias gubernamentales, y en muchas empresas. La historia de UNIX se ha contado en otros lugares (por ejemplo, Salus, 1994). Ya que el código fuente fue ampliamente disponible, varias organizaciones desarrollaron sus propias versiones (incompatibles), lo que llevó al caos. Se desarrollaron dos versiones principales, System V, de AT&T, y BSD, (Berkeley Software Distribution) de la Universidad de California en Berkeley. Estos también tenían variantes menores, ahora incluidos FreeBSD, OpenBSD y NetBSD. Para que sea posible escribir programas que puedan ejecutarse en cualquier sistema UNIX, IEEE desarrolló un estándar para UNIX, llamado POSIX, que la mayoría de las versiones de UNIX ahora es compatible. POSIX define una interfaz de llamada al sistema que cumple con todos los sistemas UNIX. De hecho, algunos otros sistemas operativos ahora también admiten la interfaz POSIX. La información necesaria para escribir software compatible con POSIX está disponible en libros (IEEE, 1990; Lewine,
1991) y en línea como la “Especificación UNIX única” del Open Group en http://www.unix.org. Más tarde, cuando nos referimos a UNIX, nos referimos a todos estos sistemas compatibles POSIX, a menos que se indique lo contrario. Si bien difieren internamente, todos admiten el estándar POSIX, por lo que para el programador son bastante similares.

LA CUARTA GENERACION. COMPUTADORAS PERSONALES

Con el desarrollo de circuitos LSI (integración a gran escala), que contienen miles de transistores en un centímetro cuadrado de silicio, la era de los microprocesadores personales despegó. En términos de arquitectura, las computadoras personales (inicialmente llamadas microcomputadoras) no eran tan diferentes de las minicomputadoras de la clase PDP-11, pero en términos de precio, ciertamente eran diferentes. La minicomputadora hizo posible a un departamento en una empresa o universidad tener su propia computadora. El microordenador hizo posible que un individuo tuviera su propia computadora. Había varias familias de microcomputadoras. Intel lanzó el 8080 el 1974, el primer microprocesador de 8 bits de propósito general. Varias empresas produjeron sistemas completos utilizando el 8080 (o el Zilog Z80 compatible) y el CP/M (Programa de control para microcomputadoras) El sistema operativo de una empresa llamada Digital Research fue ampliamente utilizado con estos años. Muchosde los programas de aplicación se escribieron para ejecutarse en CP/M, y dominó la informática personal durante unos 5 años. Motorola también produjo un microprocesador de 8 bits, el 6800. Un grupo de ingenieros de Motorola uso la tecnología MOS y fabrico la CPU 6502 después de que la empresa Motorola rechazara su propuesta de mejoras al 6800. El 6502 fue la CPU de varios de los primeros sistemas. Uno de estos, el Apple II, se convirtió en un importante competidor de los sistemas CP/M en los mercados doméstico y educativo. Pero el CP/M era tan popular que muchos propietarios de computadoras Apple II compraron el complemento de coprocesador Z-80 en tarjetas para ejecutar CP/M, ya que la CPU 6502 no era compatible con el CP/M. Las tarjetas CP/M fueron
vendidas por una pequeña empresa llamada Microsoft, que también tenía un nicho de mercado que suministraba interpretes BASIC utilizados por una serie de microcomputadoras que ejecutaban CP/M. La próxima generación de microprocesadores fueron los sistemas de 16 bits. Intel salió con el 8086 y a principios de la década de 1980, IBM diseñó el IBM PC en torno al 8088 de Intel (un 8086 en el interior, con un bus de datos externos de 8 bits). Microsoft ofreció a IBM un paquete que incluía BASIC y un sistema operativo, DOS (Disk Operating System) desarrollado originalmente por otra compañia. Microsoft compró el producto y contrató al autor original para mejorarlo. El sistema revisado sistema pasó a llamarse MS-DOS (MicroSoft Disk Operating System) y rápidamente llegó a dominar el mercado de IBM PC.

CP/M, MS-DOS y Apple DOS eran sistemas de línea de comandos: los usuarios escribían comandos en el teclado. Años antes, Doug Engelbart del Stanford Research Institute había inventado la GUI (Interfaz gráfica de usuario), pronunciada “pegajosa”, completa con ventanas, iconos, menús y ratón. Steve Jobs de Apple vio la posibilidad de una computadora personal verdaderamente fácil de usar (por usuarios que no sabían nada de computadoras y no querían aprender), y el Apple Macintosh se anunció a principios de 1984. Utilizaba la CPU 68000 de 16 bits de Motorola y tenía 64 KB de ROM, para admitir la GUI. El Macintosh ha evolucionado a lo largo de los años. Las CPU de Motorola eran verdaderos sistemas de 32 bits, y más tarde Apple se mudó a las CPU de IBM PowerPC, con
Arquitectura RISC de 32 bits (y posterior, 64 bits). En 2001, Apple hizo un cambio de sistema operativo importante, lanzando Mac OS X, con una nueva versión de la GUI de Macintosh sobre UNIX. Y en 2005 Apple anunció que cambiaría a procesadores Intel. Para competir con Macintosh, Microsoft inventó Windows. Originalmente, Windows era solo un entorno gráfico en la parte superior de MS-DOS de 16 bits (es decir, era más como un shell que un verdadero sistema operativo). Sin embargo, las versiones actuales de Windows son descendientes de Windows NT, un sistema de 32 bits, reescrito desde cero.
El otro competidor importante en el mundo de las computadoras personales es UNIX (y sus diversos derivados). UNIX es más fuerte en estaciones de trabajo y otras computadoras de alta gama, como servidores de red. Son especialmente populares en máquinas impulsadas por chips RISC de alto rendimiento. En Computadoras basadas en Pentium, Linux se está convirtiendo en una alternativa popular a Windows para los estudiantes y cada vez más usuarios corporativos. (A lo largo de este libro usaremos el término “Pentium” para referirnos a la Familia Pentium, que incluye Celeron de gama baja, Xeon de gama alta y AMD compatibles). Aunque muchos usuarios de UNIX, especialmente programadores experimentados, prefieren un sistema basado en linea de comandos a una GUI, casi todos los sistemas UNIX admiten un sistema de ventanas llamado X Window, un sistema desarrollado en M.I.T. Este sistema maneja la gestión básica de ventanas, lo que permite a los usuarios crear, eliminar, mover y cambiar el tamaño de las ventanas usando un mouse. A menudo, una GUI completa, como Motif, esta disponible para ejecutarse en la parte superior del sistema X Window, lo que le da a UNIX una apariencia similar a la Macintosh o Microsoft Windows para aquellos usuarios de UNIX que quieran tal cosa. Un desarrollo interesante que comenzó a tener lugar a mediados de la década de 1980 es el crecimiento de redes de computadoras personales que ejecutan sistemas operativos de red sistemas operativos distribuidos (Tanenbaum y Van Steen, 2002). En un sistema operativo de red, los usuarios son conscientes de la existencia de varias computadoras y pueden iniciar sesión en máquinas remotas y copiar archivos de una máquina a otra. Cada máquina ejecuta su propio sistema operativo local y tiene su propio usuario (o usuarios) locales. Básicamente, las máquinas son independientes entre sí.

Los sistemas operativos de red no son fundamentalmente diferentes de los que operan con un solo procesador. Obviamente, necesitan un controlador de interfaz de red y algún software de bajo nivel para controlarlo, así como los programas para lograr el inicio de sesión remoto y el acceso remoto a archivos, pero estas adiciones no cambian la estructura esencial del sistema operativo.
Un sistema operativo distribuido, por el contrario, es uno que aparece a sus usuarios como un sistema operativo tradicional monoprocesador, aunque en realidad está compuesto por varios procesadores. Los usuarios no debe saber dónde se ejecutan sus programas o dónde se encuentran sus archivos; tal cosa debe ser manejada de manera automática y eficiente por el sistema operativo. Los verdaderos sistemas operativos distribuidos requieren algo más que agregar un poco de código a un sistema operativo monoprocesador, porque los sistemas distribuidos y centralizados difieren en formas críticas. Los sistemas, por ejemplo, a menudo permiten que las aplicaciones se ejecuten en varios procesadores al mismo tiempo, requiriendo así algoritmos de programación de procesador más complejos para optimizar la cantidad de paralelismo. Los retrasos en la comunicación dentro de la red a menudo significan que estos (y otros) algoritmos deben ejecutarse con información incompleta, desactualizada o incluso incorrecta. Esta situación es radicalmente diferente de un sistema de un solo procesador en el que el sistema operativo tiene información completa sobre el estado del sistema.

CROSS-SITE REQUEST FORGERY

Un ataque de falsificación de solicitud entre sitios (CSRF) ocurre cuando un atacante puede hacer que el navegador de un objetivo envíe una solicitud HTTP a otro sitio web. Ese sitio web luego realiza una acción como si la solicitud fuera válida y enviada por el objetivo. Tal ataque generalmente se basa en que el […]

Leer más CROSS-SITE REQUEST FORGERY

HTTP PARAMETER POLLUTION

La contaminación del parámetro HTTP (HPP) es el proceso de manipulacion de cómo un sitio web trata los parámetros que recibe durante las solicitudes HTTP. La vulnerabilidad ocurre cuando un atacante inyecta parámetros adicionales en una solicitud y el sitio web objetivo confía en ellos, lo que lleva a un comportamiento inesperado. Errores de HPP […]

Leer más HTTP PARAMETER POLLUTION

OPEN REDIRECT

Comenzaremos el post con las vulnerabilidades de redireccionamiento abierto (open redirect), que ocurren cuando un objetivo visita un sitio web y ese sitio web envía su navegador a una URL diferente, potencialmente en un dominio separado. Las redirecciones abiertas aprovechan la confianza de un determinado dominio para atraer victimas a un sitio web malicioso. Un […]

Leer más OPEN REDIRECT

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Salir /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Salir /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Salir /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Salir /  Cambiar )

Conectando a %s