Administracion-de-sistemas-Unix

Vista previa del material en texto

UNIVERSIDAD NACIONAL AUTONÓMA 
DE MÉXICO 
 
 
 
FACULTAD DE ESTUDIOS SUPERIORES 
ARAGÓN 
 
 
 
DIPLOMADO DE DISEÑO E IMPLANTACIÓN DE 
SOFTWARE LIBRE EN LINUX 
 
ESPECIALIZACIÓN EN ADMINISTRACIÓN DE 
SISTEMAS UNIX 
 
 
 
“ADMINISTRACIÓN DE SISTEMAS UNIX” 
 
 
 
 
 
 
 
 
TRABAJO ESCRITO EN LA MODALIDAD DE 
SEMINARIOS Y CURSOS DE ACTUALIZACIÓN 
Y CAPACITACIÓN PROFESIONAL 
QUE PARA OBTENER EL TÍTULO DE: 
INGENIERO EN COMPUTACIÓN 
P R E S E N T A: 
POBLANO HERNÁNDEZ GERARDO OMAR 
ASESOR: M. EN.C. PEREZ MEDEL MARCELO 
 
MÉXICO, 2007 
 
 
UNAM – Dirección General de Bibliotecas 
Tesis Digitales 
Restricciones de uso 
 
DERECHOS RESERVADOS © 
PROHIBIDA SU REPRODUCCIÓN TOTAL O PARCIAL 
 
Todo el material contenido en esta tesis esta protegido por la Ley Federal 
del Derecho de Autor (LFDA) de los Estados Unidos Mexicanos (México). 
El uso de imágenes, fragmentos de videos, y demás material que sea 
objeto de protección de los derechos de autor, será exclusivamente para 
fines educativos e informativos y deberá citar la fuente donde la obtuvo 
mencionando el autor o autores. Cualquier uso distinto como el lucro, 
reproducción, edición o modificación, será perseguido y sancionado por el 
respectivo titular de los Derechos de Autor. 
 
 
 
 
Administración de Sistemas 
Unix 
 
 
 
 
 
 
 
Agradecimientos 
Agradezco profundamente a la Universidad Nacional Autónoma de México 
UNAM por la confianza ofrecida a lo largo de estos cinco años. Por permitirme ser 
un profesionista más de la carrera de Ingeniería en Computación y conformar 
parte de este importante orgullo universitario. 
A su vez, también mis agradecimientos hacia la Facultad de Estudios 
Superiores Aragón, profesores y directivos, por su incontenible labor en hacer de 
ésta facultad la fuente de nuestro conocimiento y formación. 
Mantengo mi gratitud a la Dirección General de Servicios de Cómputo 
Académico, por permitirme un desarrollo profesional. A los profesores y 
compañeros que ahí colaboran, por su camaradería en esta travesía vivida de casi 
dos años. 
A mis compañeros y amigos de carrera, por compartir anécdotas y colaborar 
activamente en cada uno de los proyectos y adversidades que nos acaecieron. 
Finalmente y no siendo menos importante, sino el que más, un agradecimiento 
especial hacia mi familia, por su inmensurable apoyo. Por ser el motor que me 
impulso en la finalización de este sueño logrado de cinco años de esfuerzo, lucha 
y dedicación. 
Gracias. 
 
 
Contenido 
AGRADECIMIENTOS............................................................................................. II 
CONTENIDO.......................................................................................................... III 
ÍNDICE DE FIGURAS ............................................................................................VI 
ÍNDICE DE TABLAS............................................................................................VIII 
INTRODUCCIÓN ...................................................................................................XI 
ADMINISTRACIÓN DE SISTEMAS........................................................................ 1 
1.1. Introducción al Sistema Operativo Unix
1.1.1. 
1.1.2. 
1.1.3. 
1.1.4. 
1.1.5. 
1.1.6. 
................................................... 1 
Antecedentes ........................................................................................ 1 
La creciente importancia de Unix .......................................................... 6 
¿Qué es Unix?....................................................................................... 7 
La filosofía de Unix .............................................................................. 10 
Edición de texto en Unix...................................................................... 11 
.............................................. 12 Introducción a la programación en shell
1.2. Utilerías de Unix
1.2.1. 
1.2.2. 
1.2.3. 
1.2.4. 
1.2.5. 
1.2.6. 
1.2.7. 
1.2.8. 
1.2.9. 
....................................................................................... 15 
Conceptos asociados al manejo de utilerías ....................................... 15 
Búsqueda de patrones en archivos ..................................................... 16 
Operación con columnas y campos..................................................... 18 
Herramientas para la ordenación ........................................................ 18 
Comparación de archivos.................................................................... 19 
Cambio de información en archivos .................................................... 19 
Monitorización de la entrada y salida .................................................. 21 
Herramientas para visualizar fechas y hora
awk
........................................ 21 
...................................................................................................... 21 
1.3. Llamadas al sistema
1.3.1. 
1.3.2. 
1.3.3. 
1.3.4. 
1.3.5. 
 1.3.6.
................................................................................. 25 
El kernel .............................................................................................. 25 
Arquitectura del sistema Unix .............................................................. 25 
Visión general del sistema de archivos ............................................... 28 
Estándares de Unix ............................................................................. 29 
ANSI C
POSIX
................................................................................................ 30 
................................................................................................. 31 
III 
 
IV CONTENIDO 
1.3.7. Sockets................................................................................................ 33 
1.4. Administración básica de Unix
1.4.1. 
1.4.2. 
............................................................... 37 
Características del administrador Unix
Tareas del administrador Unix
................................................ 38 
............................................................. 40 
1.5. Seguridad en Unix
1.5.1. 
1.5.2. 
1.5.3. 
1.5.4. 
1.5.5. 
1.5.6. 
.................................................................................... 43 
¿Qué es seguridad en cómputo? ........................................................ 43 
La seguridad y Unix............................................................................. 45 
Vulnerabilidades en los sistemas Unix ................................................ 46 
Esquema de seguridad........................................................................ 51 
Políticas y procedimientos de seguridad
Análisis de riesgos
............................................. 52 
............................................................................... 54 
PROGRAMACIÓN DE SISTEMAS....................................................................... 57 
2.1. Herramientas de Programación
2.1.1. 
2.1.2. 
2.1.3. 
2.1.4. 
.............................................................. 57 
Emacs ................................................................................................. 57 
CVS ..................................................................................................... 57 
MAKE .................................................................................................. 58 
............................................................................... 59 GNU Build System
2.2. Programación con C/C++
2.2.1. 
2.2.2. 
......................................................................... 61 
El lenguaje de programación C ...........................................................61 
....................................................... 67 El lenguaje de programación C++
2.3. Programación con Perl ............................................................................ 75 
CÓMPUTO DE ALTO RENDIMIENTO ................................................................. 77 
3.1. Introducción al Cómputo Científico
3.1.1. 
3.1.2. 
3.1.3. 
3.1.4. 
........................................................ 77 
Simulación........................................................................................... 77 
Supercómputo ..................................................................................... 79 
Realidad Virtual ................................................................................... 80 
........................................................................ 81 Visualización Científica
3.2. Redes
3.2.1. 
3.2.2. 
3.2.3. 
3.2.4. 
3.2.5. 
3.2.6. 
......................................................................................................... 83 
Introducción......................................................................................... 83 
Internet ................................................................................................ 83 
Modelo Cliente-Servidor ...................................................................... 88 
TCP/IP................................................................................................. 89 
Archivos y programas de red en Unix
Servicios de red en Unix
.................................................. 91 
...................................................................... 95 
3.3. Arquitecturas para el cómputo paralelo
Arquitecturas paralelas3.3.1. 
................................................. 97 
........................................................................ 97 
 
 
3.3.2. 
3.3.3. 
3.3.4. 
3.3.5. 
Tipos de máquinas paralelas............................................................... 98 
Memoria distribuida y compartida........................................................ 99 
Clusters ............................................................................................. 101 
.................... 103 Ventajas e inconvenientes de los sistemas distribuidos
3.4. Tópicos selectos de administración avanzada
3.4.1. 
3.4.2. 
3.4.3. 
3.4.4. 
3.4.5. 
.................................... 105 
Introducción al cómputo de alto rendimiento ..................................... 105 
Sistema de control de procesos ........................................................ 107 
Parámetros de rendimiento ............................................................... 112 
Administración de tareas ................................................................... 115 
.................................................. 118 Análisis del desempeño del sistema
CASOS PRÁCTICOS DE CONFIGURACIÓN.................................................... 123 
4.1. Proyecto 1: Introducción al sistema operativo Unix ........................... 123 
4.2. Proyecto 2: Utilerías de Unix ................................................................. 124 
4.3. Proyecto 3: Llamadas al sistema .......................................................... 124 
4.4. Proyecto 4: Administración básica de Unix ......................................... 125 
4.5. Proyecto 5: Seguridad en Unix.............................................................. 125 
4.6. Proyecto 6: Programación con C/C++ .................................................. 127 
CONCLUSIONES ............................................................................................... 129 
BIBLIOGRAFÍA
 
.................................................................................................. 133 
 
 
 
 
V 
 
 
Introducción 
El sistema operativo Unix ha sido desde sus inicios un proyecto bastante 
ambicioso. Las distintas implementaciones o “sabores” realizaron mejoras y 
actualizaciones a su diseño, para obtener de esta manera un sistema lo 
mayormente estable posible. Esta característica le ha otorgado a Unix la categoría 
de sistema “seguro” en términos de las posibilidades que éste ofrece y que 
podemos encontrar desde el sector académico hasta el empresarial en donde el 
valor de los activos se convierte en un issue muy importante. 
La UNAM, a través de la Dirección General de Servicios de Cómputo 
Académico (DGSCA) es hoy día la institución más importante de México en 
materia de Cómputo de Alto Rendimiento. Además de ofrecer servicios orientados 
a este último rubro es también un importante centro de investigación y docencia. 
Es por ello que su necesidad de la capacitación de recursos humanos para cubrir 
la demanda e interés de la comunidad científica, se convierta en una prioridad. El 
plan de becarios ofrecido y del cual tuve participación se convierte en una 
excelente oportunidad en la realización de actividades científicas y tecnológicas 
relacionadas al supercómputo. 
El presente trabajo es una compilación de temas basados en las habilidades 
necesarias y conocimientos que debe poseer un Administrador de Sistemas Unix. 
No obstante, el enfoque aquí presentado no es el de ser una guía completa de 
referencia, sino más bien es la de “tocar superficie” en cuanto a todos los tópicos 
que rodean a la Administración de Sistemas Unix y al Cómputo de Alto 
Rendimiento que conformaron la base de mi especialización. Esto no significa que 
no abarque lo suficiente o no cumpla con las expectativas, de hecho, retomo 
varios temas avanzados que bien valdría la pena considerarse como parte de un 
curso más avanzado u alguna otra especialización.
XI 
 
XII INTRODUCCIÓN 
Mi objetivo es la de fomentar el interés de aquella persona que lea este trabajo 
a indagar más sobre los temas que aquí se presentan y mirar otras opciones como 
Unix y sus derivados tales como Linux, que no son tan viejas como se creería y 
ofrecen mayores capacidades que otros sistemas operativos. 
Cada capítulo conforma la estructura en la que se basa este trabajo: 
Administración de Sistemas, Programación de Sistemas, Cómputo de Alto 
Rendimiento y Casos Prácticos de Configuración. A si mismo, cada capítulo esta 
subdividido por temas que surgen como parte del temario original de la 
especialización antes mencionada. 
En el capítulo 1 se hace una introducción sobre aquellos fundamentos que 
influyen sobre la filosofía que ha mantenido Unix a lo largo de los años. Estos 
elementos han originado la inclinación de la balanza hacia ambientes en los que la 
prioridad es mantener una estabilidad en cuanto a seguridad y operabilidad. El 
hecho de ajustar el sistema a las necesidades de cualquier organización o 
escenario y que no sea lo contrario, es decir, que la organización sea la que se 
ajuste al sistema, sobresale sobre cualquier otro sistema operativo. Las llamadas 
al sistema, la programación en shell y el sin fin de comandos que el sistema Unix 
ofrece permiten esta orientación por cubrir las necesidades de cualquier 
organización. 
En el capítulo 2 se hace mención de las herramientas auxiliares existentes en 
cualquier ambiente Unix necesarias para llevar a cabo una adecuada 
administración y desarrollo de proyectos profesionales de cualquier ámbito. El 
conocimiento y uso de estas herramientas se convierten en obligatorios por parte 
del administrador ya que facilitan la realización de programas para la 
automatización de ciertas tareas que requieren de una funcionalidad especial en el 
sistema, o como parte de requerimientos específicos de proyectos de los usuarios. 
No pasando por hecho de que la programación en C es la base sobre la cual esta 
programado en su mayoría el sistema Unix. 
El capítulo 3 es, quizás, uno de los más importantes debido al papel que 
desempeña el cómputo de alto rendimientocomo ciencia aplicativa a problemas 
complejos. Se abre entonces una puerta para la computación distribuida y las 
 
 
nuevas tecnologías que surgen para cubrir las necesidades de recursos 
computacionales a gran escala. Las características avanzadas que se mencionan 
en este capítulo conforman parte esencial en la administración de equipos 
especializados en el que los recursos son variables importantes en el rendimiento 
y desempeño del sistema. Estos tópicos establecen los factores influyentes en el 
comportamiento del sistema en términos de una arquitectura especializada capaz 
de proporcionar servicios hacia usuarios con necesidades igual de especializadas. 
El capítulo 4 mantiene una descripción de aquellos proyectos realizados 
durante los diferentes cursos tomados. Cada caso práctico es un proyecto distinto 
que permite evaluar la parte aplicada y entendimiento de los diferentes cursos de 
la especialización, manteniendo siempre estrecha relación entre investigación e 
inventiva para la resolución de problemas típicos en ambientes reales de 
administración de equipos de alto rendimiento. Al final de este trabajo se podrá 
encontrar parte del código y archivos utilizados de forma libre durante esta 
especialización con la finalidad de recomendaciones para futuras modificaciones y 
actualizaciones hacia estos trabajos. 
 
 
 
XIII 
 
Capítulo 1 
Administración de Sistemas 
1.1. Introducción al Sistema Operativo Unix 
El sistema Unix ha tenido una historia y evolución fascinantes. Iniciado como 
un proyecto de investigación por un puñado de personas, se ha convertido hoy en 
día en un sistema operativo de alta demanda en los sectores empresariales y 
académicos. 
Unix fue creado hace ya más de 30 años y es el único sistema operativo que 
continúa ampliamente utilizado hasta nuestros días. Unix es universal, operado 
por una gran variedad de personas para diferentes tipos de propósitos. 
 
1.1.1. Antecedentes 
Unix fue diseñado por representantes de AT&T en el desarrollo de MULTICS, 
en el MIT, a finales de los sesenta. MULTICS, un sistema desarrollado por varias 
compañías entre las que destacan AT&T y General Electric, ha influido en gran 
medida el diseño de los sistemas modernos. Como uno de los primeros sistemas 
de tiempo compartido, MULTICS incorporaba la mayoría de las ideas que 
aparecen en los sistemas operativos actuales. Desgraciadamente MULTICS 
resultó mucho más complejo y pesado de lo que era necesario, lo cual lo hizo 
inviable. A finales de los sesenta, AT&T abandonó el proyecto MULTICS. Sin 
embargo, Ken Thompson y Dennis Ritchie, quienes habían participado en el
1 
 
2 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
proyecto, decidieron construir el sistema basado en un diseño que ellos mismos 
elaboraron junto con Rudd Canaday. Luego se les unieron otros informáticos 
capaces como J. F. Ossanna y R. Morris. Adquirieron una DEC PDP-7 de desecho 
y se pusieron a desarrollar. Como muchos proyectos interesantes, éste empezó 
con la creación de un juego: Thompson y Ritchie desarrollaron un juego de Viaje 
espacial para la PDP-7. Luego crearon una nueva estructura de sistemas de 
archivos y nuevo software. Le añadieron un entorno de procesos con planificación 
y completaron un sistema operativo rudimentario. Al resultado se le nombró UNIX 
pues era una simplificación de MULTICS. La primera versión de Unix se codificó 
en lenguaje ensamblador. Un año después Ritchie instaló el sistema en una DEC 
PDP-11. 
Luego, dentro de ese mismo grupo se desarrolló el lenguaje de programación 
C, proyecto que iniciaron en 1971. Casi inmediatamente se usó el lenguaje C para 
continuar el desarrollo de Unix. Así se rompió la tradición de escribir sistemas 
operativos en lenguaje ensamblador. Sólo algunas subrutinas de alto rendimiento 
dentro del núcleo del sistema están escritas en ensamblador. Esto permitió hacer 
a Unix muy portable y ganar popularidad. 
Muchos integrantes del equipo de los Laboratorios Bell se interesaron en Unix 
y después de dos o tres años, estaba corriendo en varias máquinas diferentes. El 
sistema Unix se consolidó con el desarrollo de las PDP-11 superiores, como la 
PDP-11/45 y la PDP-11/70, a mediados de los setenta. AT&T distribuyó copias de 
Unix a universidades de todo el mundo, lo cual propició más innovaciones y la 
Universidad de California en Berkeley desarrolló su propia implementación: BSD 
(Berkeley Software Distribution), la cual es ampliamente utilizada. Al tiempo que 
AT&T fortalecía y optimizaba Unix con un enfoque comercial, la implementación 
BSD dominaba en los ambientes universitarios y técnicos. Las versiones BSD 
fueron la plataforma dominante para experimentación en conceptos de red. El 
primer experimento importante en redes de área extensa, el ARPANET, fue 
orientado a Unix. 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 3 
 
Figura 1.1: Desarrollo de la distribución Berkeley Software Distribution 
 
A finales de los setenta, AT&T introdujo un nuevo esquema de denominación 
para su versión del sistema Unix. Hasta entonces, las revisiones importantes se 
referían a las nuevas versiones que emergían del área de investigación de los 
laboratorios Bell. AT&T cambió su numeración a sistema III y sistema V, 
descendientes directas de la edición séptima. El sistema V sustituyó al sistema III 
a mediados de los ochenta. El sistema IV se utilizó dentro de los laboratorios Bell, 
 
 
4 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
pero se consideró un producto de transición. AT&T normalizó el nombre de 
sistema V y sus versiones recientes se denominan sistema V revisión 3 y sistema 
V revisión 4, que con frecuencia se abrevian como SVR3 y SVR4, 
respectivamente. 
 
Figura 1.2: Desarrollo de la distribución de System V 
 
Al incrementarse la velocidad y potencia de las microcomputadoras y con la 
disminución de su costo, estas pudieron soportar el sistema Unix. Cuando los 
sistemas SVR3 y SVR4 estuvieron disponibles en máquinas de arquitectura PC-
AT a finales de los ochenta, creció mucho la popularidad de Unix. Otro paso 
importante fué la aparición del sistema de ventanas X. X fue un prototipo de un 
proyecto de investigación en el MIT a mediados de los ochenta, luego lo adaptaron 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 5 
algunas compañías, lo mejoraron y estabilizaron para poder hacerlo comercial. 
Actualmente, la mayoría de los paquetes de aplicaciones comerciales para Unix 
corren bajo el entorno X. 
En las últimas revisiones de SVR3 se inició una mezcla de las tres variantes 
principales del sistema Unix. Como resultado de acuerdos entre AT&T, Sun 
Microsystems y Microsoft, los sistemas BSD y XENIX están fundidos dentro del 
sistema V. 
Al tiempo de la fusión entre BSD y el sistema V, otros vendedores de sistemas 
Unix se preocupaban de que un sistema mixto diera predominio a AT&T y Sun 
Microsystems en el mercado. Estos vendedores, principalmente Hewlett-Packard y 
DEC, formaron un consorcio para desarrollar una variante que no estuviera bajo el 
control de AT&T o Sun. Este grupo, llamado Open Software Foundation (OSF), ha 
desarrollado varios productos importantes para el sistema Unix, el principal de 
ellos, la interfaz de usuario Motif. 
 
Figura 1.3: Genealogía del sistema Unix 
 
Unix y la mayoría de los sistemas que se ejecutan en él, están escritos en 
lenguaje C y han demostrado que un sistema operativo interactivo y poderoso, no 
necesariamente es grande y caro, ya sea en equipo o en cantidad de código. En 
 
 
6 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
palabrasde sus creadores, el objetivo es que, desde el punto de vista del usuario, 
sea simple y fácil de usar. 
 
1.1.2. La creciente importancia de Unix 
Durante los últimos años el sistema operativo Unix se ha consolidado como un 
sistema operativo potente, flexible y versátil. Sirve como un sistema operativo 
multiplataforma, incluyendo desde computadoras personales, workstation y 
supercomputadoras. El éxito del sistema Unix se debe a muchos factores. Entre 
ellos está la portabilidad a un gran abanico de máquinas, su adaptabilidad y 
simplicidad, el amplio rango de tareas que se pueden realizar, su naturaleza 
multiusuario, multitarea y su adecuación a las redes. 
El código fuente del sistema Unix, y no el código ejecutable, ha estado 
disponible a usuarios y programadores. A causa de esto, mucha gente ha sido 
capaz de adaptar el sistema Unix de formas diferentes. Este carácter abierto ha 
conducido a la introducción de un amplio rango de características nuevas y de 
versiones personalizadas que se ajustan a necesidades especiales. A las 
personas que han desarrollado esta adaptación del sistema Unix les ha resultado 
fácil porque el código correspondiente es sencillo, modular y compacto. Esto ha 
fomentado la evolución del sistema Unix, haciendo posible la fusión de las 
capacidades desarrolladas por varias variantes del sistema Unix necesarias para 
soportar los entornos de computación de hoy en un sistema operativo único. 
El sistema Unix proporciona a los usuarios diferentes herramientas y utilidades 
que se pueden utilizar para realizar una gran variedad de trabajos. Algunas de 
estas herramientas son órdenes simples que se pueden utilizar para llevar a cabo 
tareas específicas. Otras herramientas y utilidades son realmente pequeños 
lenguajes de programación que se pueden utilizar para construir scripts que 
resuelven sus propios problemas. Lo más importante es que las herramientas 
están diseñadas para funcionar juntas, como partes de una máquina o bloques de 
construcción. El sistema operativo Unix puede ser utilizado por computadoras con 
muchos usuarios o con un único usuario, ya que es un sistema multiusuario. 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 7 
También es un sistema multitarea, ya que un único usuario puede llevar a cabo 
más de una tarea al mismo tiempo. El sistema Unix proporciona un entorno 
excelente para redes. Ofrece programas y facilidades que proporcionan los 
servicios necesarios para construir aplicaciones basadas en red, base de la 
computación distribuida. En la computación en red la información y su 
procesamiento es compartida entre diferentes computadoras de la red. 
El sistema Unix es mucho más fácil de portar a nuevas máquinas que otros 
sistemas operativos. Esto es, se necesita menos trabajo para adaptarlo y correrlo 
sobre una máquina nueva. La portabilidad del sistema Unix es consecuencia 
directa de estar escrito casi completamente en un lenguaje de alto nivel, el 
lenguaje C. La portabilidad a un amplio rango de computadoras hace posible 
mover las aplicaciones de un sistema a otro. 
 
1.1.3. ¿Qué es Unix? 
Para comprender cómo opera el sistema Unix, se necesita entender su 
estructura. El sistema operativo Unix lo forman varios componentes principales. 
Entre estos componentes están el núcleo, el shell, el sistema de archivos y los 
comandos (o programas de usuario). 
 
Figura 1.4: Estructura general de Unix 
 
 
8 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
Aplicaciones 
Se pueden utilizar aplicaciones construidas utilizando comandos, herramientas 
y programas del sistema Unix. Los programas de aplicación llevan a cabo 
diferentes tipos de tareas. Algunas realizan funciones generales que pueden ser 
utilizadas por una amplia variedad de usuarios. Estas se conocen como 
aplicaciones horizontales e incluyen programas tales como procesadores de texto, 
compiladores, sistemas de gestión de base de datos, hojas de cálculo, programas 
de análisis estadístico y programas de comunicaciones, entre otros. Otras son 
específicas de la industria y se conocen como aplicaciones verticales. Ejemplos de 
ellas serían los paquetes de software utilizados para la administración de un 
banco, centro comercial, etc. Es posible que el programador cree sus propias 
aplicaciones mediante lenguajes como C, C++, fortran, Java, ensamblador, etc. 
Existe un gran número de bibliotecas que permiten reforzar las aplicaciones que el 
programador vaya creando y que sólo necesita incluir en un programa. La ventaja 
es que todos los programas que realicen pueden ser transportados a otros 
sistemas y sólo bastará compilar de nuevo y ejecutar. 
Utilerías 
El sistema Unix contiene varios cientos de utilerías o programas de usuario. 
Los comandos también se conocen como herramientas, pues pueden utilizarse 
independientemente o en forma conjunta de diversas maneras para llevar a cabo 
tareas útiles. Estas utilerías se pueden ejecutar invocándolas por su nombre a 
través del shell, por esta razón es por lo que se les conocen como comandos o 
instrucciones del sistema. 
Se pueden realizar muchas tareas automatizadas utilizando las utilerías 
estándar suministradas con el sistema Unix. Hay utilerías para edición y 
procesamiento de texto, para manipulación de información, comunicaciones 
electrónicas y para redes, para realizar cálculos, para desarrollar programas de 
computadoras, para la administración del sistema, y muchos otros propósitos. 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 9 
El sistema de archivos 
La unidad básica utilizada para organizar la información en el sistema Unix se 
denomina archivo. El sistema de archivos de Unix proporciona un método lógico 
para organizar, almacenar, recuperar, manipular y gestionar la información. Los 
archivos están organizados en un sistema de archivos jerárquico, agrupados en 
directorios. Una característica de simplificación importante del sistema Unix es la 
forma general de tratamiento de los archivos. Por ejemplo, los dispositivos 
físicos se tratan como archivos; esto permite que los comandos operen sobre 
archivos ordinarios y sobre dispositivos físicos. 
 
Figura 1.5: El sistema de archivos jerárquico 
El shell 
El shell lee los comandos y los interpreta como peticiones de ejecución de un 
programa o programas, lo que realiza posteriormente. Debido a este papel, el shell 
se denomina intérprete de comandos. Además de ser un intérprete, el shell 
también es un lenguaje de programación. Como lenguaje de programación permite 
controlar como y cuando se llevan a cabo la ejecución de los comandos. 
 
Figura 1.6: El intérprete de comandos shell 
 
 
10 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
El kernel 
El núcleo o kernel es la parte del sistema operativo que interactúa 
directamente con el hardware de la computadora. Proporciona conjuntos de 
servicios que pueden ser utilizados por programas, aislando a estos programas del 
hardware subyacente. Las funciones principales del núcleo son la administración 
de la memoria, el control de acceso a la computadora, el mantenimiento del 
sistema de archivos, el manejo de las interrupciones (señales que finalizan la 
ejecución), el manejo de errores, la realización de los servicios de entrada y salida 
(que permite a las computadoras interactuar con terminales, dispositivos de 
almacenamiento e impresoras) y la asignación de recursos de la computadora 
entre los usuarios. 
Los programas interactúan con el kernel a través de aproximadamente 100 
llamadas al sistema. Las llamadas al sistema dicen al núcleo que lleve a cabo 
diferentes tareas para el programa, tales como abrir un archivo, escribir en un 
archivo,obtener información sobre un archivo, ejecutar un programa, terminar un 
proceso, cambiar la prioridad de un proceso u obtener la hora y la fecha. 
 
1.1.4. La filosofía de Unix 
Conforme ha ido evolucionando, el sistema Unix ha desarrollado un enfoque 
característico y consistente que se denomina a veces como filosofía Unix. Esta 
filosofía ha influido profundamente sobre la estructura del sistema y la forma de 
operar. Tener presente esta filosofía ayuda a entender la forma en que el sistema 
Unix trata los archivos y programas, los tipos de comandos y la manera de 
utilizarlos para llevar a cabo una tarea. La filosofía Unix se basa en la idea de que 
un sistema informático potente y complejo debe ser simple, general y extensible 
y que esto proporciona importantes beneficios tanto para los usuarios como para 
los que desarrollan programas. Este planteamiento queda especialmente reflejado 
en la forma en que el sistema Unix trata los archivos y en la manera de enfocar a 
sus herramientas. 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 11 
El sistema Unix contempla los archivos de una manera extremadamente 
simple y general dentro de un modelo único. Ve de la misma manera a los 
directorios, archivos ordinarios, los dispositivos, tales como impresoras y discos, y 
los teclados y terminales de pantalla. El sistema de archivos oculta al usuario 
detalles del hardware subyacente. Esta simplicidad le permite concentrarse sobre 
lo que realmente le interesa: los datos y la información que contiene el archivo. 
En una red de área local, el concepto de sistemas de archivos remoto le ahorra la 
necesidad de conocer sobre que máquina están sus archivos. Una característica 
única del sistema Unix es la gran colección de herramientas que proporciona. Esta 
es otra expresión de la filosofía básica. Estas herramientas son pequeños 
programas, cada uno diseñado para realizar una función específica, y todos 
diseñados para operar juntos. En lugar de pocos programas grandes, cada uno 
tratando de realizar muchas cosas, el sistema Unix proporciona muchas 
herramientas simples que pueden combinarse para realizar un amplio rango de 
cosas. Algunas herramientas llevan a cabo una tarea básica y tienen nombres 
mnemotécnicos. Otras, como awk son lenguajes de programación y por tanto con 
sintaxis complicadas. 
El énfasis sobre herramientas modulares es soportado por una de las 
características más típicas del sistema Unix, el pipe. Esta característica, de 
importancia tanto para los usuarios como para los programadores, es un 
mecanismo general que permite utilizar la salida de un comando como entrada a 
otro. Se trata del entubamiento utilizado para unir herramientas que van a realizar 
la tarea que se necesita. El sistema Unix trata la entrada y salida de una forma 
simple y consistente, utilizando una entrada y salida estándar. 
 
1.1.5. Edición de texto en Unix 
Un editor es una utilidad ofrecida por la mayoría de los sistemas operativos 
que nos permite modificar el contenido de un archivo. Cuando hablamos de 
editores o programas de edición, normalmente nos referimos a editores de texto. 
Unix cuenta con varios editores de texto, entre los que destacan por su uso: 
 
 
12 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 ed 
 vi 
 emacs 
 
Existen básicamente dos tipos de editores en Unix: editores de línea y editores 
de pantalla. En los primeros, el contenido de un archivo se muestra y edita línea 
por línea, en tanto que los segundos es posible editar texto en una pantalla 
completa, por lo que uno puede desplazarse libremente por todo el archivo. El 
editor ed es un ejemplo de un editor de línea, mientras que vi ejemplifica los 
editores de pantalla. El editor de texto más ampliamente utilizado en sistemas Unix 
es el editor de pantalla vi. 
 
1.1.6. Introducción a la programación en shell 
La palabra shell en el sistema Unix hace referencia a diferentes cosas. En 
primer lugar, el shell hace referencia al intérprete de comandos que es la Interfaz 
de usuario principal en los sistemas Unix. Es el shell quien atiende lo que se teclea 
y quien ejecuta estos comandos. Un segundo uso de la palabra tiene que ver con 
el hecho de que el shell incluye un lenguaje de programación completo. Esto es lo 
que se conoce como lenguaje de programación del shell o el lenguaje del shell. En 
pocas palabras, los usuarios hablan de programas escritos en shell. Un programa 
escrito en shell, o en lenguaje de programación shell, se denomina script de shell 
o programa de shell. El lenguaje de shell es un lenguaje de programación de alto 
nivel, que permite ejecutar secuencias de comandos para seleccionar operaciones 
alternativas dependientes del resultado de pruebas lógicas y para repetir acciones 
del programa. Un script puede tomar la entrada de un usuario (vía entrada 
estándar), de un archivo o de la salida de otro comando. Es útil para crear pilas de 
comandos y automatizar ciertas tareas. 
A grandes rasgos, podemos decir que el shell tiene las siguientes funciones: 
 Uso interactivo: El sistema ejecuta comandos tecleados desde el prompt. 
 Personalización de una sesión de trabajo: El ambiente de trabajo, como la 
definición del directorio de trabajo por el usuario, la configuración de la terminal, 
etc., es controlado por variables definidas por el shell. 
 
 
1.1. INTRODUCCIÓN AL SISTEMA OPERATIVO UNIX 13 
 Programación: Permite la creación y ejecución de scripts. 
 
Algunas de las aplicaciones de los scripts son: 
 Instalación de software 
 Procedimientos de respaldo 
 Personalización del ambiente de trabajo 
 
Tradicionalmente Unix maneja 3 shells: Bourne shell, Korn shell y C shell. 
Cada shell tiene su propio lenguaje de programación de alto nivel utilizado para 
ejecutar secuencias de comandos, seleccionar entre operaciones alternas, realizar 
operaciones lógicas y acciones repetitivas. El Bourne shell y el Korn shell tienen 
sintaxis similares, mientras que el C shell tiene una sintaxis similar a la del 
lenguaje C y ofrece otras capacidades. 
Shell Autor Características Comando Prompt 
Bourne Shell Steve 
Bourne 
 Shell original del Unix de AT&T 
 Es el shell estándar de Unix 
 No permite historia de comandos 
 Permite la redirección de Entrada/Salida
 Permite el uso de metacaracteres
(comodines) para la abreviación de los
nombres de archivos 
 Posee un conjunto de comandos
propios para la programación 
 Usado por todos los scripts de
administración del sistema 
 
/bin/sh $ 
Korn Shell David Korn Compatible con Bourne Shell 
 Incluye operaciones aritméticas,
arreglos y manipulación de cadenas 
 Permite historia de comandos (acceso a
comandos ya tecleados) 
 Usa un mayor número de
metacaracteres 
 Permite utilizar arreglos y expresiones
aritméticas 
 Permite usar alias (abreviación de
comandos) 
/bin/ksh $ 
C Shell Bill Joy Diseñado en la Universidad de
California, en Berkeley 
 /bin/csh 
 Redireccionamiento de E/S 
 Incorpora alias e historia de comandos 
% 
 
 
14 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 Sintaxis similar a la del lenguaje C 
 
Tabla 1.1: Tabla comparativa de los shells de Unix 
Variables 
Una variable es un nombre que se refiere a un área de almacenamiento 
temporal en la memoria del sistema. La programación en shell utiliza dos tipos de 
variables: 
 Variables del shell 
 Variables de ambiente 
 
La diferencia es que las variables del shell son como variables locales, es decir 
sólo son conocidas por el shell que las genera, en tanto las variables de ambiente 
son como variables globales, que pueden ser heredadas a procesos hijos, es 
decir, son reconocidas por cualquier programa o script. 
 
Variable SignificadoHOME=dir Guarda el directorio home del usuario 
IFS=caracteres Separadores de campos internos (espacio, tabuladores, salto de línea,
etc.) 
MAIL=archivo Archivo en dónde el usuario recibe su correo 
MAILCHECK=n Frecuencia (en segundos) con que el shell verifica si hay mensajes de
correo para el usuario 
PATH=dirs Almacena uno o más directorios, separados por :, en donde se buscará
un programa cuando este se ejecute 
PS1=cadena Almacena el prompt primario (generalmente, $) 
PS2=cadena Almacena el prompt secundario (generalmente, <) 
SHELL=archivo Nombre del shell utilizado 
TERM=cadena Tipo de terminal que se está utilizando 
 
Tabla 1.2: Algunas variables del shell en Unix 
 
 
 
 
 
 
1.2. UTILERÍAS DE UNIX 15 
1.2. Utilerías de Unix 
Una de las características más valiosas del sistema Unix es el conjunto tan 
rico de comandos que proporciona. Esto se debe a que desde sus inicios ha 
conservado la filosofía que lo caracteriza: 
El potencial del sistema operativo radica más en la relación de los programas que en 
los programas mismos. 
Lo que significa que Unix posee los medios necesarios para integrar distintos 
comandos, aprovechando sus capacidades conjuntas para llevar a cabo tareas 
más complejas de una manera relativamente más sencilla. De hecho, en Unix son 
pocos los comandos que realizan más de una función en particular. 
 
1.2.1. Conceptos asociados al manejo de utilerías 
Operaciones de Entrada y Salida 
El sistema de E/S (Entrada y Salida) de Unix se divide en 2 sistemas 
complementarios: el sistema de E/S por bloques y el sistema de E/S por 
caracteres. El primero se emplea para el manejo de discos y cintas magnéticas, 
mientras que el segundo se usa para atender terminales e impresoras. 
En general, Unix emplea programas especiales (escritos en C) conocidos 
como controladores para atender a cada familia de dispositivos de E/S. Los 
procesos se comunican con los dispositivos mediante llamadas a su controlador. 
Además, desde el punto de vista de los procesos, los controladores aparecen 
como si fueran archivos en los que se lee o escribe, lográndose así una 
homogeneidad y elegancia en el diseño. 
Las llamadas del sistema de más bajo nivel hacen referencia a un flujo de 
entrada y salida a través de un número de identificación llamado descriptor de 
archivo1. 
Por convención, cada proceso Unix tiene asignados 3 canales de E/S: 
 
1 File descriptor o simplemente fd 
 
 
16 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 Entrada estándar (fd=0), generalmente asociada con el teclado. 
 Salida estándar (fd=1), generalmente asociada con la pantalla. 
 Salida de errores estándar (fd=2), generalmente asociada con la pantalla. 
 
Pipes 
Un pipe es la manera de conectar la salida de un programa o comando a la 
entrada de otro programa sin hacer uso visible de un archivo temporal. Un pipe no 
es más que un mecanismo de almacenamiento temporal donde la salida de un 
comando es guardada para poder ser utilizada como la entrada de otro comando. 
Los pipes son usados para usar más de dos comandos (múltiples comandos) 
desde la misma línea de comandos. 
 
Figura 1.7: Entubamiento en Unix 
Filtros 
Muchos de los programas en Unix están diseñados como filtros, es decir, 
aceptan los datos de un dispositivo conocido como entrada y envían sus 
resultados a otro dispositivo conocido como salida. Un programa que opera de 
esta manera puede ser utilizado como filtro. 
Redireccionamiento 
Un redireccionamiento es una característica de Unix que nos permite cambiar 
el dispositivo asociado ya sea a la salida estándar o la entrada estándar de un 
programa. Por ejemplo, si se redirecciona la salida estándar de un comando hacia 
un archivo, lo que el programa imprima no aparecerá en la pantalla, sino que se 
escribiría al archivo que le indiquemos. 
 
1.2.2. Búsqueda de patrones en archivos 
Entre las herramientas más útiles del sistema Unix están aquellas que buscan 
palabras en archivos: grep, fgrep y egrep. Estos comandos buscan líneas que 
 
 
1.2. UTILERÍAS DE UNIX 17 
contengan texto que identifiquen a un objetivo o patrón que se especifica. Se 
pueden utilizar para extraer información de los archivos, buscar líneas que se 
relacionen con un elemento particular y para localizar archivos que contengan una 
palabra clave en específico. 
Los tres comandos descritos anteriormente son muy similares. Los tres 
imprimen las líneas que identifican a un objetivo. Se diferencian en la forma de 
especificar los objetivos de búsqueda. 
 grep: Es la más utilizada de las tres. Proporciona la posibilidad de buscar 
palabras, o patrones que contengan comodines y otros elementos de 
expresiones regulares. 
 fgrep: No permite expresiones regulares, pero permite buscar múltiples 
objetivos desde un archivo. 
 egrep: Toma un conjunto más rico de expresiones regulares, permitiendo 
además búsquedas de objetivos múltiples. 
 
Expresiones regulares 
Una expresión regular es la forma compacta de especificar un modelo general 
de caracteres. Dentro de una expresión regular determinados símbolos tienen 
significados especiales. 
c Cualquier carácter no especial c concuerda a sí mismo 
\c Cancela cualquier significado especial del carácter c 
^ Inicio de Línea 
$ Fin de Línea 
. Cualquier carácter individual 
[...] Cualquiera de los caracteres en ...; los rangos tipo a-z, A-Z y 0-9 son legales 
[^...] Cualquier carácter individual que no se encuentre en ...; los rangos son legales
r* Cero o más ocurrencias de r 
r+ Una o más recurrencias de r (solo egrep) 
r? Cero o una recurrencia de r (solo egrep) 
r1r2 r1 seguida de r2 
r1|r2 r1 o r2 (solo egrep) 
 
Tabla 1.3: Expresiones regulares en Unix 
 
 
18 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
Existen muchas áreas en Unix donde se puede usar una expresión regular en 
lugar de un modelo exacto, sin embargo los detalles en cuanto a que expresiones 
regulares son aceptables varían de un programa a otro. 
Partes de una expresión regular: 
 Posición 
 Conjunto de caracteres. 
 Modificadores 
Tipos de expresiones regulares: 
 Simples: vi, sed, grep, more, ed, expr, lex. 
 Extendidas: awk, egrep. 
 
1.2.3. Operación con columnas y campos 
Muchos archivos contienen información organizada en términos de posiciones 
dentro de una línea. Entre ellos están las tablas, que organizan la información en 
columnas, y los archivos que constan de líneas o registros formados por campos. 
El sistema Unix incluye varias herramientas diseñadas específicamente para 
operar con archivos organizados en columnas o campos. 
 cut: Permite seleccionar columnas o campos particulares en archivos. 
 paste: Crea nuevas tablas juntando columnas o campos de archivos 
existentes. 
 join: Une la información de dos archivos para crear un nuevo archivo que 
combina la información de ambos. 
 
1.2.4. Herramientas para la ordenación 
Muchas áreas requieren el uso de datos ordenados, y la ordenación de 
información en archivos y la operación sobre archivos ordenados son algunas de 
las tareas comunes de una computadora. La información se ordena en un archivo 
para facilitar la lectura, para facilitar la comparación de dos listas, o para preparar 
la información a un comando que necesita las entradas ordenadas. La información 
se puede ordenar alfabética o numéricamente, por líneas o en función de un 
campo o columna en particular. 
 
 
1.2. UTILERÍAS DE UNIX 19 
Uno de los comandos más útiles del sistema Unix es sort, una herramienta 
potente de propósito general que sirve para ordenar la información. 
 sort: Es un comando que nos permite ordenar el contenido de un archivo de 
acuerdo a un criterio alfabético o numérico, ascendente o descendente,y de 
acuerdo a cualquier campo de la línea, que nosotros especifiquemos. Los datos 
ordenados son impresos en la salida estándar. 
 uniq: Es un comando que sirve para identificar líneas que estén repetidas en 
un archivo de texto. Para que funcione correctamente, las líneas iguales tienen 
que estar juntas, es decir, es necesario primero ordenar el archivo utilizando 
sort. 
 
1.2.5. Comparación de archivos 
Con frecuencia se necesita ver si dos archivos tienen diferente contenido y 
listar las diferencias en caso afirmativo. También resulta útil la posibilidad de ver si 
archivos que tienen el mismo nombre en directorios diferentes, son simplemente 
copias del mismo archivo o si se trata de archivos diferentes. 
 cmp, comm y diff: Informan si dos archivos son el mismo o diferentes y 
proporcionan información de dónde están o cómo son las diferencias. Se 
distinguen por la cantidad de información que proporcionan y la forma de 
visualizarla. 
 dircmp: Dice si los archivos de dos directorios son el mismo o diferentes. 
 
1.2.6. Cambio de información en archivos 
Los editores como vi o emacs son herramientas de propósito general que se 
utilizan para crear y modificar archivos de texto. Están diseñados para uso 
interactivo. 
A veces, se necesita modificar el contenido de un archivo añadiendo, 
eliminando o cambiando su información, pero no es necesario (o no se puede) 
hacerlo de forma interactiva. El sistema Unix proporciona diferentes herramientas 
para la edición no interactiva tales como tr y sed. 
 tr: Es un ejemplo de utilería del sistema Unix diseñada para realizar una 
función básica: cambia o traduce caracteres procedentes de la entrada de 
acuerdo a reglas que se le especifican. 
 sed: Proporciona un amplio rango de capacidades de edición, incluyendo casi 
todas las funciones de edición que se encuentran en los editores ed, vi o 
emacs, pero en forma no interactiva 
 
 
20 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
Sed 
ed es un editor muy poderoso (aunque un tanto hostil con el usuario), pero 
tiene un par de desventajas. La primera es que ed necesita cargar todo el archivo 
en la memoria simultáneamente, por lo que no sirve para archivos 
extremadamente largos. La segunda es que, aunque es posible, no es muy fácil 
especificarle a ed una secuencia de comandos que deben ejecutar 
automáticamente. Para ello existe sed, que significa Stream EDitor, es decir, 
editor de flujo. Los comandos de sed son similares a los de ed, pero con una 
diferencia principal: sed toma su entrada de un archivo, lo edita, pero no modifica 
el contenido del archivo original, sino que deja el resultado en la salida estándar. 
sed también puede tomar los datos de entrada de la entrada estándar, por lo que 
cae dentro de la clasificación de filtros. 
Debido a que es un editor de flujo, sed no es un editor interactivo, sino que 
todos los comandos a ejecutar son proporcionados desde el principio. 
Todos los comandos de sed son compilados antes de comenzar la ejecución. 
Una vez compilada, se extrae una línea de entrada y se copia en un espacio 
reservado llamado espacio de patrones. Sobre esta línea se aplican todos los 
comandos que le correspondan. Finalmente, la línea, posiblemente modificada, es 
extraída del espacio de patrones y colocada en la salida estándar, al tiempo que 
se lee la siguiente línea de entrada y se coloca en el espacio de patrones, para 
repetir el proceso hasta que las líneas de entrada se agoten. Algunos comandos 
pueden hacer uso del espacio de retención (hold space), que es una zona de 
almacenamiento temporal donde se pueden guardar algunas cosas para ser 
usadas posteriormente. 
 
 
1.2. UTILERÍAS DE UNIX 21 
 
Figura 1.8: Forma de funcionamiento del editor sed 
 
1.2.7. Monitorización de la entrada y salida 
Unix proporciona una herramienta que se puede utilizar para redireccionar la 
salida de un comando a un archivo y a la salida estándar. 
 tee: Descompone la entrada (estándar) en dos o más flujos de salida; uno se 
envía a la salida estándar, los otros se envían a los archivos que se 
especifiquen. Se utiliza frecuentemente para salvar un paso intermedio en una 
secuencia de comandos ejecutada en una segmentación encauzada, o para 
monitorizar un comando y asegurarse que hace lo que se quiere. 
 
1.2.8. Herramientas para visualizar fechas y hora 
El sistema Unix proporciona dos utilidades para obtener información sobre la 
fecha y hora. 
 cal: Imprime un calendario de cualquier mes o año. 
 date: Imprime la hora y fecha actuales del sistema en diferentes formatos 
 
1.2.9. awk 
awk es el comando más complejo de Unix en general, sobre todo porque no es 
un comando que realice una sola tarea, sino que es un lenguaje de programación 
hecho y derecho, pero con facilidades para descomposición de líneas y 
reconocimiento de patrones, proporcionando también capacidad de realizar 
 
 
22 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
cálculos aritméticos, y todo ello con una estructura sumamente similar al lenguaje 
C. 
awk esta especialmente diseñado para trabajar con archivos estructurados y 
patrones de texto. Dispone de características internas para descomponer líneas 
de entrada en campos y comparar estos campos con patrones que se 
especifiquen. Debido a estas posibilidades, resulta particularmente apropiado para 
trabajar con archivos que contienen información estructurada en campos, como 
inventarios, listas de correo y otros archivos de bases de datos simples. Muchos 
programas útiles awk solamente son de una línea de longitud, pero incluso un 
programa awk de una línea puede contarse el número de líneas de un archivo 
como wc, imprimir el primer campo de cada línea como cut, imprimir todas las 
líneas que contienen la palabra “services” como grep, intercambiar la posición de 
los campos tercero y cuarto de cada línea como join y paste o borrar el último 
campo de cada línea. Sin embargo, lo que es diferente para awk es ser un 
lenguaje de programación con estructuras de control, funciones y variables. 
 
Figura 1.9: Forma de funcionamiento de awk 
 
 
1.2. UTILERÍAS DE UNIX 23 
Historia de awk 
awk fue diseñado e implementado originalmente por Alfred AHO, Peter 
Weinberger y Brian Kernighan en 1977. El nombre del lenguaje, al contrario de 
los demás comandos de Unix, no viene de algún acrónimo de lo que hace el 
comando, si no que esta formado por las iniciales de los tres apellidos de sus 
autores. Se realizó como parte de un experimento para ver cómo las herramientas 
grep y sed podrían ser generalizadas para tratar con números al igual que con 
texto. A pesar de que fue ideado para escribir programas muy cortos, sus 
facilidades y características pronto atrajeron a usuarios que comenzaron a escribir 
programas considerablemente más largos. Esto ocasiono la necesidad de nuevas 
cosas que no se encontraban en el lenguaje original, de manera que se publicó 
una nueva versión grandemente mejorada en 1985. Una de las principales 
mejoras en esta nueva versión era la posibilidad para los usuarios de definir sus 
propias funciones, además de incluir muchas otras funciones intrínsecas y otras 
características adicionales que hicieron más fácil la escritura de programas más 
complejos. 
 
 
 
 
24 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 
 
 
 
1.3. LLAMADAS AL SISTEMA 25 
1.3. Llamadas al sistema 
1.3.1. El kernel 
El centro del sistema Unix es un programa conocido como el kernel o núcleo. 
A pesar de que nunca se tiene acceso directo a él su operación es primordial para 
el funcionamiento del sistema: administra la memoria, controla el acceso a los 
archivos, carga y ejecuta los programas ejecutables como los interpretes de 
comandosy, lo más importante, administra el uso del procesador sin el cual 
Unix sería capaz de realizar mas de una tarea a la vez. 
El kernel realiza todas estas tareas proporcionando una interfaz entre los 
programas que se está ejecutando bajo su control y el hardware de la 
computadora; esta interfaz, la interfaz de llamadas al sistema, aísla a los 
programas de las complejidades del hardware. Por ejemplo, cuando un programa 
que se esta ejecutando necesita abrir un archivo, lo hace a través de una llamada 
al sistema que le indica al kernel que habrá el archivo para ese programa. El 
kernel recibe y controla la petición y notifica si esta concluyó exitosamente o no. 
Para leer datos del archivo se requiere de otra llamada; el kernel determina si la 
petición es valida o no, y si lo es, el kernel lee el bloque de datos requerido y lo 
manda al programa. A diferencia de otros sistemas operativos (DOS), los 
programas en un sistema Unix no tienen acceso al hardware de la computadora. 
Todo lo que ellos “ven” son los servicios del kernel, proporcionadas por las 
llamadas al sistema. La interface de llamadas al sistema es un ejemplo de una API 
o interfaz de programación de aplicaciones. Las llamadas al sistema tienen 
parámetros estrictamente definidos, que permiten a una aplicación acceder a los 
recursos físicos de la computadora. 
 
1.3.2. Arquitectura del sistema Unix 
La arquitectura del sistema se basa en dos conceptos principales, los archivos 
y los procesos. El kernel esta pensado para facilitar el acceso al sistema de 
archivos y para el control de procesos. Los tres niveles en que se divide la 
arquitectura del sistema son: hardware, kernel y usuario. Las llamadas al sistema 
 
 
26 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
y su biblioteca relacionada representan la frontera entre los programas de usuario 
y el kernel. La biblioteca asociada a las llamadas al sistema es el medio por el cual 
se puede solicitar un servicio al kernel desde un programa en C. Esta biblioteca 
se enlaza por defecto al compilar cualquier programa en C y se encuentra en el 
archivo /usr/lib/libc. Los programas escritos en lenguaje ensamblador puede 
invocar directamente las llamadas al sistema sin necesidad de ninguna biblioteca. 
Las llamadas del sistema se ejecutan en modo kernel y para entrar en este 
modo hay que ejecutar una sentencia en modo máquina llamada trap (o 
interrupción de software). Es por esto que las llamadas al sistema se pueden 
invocar directamente desde ensamblador y no desde C. 
El kernel esta dividido en dos subsistemas principales: el subsistema de 
archivos y el subsistema de control de procesos. 
 
Figura 1.10: Diagrama a bloques del kernel 
 
El subsistema de archivos controla los recursos del sistema de archivos y 
tiene funciones como reservar espacio para los archivos, administrar el espacio 
libre, controlar el acceso a los archivos, permitir el intercambio de datos entre los 
archivos y el usuario, etc. Los procesos interaccionan con el subsistema de 
 
 
1.3. LLAMADAS AL SISTEMA 27 
archivos a través de unas llamadas especificas (open, read, write, chown, 
status, etc.) 
El subsistema de archivos se comunica con los dispositivos de 
almacenamiento secundario (discos duros, unidades de cinta, etc.) a través de los 
controladores de dispositivo. Los controladores de dispositivo se encargan de 
proporcionar el handshake o inicio de comunicación, entre el kernel y los 
periféricos. Se consideran dos tipos de archivos según su forma de acceso: 
dispositivos modo bloque y dispositivos modo carácter. El acceso a los 
dispositivos modo bloque se lleva a cabo con la intervención de buffers que 
mejoran la velocidad de transferencia. El acceso a dispositivos en modo carácter 
se lleva a cabo de forma directa, sin la intervención de buffers. Un mismo 
dispositivo físico puede ser manejado tanto en modo bloque como en modo 
carácter dependiendo de que controlador se utilice para acceder a él. 
El subsistema de control de procesos es el responsable de la planificación 
de los procesos (scheduler), su sincronización, comunicación entre los mismos 
(IP: Inter Process Comunication) y del control de la memoria principal. 
Algunas de las llamadas al sistema usadas para controlar procesos son: 
fork, exec, exit, wait, brk, signal, etc. 
El módulo de gestión o administración de memoria se encarga de controlar 
qué procesos están cargados en la memoria principal en cada instante. Si en un 
momento determinado no hay suficiente memoria principal para todos los 
procesos que la solicitan, el gestor de memoria debe recurrir a mecanismos de 
swapping para que todos los procesos tengan derecho a un tiempo mínimo de 
ocupación de la memoria RAM y se puedan ejecutar. 
El swapping consiste en llevar los procesos cuyo tiempo de ocupación de la 
memoria expira a una memoria secundaria (que es un área del disco conocida 
como swap y que se monta como un sistema de archivos aparte) y traer de esa 
memoria secundaria los procesos a los que se les asigna tiempo de ocupación de 
la memoria principal. Al módulo de administración de memoria se le conoce 
también como swapper. 
 
 
28 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
El planificador o scheduler se encarga de administrar el tiempo de CPU que 
tiene asignado cada proceso. El scheduler entra en ejecución cada cierto tiempo 
(conocido como quantum) y decide si el proceso actual tiene derecho a seguir 
ejecutándose (esto depende de su prioridad y de sus privilegios) o sí ha de 
cambiar de contexto, asignándole el CPU a otro proceso. 
El módulo de control de hardware es la parte del kernel encargada del 
manejo de las interrupciones y de la comunicación con la máquina. Los 
dispositivos pueden interrumpir al CPU mientras está ejecutando un proceso. Si la 
interrupción ocurre, el kernel debe reanudar la ejecución del proceso después de 
atender a la interrupción. Las interrupciones no son atendidas por procesos, sino 
por funciones especiales codificadas en el kernel, que son invocadas durante la 
ejecución de cualquier proceso. 
El kernel no es indivisible. Hay una pequeña cantidad de los subprocesos del 
kernel que son ejecutados por el kernel; estos son visibles en el listado de 
procesos cuando se ejecuta el comando ps -fea. Los controladores de 
dispositivos, por el contrario, se enlazan dentro del kernel, algunos pueden 
agregarse como módulos por el administrador. 
 
1.3.3. Visión general del sistema de archivos 
La representación interna de los archivos se hace mediante los i-nodos, los 
cuales contienen una descripción de la distribución en el disco de los datos del 
archivo y otra información como el propietario del archivo, los permisos de acceso 
y los tiempos de acceso. Todos los archivos tienen un i-nodo, aunque pueden 
tener varios nombres, pero todos apuntan al mismo i-nodo. Cada nombre se dice 
que es un enlace o liga. 
Un sistema de archivos consiste de una secuencia de bloques lógicos. El 
tamaño de estos bloques depende de la implementación, pero son múltiplos de 
512 bytes (512, 1024, 2048,...). Su tamaño es homogéneo dentro de un sistema 
de archivos, pero puede variar de un sistema de archivos a otro, aunque 
corresponda a la misma instalación. Con bloques lógicos grandes se aumenta la 
 
 
1.3. LLAMADAS AL SISTEMA 29 
eficacia de la transferencia de datos entre disco y memoria, ya que el kernel puede 
transferir más datos por operación con el disco y además con menos operaciones. 
Sin embargo, si un bloque lógico es muy grande la capacidad de almacenamiento 
efectiva puede bajar. 
Un sistema de archivos tiene la siguiente estructura: 
 El bloque de arranque (boot) que ocupa el comienzo del sistema de archivos, 
generalmente en el primer sector, y puede contener elcódigo de arranque de la 
máquina (bootstrap) que se lee para arrancar o inicializar el sistema operativo. 
Aunque sólo un bloque de arranque es necesario para inicializar el sistema, 
todos los sistemas de archivos que tenga la máquina tiene un bloque de 
arranque (aunque probablemente esté vacío). 
 El super bloque describe el estado de un sistema de archivos: qué tamaño 
tiene, cuántos archivos se pueden almacenar, dónde hay espacio libre en el 
sistema de archivos, y otro tipo de información. 
 La lista de i-nodos es una lista de los i-nodos que sigue al super bloque. Los 
administradores, cuando configuran el sistema de archivos, especifican el 
tamaño de la lista de i-nodos. Un i-nodo es el i-nodo raíz (root), es decir, el i-
nodo mediante el cuál es accesible el sistema de archivos cuando se ejecuta la 
llamada al sistema mount (que monta este sistema de archivos). 
 Los bloques de datos comienzan cuando termina la lista de i-nodos y contienen 
los datos de los archivos y los datos administrativos. Un bloque de datos sólo 
puede pertenecer a un único archivo del sistema de archivos. 
 
 
 
Figura 1.11: Estructura del sistema de archivos 
 
1.3.4. Estándares de Unix 
La reescritura, en 1973, de Unix en C, hizo que fuera “fácil de modificar” y 
portar, algo que no había sido posible antes con ningún sistema operativo. Como 
resultado, el Unix inicial divergió en una familia de sistemas operativos 
rápidamente. Los estándares de Unix fueron originalmente desarrollados para 
unificar los APIS de las diferentes ramas de la familia Unix. 
Los estándares de Unix que evolucionaron a partir de 1985 fueron muy 
exitosos en esto, tanto que aún funcionan como referencia para las modernas 
implementaciones de Unix. Los Unix modernos se apegan tanto a los estándares 
 
 
30 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
que es más conveniente para los desarrolladores confiar en las especificaciones 
como POSIX que en los manuales de la variante con la que están trabajando. 
La motivación original para el desarrollo de los estándares de Unix fué su 
división en dos corrientes la de AT&T y la de Berkeley. 
Las versiones Unix BSD 4.x son descendientes de la versión 7 de 1979. 
Después de la liberación de BSD 4.1 en 1980, la linea BSD rápidamente desarrolló 
reputación como una de las versiones mejor implementadas de Unix. Se 
incluyeron herramientas importantes como el editor vi, herramientas para 
administrar trabajos en background e interactivo y mejoras al sistema de señales. 
Por mucho la adición más importante fué el protocolo TCP/IP para red. 
Otra versión, sistema III (1981), se convirtió en la base de los desarrollos 
posteriores de AT&T. El sistema III redefinió la interfaz de terminales de una forma 
más clara y elegante pero completamente incompatible con la versión de Berkeley. 
La versión de enero de 1983, System V Release 1 incorporó algunas utilerías de 
BSD como vi. 
Cualquier versión de Unix proviene de alguna de estas dos corrientes System 
V o BSD, cada vendedor del sistema operativo adiciona sus propias 
modificaciones, para incrementar el rendimiento o agregar nuevas interfaces. 
Dado que la portabilidad de aplicaciones era crucial para los desarrolladores de 
aplicaciones, pronto fué claro que un nivel de estandarización era necesario para 
evitar que las diferencias fueran inmanejables. 
 
1.3.5. ANSI C 
Algo similar le ocurrió al lenguaje C. Por muchos años el libro El lenguaje 
de programación C, de Brian W. Kernigan y Dennis M. Ritchie, fué el estándar 
de referencia por defecto para el lenguaje. Este libro tiene una buena 
introducción al lenguaje, pero no fué pensado como una especificación formal 
del mismo. 
En 1983, C se había extendido más allá del sistema Unix para ser usado 
en muchas plataformas diferentes, y fué rápidamente ganando popularidad. 
 
 
1.3. LLAMADAS AL SISTEMA 31 
Fué el momento para crear un estándar independiente de la plataforma, de 
manera que no se fragmentara en varios dialectos incompatibles. 
ANSI (American National Standards Institute) publicó un estándar formal 
para el lenguaje 1989. El comité que escribió el estándar hizo un excelente 
trabajo, y el estándar fué rápidamente aceptado por casi todos los que 
usaban el lenguaje. El estándar original de ANSI fué oficialmente llamado 
ANS X3.159-1989, pero es comúnmente llamado como el estándar ANSI C, y 
el lenguaje por él definido como ANSI C. 
En 1990, un comité del ISO (International Standards Organization) adoptó 
el estándar de ANSI C, con algunas modificaciones, como el estándar 
Internacional conocido como ISO / IEC 9899:1990. ANSI adoptó, entonces, 
este estándar como reemplazo al ANS X3.159-1989. Sin embargo, lo más 
común es referirse al estándar como ANSI C. 
 
1.3.6. POSIX 
En 1980 se formó una organización denominada /usr/group, con la 
intención de estandarizar las interfaces a nivel de usuario con el fin de facilitar 
la portabilidad de aplicaciones. 
En 1984 llegaron a un acuerdo, y su trabajo fué utilizado por el comité 
ANSI X3J11, el mismo que estaba trabajando en la estandarización del 
lenguaje C. Como el número de versiones de Unix comenzó a incrementarse, 
la divergencia entre éstas aumentaba, y el estándar del /usr/group se volvió 
menos efectivo. Esto condujo a la formación del Portable Operating System 
Interface for Computing Environments (POSIX) en 1985 el cuál utilizó el 
estándar de /usr/group como su documento base de trabajo. Como nota 
curiosa, el nombre POSIX fue propuesto por Richard Stallman, fundador de la 
Free Software Foundation (FSF). 
El estándar producido por este grupo, POSIX 1003.1-1988 se convirtió en 
el estándar más reconocido en la industria Unix y está disponible en otras 
plataformas no-Unix. El estándar inicial fue revisado durante los siguientes 
 
 
32 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
tres años y adoptado por el IEEE (Institute of Electrical and Electronics 
Engineers) para ser el estándar IEEE 1003.1-1990 comúnmente conocido 
como POSIX.1 o simplemente estándar POSIX. En 1989 el grupo /usr/group 
cambió su nombre a Uniforum. 
Estándar Fecha Descripción 
POSIX.1 
POSIX.1b 
POSIX.1c 
POSIX.2 
POSIX.3 
POSIX.3.1 
POSIX.4 
POSIX.5 
POSIX.6 
POSIX.7 
POSIX.7.1 
POSIX.7.2 
POSIX.7.3 
POSIX.8 
POSIX.9 
POSIX.12 
1990 
1993 
1995 
1992 
1991 
1992 
1993 
1992 
en desarrollo 
en desarrollo 
en desarrollo 
en desarrollo 
en desarrollo 
en desarrollo 
1992 
en desarrollo 
Interfaz del sistema para programas de aplicación (Lenguaje C)
Rectificación 1 del API: Extensión del tiempo real 
Rectificación 2 del API: Extensión de hilos de control 
Intérprete de comandos y utilerías 
Métodos de prueba para apego a POSIX 
Métodos de prueba para apego a POSIX.1 
Ahora llamado POSIX.1b 
POSIX.1 (Lenguaje ADA) 
Seguridad 
Administración del sistema 
Administración de impresión 
Instalación y administración de software 
Administración de usuarios/grupos 
Acceso transparente a archivos 
POSIX.1 (Lenguaje FORTRAN) 
Servicios de red 
 
Tabla 1.4: Estándares POSIX 
 
Cualquier programador en Unix debe apegarse a los estándares cuando 
desee que su aplicación sea compatible con la mayoría de las versiones de 
Unix. Como mínimo, las interfaces POSIX son soportadas por casi todos los 
sistemas operativos, Unix y no-Unix. 
 
 
1.3. LLAMADAS AL SISTEMA 33 
1.3.7. Sockets 
El modelo cliente - servidor 
La mayoría de la comunicación entre procesos utiliza el modelo cliente 
servidor. Estos modelos se refieren a los procesos que se comunicarán entre sí. 
Uno de los procesos, el cliente, se conecta con el otro proceso, el servidor, para 
hacer típicamente una petición de información. Una buena analogía es una 
persona que hace una llamada telefónica a otra persona. Es el cliente quien 
necesita saber de la existenciadel servidor y de su dirección, pero el servidor no 
necesita saber la dirección (o aún la existencia) del cliente antes de que la 
conexión sea establecida. También, una vez que se establece una conexión, 
ambos procesos pueden enviar y recibir información. 
Las llamadas al sistema para establecer una conexión son algo diferentes para 
el cliente y el servidor, pero ambas implican la construcción básica de un socket. 
Un socket es un extremo de un canal de comunicación entre procesos. Cada uno 
de los procesos establece su propio socket. 
Los pasos implicados para establecer un socket en el lado del cliente son: 
 Crear un socket con la llamada al sistema socket. 
 Conectar el socket con la dirección del servidor usando la llamada al sistema 
connect(). 
 Envía y recibe los datos. Hay distintas maneras de hacer esto, pero lo más 
simple es utilizar las llamadas al sistema read() y write(). 
 
Los pasos implicados para establecer un socket en el lado del servidor son: 
 Crear un socket con la llamada al sistema socket. 
 Asociar el socket a una dirección usando la llamada al sistema bind(). Para un 
socket del servidor en internet, una dirección consiste en un número de acceso 
en el servidor. 
 Espera a escuchar las conexiones con la llamada del sistema listen(). 
 Acepta una conexión con la llamada al sistema accept(). Esta llamada es 
bloqueable hasta que un cliente se conecte con el servidor. 
 Enviar y recibir datos. 
 
 
34 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 
 
Figura 1.12: Ejemplo cliente-servidor TCP simple 
Tipos de Socket 
Cuando se crea un socket, el programa tiene que especificar el dominio de la 
dirección y el tipo de socket. Dos procesos pueden comunicarse mutuamente sí 
sus sockets son del mismo tipo y están en el mismo dominio. Hay dos dominios 
extensamente usados en la dirección, el dominio de Unix, en el cual dos procesos 
que comparten un sistema de archivos común se comunican, y el dominio de 
Internet, en el cual dos procesos que corren en cualquier host en internet se 
comunican. Cada uno de éstos tiene su propia dirección. La dirección de un socket 
en el dominio de Unix es una cadena de caracteres que es básicamente una 
entrada en el sistema de archivos. 
Hay dos tipos de sockets usualmente empleados, Sockets Streams y Sockets 
Datagrama. Los socket streams tratan las comunicaciones como un flujo continuo 
de caracteres, mientras que los sockets datagrama tienen que leer mensajes 
enteros inmediatamente. Cada uno utiliza su propio protocolo de comunicación. 
 
 
1.3. LLAMADAS AL SISTEMA 35 
Los sockets streams utilizan el TCP (transmisión Control Protocol), que es un 
protocolo orientado a la conexión confiable, y los sockets datagram utilizan un 
UDP (protocol del datagrama de Unix), que es no fiable y es no orientado a la 
conexión. 
 
 
Figura 1.13: Tipos de socket 
 
 
 
36 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
 
 
 
 
 
1.4. ADMINISTRACIÓN BÁSICA DE UNIX 37 
1.4. Administración básica de Unix 
Las grandes empresas y organizaciones dependen hoy día de cada vez más 
de sus recursos de computación y de cómo éstos son administrados para 
adecuarlos a sus objetivos o metas. El gran incremento de las redes distribuidas, 
con sus equipos clientes y servidores, ha creado una gran demanda de un nuevo 
perfil laboral: el llamado administrador de sistemas. 
La administración de sistemas abarca un campo muy amplio. Los mejores 
administradores de sistema suelen ser bastante generalistas, tanto teóricamente 
como prácticamente. Esto es, pueden enfrentarse a tareas como: realizar 
cableados de instalaciones; instalar sistemas operativos o software de 
aplicaciones; corregir problemas y errores en los sistemas tanto hardware como 
software; capacitar a los usuarios, ofrecer best practices2 o técnicas para mejorar 
la productividad en diferentes áreas; evaluar económicamente compras de 
equipamiento de hardware y software; automatizar un gran número de tareas 
comunes, e incrementar el rendimiento general del trabajo en su organización. 
La relación con los usuarios finales de la organización puede establecerse de 
diferentes maneras: o bien mediante la capacitación de usuarios o bien por ayuda 
directa en el caso de presentarse problemas. El administrador es la persona 
encargada de que las tecnologías utilizadas por los usuarios funcionen 
adecuadamente, es decir, que los sistemas cumplan las perspectivas de los 
usuarios, así como las tareas que éstos quieran realizar. En general, los 
administradores de sistemas permiten a la gente explotar las computadoras a tal 
nivel que sus efectos se reflejan en toda una organización. 
Hace años, y aún actualmente, en muchas empresas no hay una perspectiva 
clara del papel del administrador. En los inicios de la informática en la empresa, el 
administrador era visto en un principio como una persona “experta” en 
computación que se encargaba de poner a punto máquinas y que vigilaba o las 
reparaba en caso de problemas. Normalmente, era una especie de informático 
multidisciplinario que tenía que solucionar los problemas que fueran apareciendo. 
 
2 Guías y consejos sobre la mejor manera de hacer las cosas. 
 
 
38 CAPÍTULO 1. ADMINISTRACIÓN DE SISTEMAS 
En este sentido, nos situábamos de alguna manera en la prehistoria de la 
administración de sistemas. Hoy en día, en la época de Internet y de los servicios 
distribuidos, un administrador de sistemas es un profesional (con dedicación 
propia y exclusiva) que proporciona servicios de software y hardware de sistemas. 
Desde este enfoque, los administradores de sistemas Unix no solo son los 
responsables de una operación exitosa del sistema (hardware, sistemas 
operativos y aplicaciones), sino que también son los responsables de proporcionar 
a los usuarios la capacitación y cultura necesaria para trabajar en un ambiente 
seguro y eficiente. 
El administrador de sistemas es la persona responsable de configurar, mantener y 
actualizar el sistema o conjunto de sistemas que forman una red, cuidando el 
funcionamiento del software, hardware y periféricos de forma que estén disponibles para 
ser utilizados para los usuarios. 
 
1.4.1. Características del administrador Unix 
Actualmente, los administradores necesitan tener unos conocimientos 
generales (teóricos y prácticos) de áreas muy diversas, desde tecnologías de 
redes, sistemas operativos, aplicaciones de ámbitos diversos, programación 
básica en una amplia variedad de lenguajes de programación, conocimientos 
amplios de hardware, seguridad, etc. 
En una organización más pequeña, varias o todas las tareas pueden estar 
asignadas a uno o pocos administradores. Los administradores de sistemas Unix 
serían una parte de estos administradores. Normalmente, su plataforma de trabajo 
es Unix, y requiere de bastantes elementos específicos que hacen este trabajo 
único. Unix es un sistema operativo abierto y muy potente, y, como cualquier 
sistema software, requiere de cierto nivel de adecuación, configuración y 
mantenimiento en las tareas para las que vaya a ser usado. Configurar y mantener 
un sistema operativo es una tarea seria, y en el caso de Unix puede llegar a ser 
bastante frustrante. 
Algunas áreas importantes a tratar por el administrador son: 
 
 
1.4. ADMINISTRACIÓN BÁSICA DE UNIX 39 
 Que el sistema sea muy potente también indica que habrá bastantes 
posibilidades de adaptarlo (configurarlo) a las tareas que queremos hacer. 
Habrá que evaluar las posibilidades que se nos ofrecen y cuán adecuadas son 
para nuestro objetivo final. 
 Un sistema abierto, que nos ofrecerá actualizaciones