Sistema Operativo UNIX -...

INSTITUTO TECNOLOGICO DE ZACATECAS

SISTEMA OPERATIVO UNIX

Ingeniería en Sistemas Computacionales

Apuntes realizados por:I.S.C. Roberto Solís Robles


CONTENIDO

1. Fundamentos de UNIX................................................................................................11.1. Evolución de UNIX.................................................................................................11.2. Tipos de UNIX........................................................................................................21.3. Características de un sistema UNIX.........................................................................31.4. Componentes Principales de un Sistema UNIX ........................................................31.5. Ventajas del sistema UNIX......................................................................................41.6. Acceso al sistema UNIX..........................................................................................41.7. Configuración del Entorno.......................................................................................6

2. Sistema de Archivos (Filesystem) ................................................................................92.1. Tipos de archivos ..................................................................................................122.2. Permisos de archivos .............................................................................................142.3. Manipulación de archivos ......................................................................................192.4. Impresión de archivos............................................................................................262.5. Comandos para desplegar mensajes .......................................................................28

3. Manejo del shell ........................................................................................................303.1. ¿Qué es un shell? ...................................................................................................303.2. El Shell Bourne .....................................................................................................303.3. Comandos para el Control de Procesos..................................................................343.4. Shell de C..............................................................................................................383.5. El Shell Korn.........................................................................................................40

4. Edición de textos y manejo de filtros .........................................................................424.1. Editor ed ...............................................................................................................42

4.1.1. Comandos básicos .........................................................................................424.1.2. Formas de indicar la dirección de las líneas.....................................................434.1.3. Caracteres Especiales para Búsquedas y Reemplazos .....................................434.1.4. Comandos para realizar búsquedas.................................................................434.1.5. Comandos para Realizar Reemplazos .............................................................444.1.6. Comandos para Realizar Movimientos de Texto.............................................44

4.2. Editor vi ................................................................................................................454.2.1. Entrando a vi .................................................................................................454.2.2. Movimiento en vi...........................................................................................454.2.3. Inserción de texto ..........................................................................................464.2.4. Eliminación de texto ......................................................................................464.2.5. Comandos de búsqueda y reemplazo ..............................................................474.2.6. Otros Comandos............................................................................................474.2.7. Para guardar y salir de vi................................................................................474.2.8. Algunas Opciones de vi..................................................................................48

4.3. Archivos utilizados por los shell para su inicialización............................................48

4.4. Comunicaciones en UNIX .....................................................................................494.4.1. Comando mail................................................................................................494.4.2. Comando finger .............................................................................................504.4.3. Comando write ..............................................................................................514.4.4. Comando talk ................................................................................................51

4.5. Filtros....................................................................................................................524.5.1. Comando cut .................................................................................................524.5.2. Comando paste ..............................................................................................544.5.3. Comando sort ................................................................................................544.5.4. Comando diff.................................................................................................564.5.5. Comando grep ...............................................................................................574.5.6. Comando uniq ...............................................................................................584.5.7. Comando sed.................................................................................................594.5.8. Comando awk................................................................................................61

5. PROGRAMACION DEL SHELL BOURNE ............................................................665.1. Ordenes multilínea .................................................................................................665.2. Documentos incluidos (Here Documents) ..............................................................675.3. Sustitución de comandos .......................................................................................675.4. Comentarios en un shell script ...............................................................................675.5. Creación y ejecución de un shell script ...................................................................685.6. Variables utilizadas en los shell script.....................................................................705.7. La sentencia if .......................................................................................................715.8. La sentencia test ....................................................................................................725.9. Sentencia exit ........................................................................................................745.10. Sentencia expr ...................................................................................................745.11. Sentencia case ...................................................................................................755.12. Sentencia for......................................................................................................765.13. Sentencia while..................................................................................................765.14. Sentencia until ...................................................................................................775.15. Funciones ..........................................................................................................775.16. Sentencia trap....................................................................................................775.17. Depuración de shell scripts.................................................................................78

6. CONTROL DE PROCESOS.....................................................................................796.1. Introducción..........................................................................................................796.2. Componentes de un proceso ..................................................................................806.3. Ciclo de vida de un proceso ...................................................................................816.4. El proceso login.....................................................................................................836.5. Señales ..................................................................................................................866.6. Estados de un proceso ...........................................................................................876.7. Comandos para el manejo de procesos...................................................................88

6.7.1. Comando kill .................................................................................................886.7.2. Comandos nice y renice .................................................................................886.7.3. Comando ps...................................................................................................896.7.4. Comando top.................................................................................................916.7.5. Comando hup ................................................................................................92

7. INICIALIZACIÓN Y TERMINACIÓN DEL SISTEMA..........................................937.1. Introducción..........................................................................................................937.2. Pasos en el Proceso de Booteo ..............................................................................937.3. Scripts de inicio tipo ATT......................................................................................957.4. Inicialización en LINUX........................................................................................977.5. Inicialización en Solaris .......................................................................................1057.6. Reinicialización y terminación del sistema ............................................................109

Sistema Operativo UNIX

I.S.C. Roberto Solís Robles 1


Objetivo: Obtener los conocimientos necesarios para aprovechar al máximo las capacidades delsistema operativo multiusuario mas usado en el mundo al descubrir la forma en que este manejalos archivos, sus comandos y herramientas.

1. Fundamentos de UNIX

1.1. Evolución de UNIX

UNIX se originó como un proyecto de investigación en los Laboratorios Bell deAT&T en 1969 a partir de otro sistema denominado MULTICS. La primera versión sedenominó UNICS (Uniplexed Operating and Computing System). En 1973, Dennis Ritchie yKen Thompson reescriben el kernel de UNIX en lenguaje C (inicialmente se escribió enensamblador), y fue liberado como la versión 5 disponible solo a las universidades. La sextaedición, conocida comúnmente como V6 fue liberada en 1976 y estuvo disponiblegratuitamente para las universidades. La versión 7 fue liberada 2 años después; fue laprimera versión en ser completamente distribuida (principalmente a universidades ylaboratorios de investigación) y se convirtió en la base para la mayoría de las posterioresversiones de UNIX. Costaba $100 a las universidades y $21000 a todos los demás.

Después de la versión 7, AT&T creó su Grupo de Soporte de UNIX (USG), paraconvertir a UNIX en un producto comercial. Los Laboratorios Bell y USG continuaron eldesarrollo de UNIX, pero los esfuerzos de ambos grupos divergieron. Las liberaciones deUSG, System III y System V, fueron ampliamente distribuidas y tuvieron un impactoproporcionalmente mayor sobre los sistemas modernos.

En 1992, AT& vendió sus operaciones de UNIX a Novell, que convirtió al System Ven un producto no muy popular denominado UnixWare. Debido a que la mayoría de lasversiones de UNIX se derivan del código de AT&T, Novell también recibe una regalía de lasventas de otros fabricantes.

El UNIX de Berkeley empezó en 1979, cuando el Computer Systems ResearchGroup (CSRG) compró una licencia del código de V& de AT&T en la Universidad deCalifornia en Berkeley. Las liberaciones de Berkeley (denominadas BSD, por BerkeleySoftware Distribution) empezaron en 1979 con 1BSD y culminó en 1993 con el 4.4BSD.

Ahora bien, debido a que BSD estaba basado en el UNIX de AT&T y debía pagarregalías las cuales aunque inicialmente eran bajas para universidades aumentarongrandemente al convertirse en un éxito comercial, decidió remover el código de AT&T delBSD, pero en el proceso Berkeley dejo de recibir fondos para la investigación de sistemasoperativos y el CSRG fue desintegrado. Antes de su desintegración total liberón su segundacolección de código no AT&T conocido como Net/2. Esta versión fue tomada por Berkeley



Software Design, Inc. (BSDI), llenó los huecos y la empezó a vender como unaimplantación real de UNIX.

En los 80’s, los fabricantes de estaciones de trabajo sacaron sus propias versiones de UNIX.Típicamente, un fabricante empieza con un sistema AT&T o BSD, y procede a desarrollarloindependientemente. Algunos fabricantes no querían comprometerse a un solo sabor ysoportaban ambos, o desarrollaban híbridos que combinaban ambos conjuntos decaracterísticas.

De repente empezó una proliferación de variantes de UNIX, cada una soportada porunos cuantos fabricantes. DEC es el único fabricante que descontinuó el desarrollo de supropia versión de UNIX en favor de un estándar.

1.2. Tipos de UNIX

Usaremos las abreviaciones ATT y BSD para identificar versiones de UNIX comomás parecidos a la versión de ATT o a la de Berkeley respectivamente.

• Solaris 2.X de SUN es un sistema ATT con muchas extensiones.• SunOS, es un sistema operativo más viejo de SUN, es BSD, también con muchas

extensiones



• OSF/1 es el sistema de DEC, el cual está basado en un sistema operativodenominado Mach desarrollado en la Universidad de Carnegie-Mellon, el cual asu vez está derivado de BSD

• IRIX, es un sistema de Silicon Graphics, similar a ATT• SCO, Santa Cruz Operation, es una versión de UNIX para PC basada en una

versión vieja de AT&T• HP-UX es un sistema de Hewlett Packard, el cual es basado en ATT• Linux, es un sistema UNIX gratuito disponible para PC. Se basa en BSD.En este curso veremos el uso de Solaris 2.5.1 y Linux.

1.3. Características de un sistema UNIX

• Interactivo. Mantiene comunicación constante con el usuario• Multitarea. Permite atender varios procesos simultáneamente (background), además

permite la ejecución de procesos en lote (batch) y procesos diferidos.• Multiusuario. Permite atender a varios usuarios simultáneamente.• Tuberías (Pipes). Permite intercomunicar procesos subsecuentes, por lo que se reduce la

necesidad de crear archivos de paso y manipulaciones intermedias.

1.4. Componentes Principales de un Sistema UNIX

• Kernel. Es la parte del sistema que administra los recursos de la de la computadora.Supervisa todos los dispositivos: discos, cintas, impresoras, terminales, líneas decomunicación, etc. Controla la ejecución de procesos, asigna espacio de memoria, etc.

• Sistema de Archivos. La estructura de datos que provee los medios para organizar la

información en forma compleja y permitir al usuario manejarlos en forma sencilla.• Interprete de comandos (Shell). Es la parte que interactúa con el usuario, traduce sus

requerimientos en acciones del KERNEL.• Comandos. Son los nombres de los programas que se desea ejecutar, los paquetes de

programas se llaman utilerías. Existen utilerías para programación, procesamiento detexto, comunicaciones, administración de información, entre otros.

Las interacción entre estos componente se muestra a continuación:



1.5. Ventajas del sistema UNIX

• Capacidad de acceso en red. UNIX ya trae incluida la capacidad de conectarse en redsin necesidad de utilizar software adicional como en el caso de otros sistemas tales comoWindows, lo que lo hace ideal para cosas tales como correo electrónico mundial eInternet.

• Portable. UNIX fue escrito en un lenguaje independiente de la máquina (C) lo que lepermite correr en una variedad de hardware.

• Flexible. UNIX incluye una variedad de comandos que le permiten adaptarse a cualquiersistema y los cuales pueden ser utilizados para construir otros comandos mas complejosya que están probados al 100%.

1.6. Acceso al sistema UNIX

Debido a que UNIX es un sistema operativo multiusuario, éste debe ser capaz dehacer una distinción entre los diversos usuarios, por lo cual se requiere de un nombre decuenta (login) y una contraseña (password) para poder entrar al sistema.

UNIX utiliza su login y su password para establecer una sesión a su nombre ydeterminar los privilegios que tiene.

Se debe acceder desde una terminal del sistema o bien, mediante un programa quesimule una terminal remota (TELNET) en una computadora conectada a la red en la que seencuentre el sistema UNIX. Al entrar al sistema UNIX despliega un indicador en el cual seda una descripción breve del sistema y se pide su login y su password (al teclear el passwordno se mostrará en pantalla lo tecleado:

UNIX(r) System V Release 4.0 (seit)

login: rsolisPassword:



Una vez dados un login y password válidos se inicia una sesión (se ejecuta el shell ointerprete de comandos que se le haya asignado) en la cual todos los comandos que se dense verificarán si pueden ser ejecutados por usted de acuerdo a su privilegio y se procederáde acuerdo a ello. Asimismo, cada vez que se quiera acceder a un archivo, solamente sepodrá hacer si se le está permitido. Al iniciarse la sesión se le indicará si ha recibido algúncorreo, la ultima vez que entro al sistema , un mensaje de bienvenida y se mostrará elindicador del sistema que denota que esta a la espera de un comando (estos dos últimosvarían de sistema a sistema).

Last login: Fri May 29 09:21:30 from mapaches.itz.edu

!!!!!! B I E N V E N I D O S A S E I T !!!!!!seit.itz.edu.mx

SERVIDOR UNIX DEL INSTITUTO TECNOLOGICO DE ZACATECAS

Si tienes cuenta en este servidor puedes publicar tu pagina en Internet!!!

You have mail. seit$

Ahora bien, ¿quién se encarga de asignar las cuentas y los passwords? Existe unusuario el cual no tiene ninguna restricción en cuanto al uso del sistema y que puede accedera absolutamente todo, el administrador del sistema, el cual tiene normalmente como nombrede login root. Entonces, cuando alguien desea obtener una cuenta para el uso de un sistemaUNIX debe ponerse en contacto con el administrador del sistema. Cabe hacer notar tambiénque cada usuario debe pertenecer por lo menos a un grupo, entendiendo por grupo unconjunto de usuarios que comparten los mismos privilegios. Como vamos a ver másadelante, se manejan privilegios a 3 niveles: usuario, grupo y otros.

Una vez en la sesión es posible cambiar el password dando el comando passwd.

Hemos estado hablando de que una vez abierta una sesión se pueden dar comandos,pero ¿cómo se indica que se quiere ejecutar un comando?. Bueno, la forma básica de uncomando en UNIX es la siguiente:

comando opciones argumento(s)

donde comando es el nombre del comando o programa que se quiere ejecutar, las opcionesmodifican la forma en que se ejecutará el comando (normalmente precedidas por un -) y losargumentos especifican los datos sobre los cuales el comando va a operar (en algunoscomandos el argumento es obligatorio y en otros es opcional).



Cuando se incluyen varias opciones y/o argumentos éstos van separados por espacio,si se desea pasar un argumento que contiene espacios éste debe estar entre comillas.

Por ejemplo, el comando ls sirve para mostrar el contenido del directorio (lo quehace dir en el DOS). Ahora bien si damos ls por si solo sólo muestra el nombre de losarchivos, pero si damos ls -l se muestran todos los datos del archivo (los cuales analizaremosdespués) y si damos por ejemplo como argumento el nombre de un archivo solo semostraran los datos de ese archivo, por ejemplo, ls -l archivo.

Ahora bien, cuando damos un comando el shell lo busca en unos directoriospredeterminados, una vez encontrado lo carga en memoria y lo ejecuta.

Un comando que puede ser muy útil es man, el cual nos permite consultar el manualde algún comando en particular, su sintáxis es la siguiente:

man comando

Una vez que no necesitemos la sesión damos el comando exit para terminarla.

1.7. Configuración del Entorno

El entorno es un conjunto de características que determinan la forma en que susesión trabaja, por ejemplo, la forma del indicador, en que directorios buscará los comandos,en donde se encuentra el archivo del correo electrónico, etc.

Su entorno de trabajo se define cuando se entra a una sesión. Este entorno seestablece usando los valores que el shell encuentra en archivos de inicialización que lee aliniciarse.

Se puede cambiar el entorno de trabajo editando estos archivos dándole nuevosvalores a las variables o pueden cambiarse sin necesidad de modificar los archivos. Cadashell maneja sus archivos de inicialización de manera diferente. Por ahora veamos los delBourne Shell.



Para ver la lista de variables de entorno se da el comando set.

$ setHOME=/home/rsolisHOSTNAME=seitHZ=100IFS=LOGNAME=rsolisMAIL=/var/mail/rsolisMAILCHECK=600OPTIND=1PATH=/usr/bin:/usr/ucb:/usr/ccs/bin:/etc:/usr/local/jdk1.1.4/bin:.PS1=seit$PS2=>PVM_ARCH=SUN4SOL2PVM_DPATH=/usr/bin/pvm3/lib/pvmdPVM_ROOT=/usr/bin/pvm3SHELL=/bin/shTERM=vt100TZ=Mexico/General

Para cambiar el valor de una variable se hace de la siguiente manera:variable=valor

No debe haber espacios entre la variable y el =, ni entre el = y el valor.

Por ejemplo, la variable PS1 guarda la forma del indicador que se puede ver que es:seit$y podemos cambiarlo dándole un nuevo valor a la variable PS1 de la siguiente forma:PS1=”Tu diras! $”

Esto daría como resultado que el indicador quedara así:Tu diras $

O bien, se pueden usar los valores de las variables, por ejemplo, si quisieramos que en elindicador saliera nuestro login haríamos lo siguiente:PS1=”$LOGNAME $”lo cual dejaría al indicador de la siguiente manera:rsolis $

Note que cuando queremos usar el valor de otra variable de entorno debemos preceder alnombre con el carácter $.

A continuación se listan algunas de las variables de entorno más comúnmente utilizadas y susignificado:



Variable SignificadoHOME Directorio de trabajo asignado al usuarioHOSTNAME Nombre de la máquina que ejecuta el UNIXLOGNAME Nombre del usuario (login)MAIL Archivo en el que se almacenan los correos electrónicosPS1 Forma del indicadorSHELL Nombre del shell que se está ejecutandoTERM Tipo de terminal usadaTZ Zona horariaPATH Ruta en la cual se buscarán los comandos



2. Sistema de Archivos (Filesystem)

La definición más simple de un sistema de archivos es una estructura de datos o unacolección de archivos. En Unix, un sistema de archivos se puede referir a dos cosas muydistintas: el árbol de directorios o el arreglo de los archivos en las particiones del disco. Esteúltimo se puede ver como el sistema de archivos físico ya que tienen una localidad físicatangible. El filesystem se divide primero en particiones del disco. El tamaño de la particióndetermina el número de bloques que el filesystem usa. Cada filesystem usa un superbloque,inodos y bloques de datos. El superbloque mantiene la información de control del sistema dearchivos. Los inodos contienen información similar para los archivos individuales. Losbloques de datos mantienen los datos, la información de los archivos. Cabe hacer notar queUNIX trata a todo (discos, cintas, monitos, modem, etc) como si fueran archivos. Lasiguiente figura muestra las tres partes en las que se divide un filesystem físico.

El filesystem lógico se refiere a una jerarquía de directorios conectados que estáncompuestos de todos los archivos (o particiones de discos) que son accesibles al usuario. Elfilesystem de UNIX se arregla en un árbol o pirámide invertida, donde los archivos estánlógicamente contenidos en el directorio raíz (el directorio de más alto nivel y representadopor /).

Hay pequeñas diferencias en el arreglo de los directorios entre los diversos tipos deUNIX. Sin embargo, la estructura general es básicamente la misma. A continuación seincluyen figuras que muestran la distribución de los sistemas ATT y BSD. Por favor noteque aunque sólo una rama del árbol se muestra para cada nivel, cada uno de los directoriospotencialmente contiene subdirectorios. Primero se muestra para ATT y luego BSD:



La segunda muestra la estructura en BSD:



Todos los directorios incluyen al menos dos entradas: . y .. (pronunciadas “punto” y“punto punto”). La entrada . se refiere al directorio mismo, y la entrada .. se refiere aldirectorio padre. El filesystem, como ya se mencionó, tiene un directorio de más alto niveldenominado el directorio raíz y se distingue de los otros en que su padre es el mismo.

Las entradas en el directorio se denominan inodos, los directorios asocian un nombrede archivo con un número de inodo, el cual es usado para localizar el área de datos delarchivo. Solo estas dos cosas se almacenan en el directorio. El número de entradas deldirectorio que pueden contener el mismo número de inodo no está restringido: el mismoarchivo físico puede estar listado en más de un solo directorio; puede ser tambiénrepresentado por dos ó más nombres en el mismo directorio.

Los directorios que se deben cruzar para llegar a un archivo particular combinadoscon el nombre del propio archivo forman la ruta, la cual identifica de manera única a unarchivo. Las rutas pueden ser absolutas (por ejemplo, /tmp/archivo) o relativas (bin/pine).Las rutas relativas se interpretan empezando en el directorio actual. Se puede ver que se usael símbolo / (slash) para separar los directorios

El archivo de directorios de UNIX puede ser arbitrariamente profundo. Sin embargo,cada directorio debe tener un nombre menor de 256 caracteres de longitud y no se puedeusar más de 1023 caracteres para la ruta. Para accesar un archivo cuya ruta absoluta esmayor que esta longitud, se deben dar pasos intermedios, es decir, primero llegar a unsubdirectorio intermedio y de ahi usar una ruta relativa.

Veamos ahora para que se usan algunos de los directorios estándar de UNIX:• /bin. Contiene los comandos y utilerías ejecutables, contiene los programas necesarios

para reconstruir el sistema, desde respaldos hasta la instalación del sistema.• /dev. Se reserva para archivos especiales de carácter y de bloque que sirven para el

manejo de los diversos dispositivos del sistema (discos duros, flexibles, unidades de cinta,CD-ROM, etc).

• /etc. Contiene los archivos de configuración necesarios para la operación, administracióny mantenimiento del sistema.

• /lib. Contiene las librerías para el compilador de C.• /tmp. Proporciona espacio para archivos temporales creados por comandos, aunque

también los usuarios pueden almacenar información ahí.• /usr. Ahí se colocan los archivos que no se requieren para la operación mínima del

sistema.• /usr/bin. Contiene todos los ejecutables no esenciales y disponibles a los usuarios.• /usr/man. Contiene los manuales en línea.• /var. Contienen la información administrativa.• /proc. Contiene imagenes de todos los procesos en ejecución.

Los comandos que se usan para el manejo de directorios son:• cd Para cambiar de directorio• mkdir Para crear un directorio



• rmdir Para eliminar un directorio. Hay que notar que para eliminar un directorioeste debe estar vacío.

• pwd Muestra el directorio actual

2.1. Tipos de archivos

Existen 6 tipos de archivos UNIX:• Regulares. Son sólo una colección de bytes. Es el tipo más común de archivo. Un

archivo regular puede ser un programa ejecutable, una imagen GIF, un código fuente deC o cualquier otra cosa que pueda ser posteriormente recuperada.

• Directorios. Puede contener cualquier tipo de archivo.• Especiales de carácter.• Especiales de bloque. Estos dos permiten a los programas en UNIX comunicarse con el

hardware y periféricos del sistema. Cuando el kernel es configurado, los módulos queconocen como comunicarse con cada uno de los dispositivos del sistema son enlazados.El módulo para un dispositivo particular, denominado manejador de dispositivo, se ocupade todos los detalles. Los de carácter permiten que sus manejadores asociados realicen supropio manejo de buffer de entrada y salida. Los de bloque son usados por losmanejadores para manejar la E/S en grupos grandes y quieren que el kernel se encarguede los buffers. Algunos tipos de hardware pueden ser representados por ambos tipos,tales como los discos duros y cintas. Puede haber más de una instancia de cada tipo dedispositivo. Estos archivos se caracterizan por 2 números, llamados número mayor ymenor de dispositivo. El número mayor le dice al kernel a que manejador se refiere elarchivo y el menor le dice a que unidad física dirigirse. Por ejemplo, en SunOS unnúmero mayor de dispositivo 12 indica un manejador de terminal. La segunda terminal(ttyb) tendría un número de dispositivo mayor 12 y un número menor igual a 1 ya que elprimer dispositivo es el cero.

• Enlaces duros (hard links). Un enlace duro no es realmente un tipo de archivo, sino másbien un nombre adicional para un archivo. Cada archivo contiene al menos un enlace,usualmente el nombre bajo el cual fue creado la primera vez. Agregar un enlace duro creaun alias para el archivo. Un enlace duro es indistinguible del archivo al cual fue enlazado;para el UNIX son idénticos. UNIX mantiene un conteo del número de enlaces queapuntan a cada archivo y no libera los bloques de datos del archivo hasta que el últimoenlace ha sido eliminado. Ya que un enlace es una conexión directa entre archivos (en lacual se hace referencia al número de inodo), los enlaces duros no pueden cruzar loslímites de un filesystem, es decir, no se puede hacer un enlace duro de un archivo de unfilesystem en otro.

Para crear enlaces duros se usa el comando ln fuente destino, donde fuente es elarchivo del cual se quiere hacer el enlace y destino es el nombre del nuevo enlace, esdecir, el nuevo alias del archivo. Veamos la siguiente secuencia de comandos:

seit$ ls -l total 1472 -rw-rw-rw- 1 rsolis staff 547785 Apr 27 15:04 Fondo1.gif -rw-rw-rw- 1 rsolis staff 132194 Apr 27 15:04 Logo.gif



-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif -rw-rw-rw- 1 rsolis staff 17904 Apr 27 15:04 index.html -rw-rw-rw- 1 rsolis staff 3875 Apr 27 15:21 new.gif seit$ ln index.html index2.html seit$ ls -l total 1520 -rw-rw-rw- 1 rsolis staff 547785 Apr 27 15:04 Fondo1.gif -rw-rw-rw- 1 rsolis staff 132194 Apr 27 15:04 Logo.gif -rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif -rw-rw-rw- 2 rsolis staff 17904 Apr 27 15:04 index.html -rw-rw-rw- 2 rsolis staff 17904 Apr 27 15:04 index2.html -rw-rw-rw- 1 rsolis staff 3875 Apr 27 15:21 new.gif

Se puede ver que en el primer ls existe un archivo denominado index.html,

posteriormente se crea un enlace duro para ese archivo con el comando ln, el cual recibeel nombre de index2.html; y al dar nuevamente el comando ls -l sale el nuevo alias ypodemos notar que ambos tienen la misma longitud, fecha y hora. También podemosnotar si analizamos la salida de ambos ls -l uno de los campos (el segundo) cambio de unvalor 1 en el primer ls a un valor 2 en el segundo. Este número indica la cantidad deenlaces que existen para el contenido del archivo y está claro que después de emitir elcomando ln existen ya 2 enlaces al mismo archivo: index.html e index2.html.

• Enlaces suaves (soft links). Un enlace simbólico o suave apunta a un archivo pornombre. Cuando el kernel necesita abrir un enlace simbólico, evalúa la ruta almacenadacomo el contenido del archivo. La diferencia entre enlaces duros y simbólicos es que unenlace duro es una referencia directa, mientras que un enlace simbólico es una referenciapor nombre; los enlaces simbólicos son distintos de los archivos a los que apuntan.

Los enlaces simbólicos se crean con el comando ln -s fuente destino. Ya quecontienen una ruta arbitraria, puede referirse a archivos en otros filesystems o a archivosno existentes. Pueden contener una ruta absoluta o relativa. Veamos el siguiente ejemplo:

seit$ ln -s index.html index3.htmlseit$ ln -s /usr/sbin/ping pingsoftseit$ ls -ltotal 1552-rw-rw-rw- 1 rsolis staff 547785 Apr 27 15:04 Fondo1.gif-rw-rw-rw- 1 rsolis staff 132194 Apr 27 15:04 Logo.gif-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif-rw-rw-rw- 2 rsolis staff 17904 Apr 27 15:04 index.html-rw-rw-rw- 2 rsolis staff 17904 Apr 27 15:04 index2.htmllrwxrwxrwx 1 rsolis docentes 10 Jun 3 09:12 index3.html -> index.html-rw-rw-rw- 1 rsolis staff 3875 Apr 27 15:21 new.giflrwxrwxrwx 1 rsolis docentes 14 Jun 3 09:12 pingsoft -> /usr/sbin/ping

Se puede notar que al crear un enlace suave los archivos no tienen el mismo tamañoya que el enlace suave en realidad almacena la ruta, en el primer caso es relativa(index.html) la cual tiene 10 caracteres de longitud, mientras que la segunda es absoluta(/usr/sbin/ping) la cual tiene 14 caracteres de longitud. Asimismo podemos notar que elnúmero de enlaces no aumenta pues no es una referencia directa.



2.2. Permisos de archivos

Los permisos son simplemente el medio por el cual a los usuarios se les concedeacceso a los recursos del sistema. Encontrara permisos más frecuentemente en conexión alos archivos.

Asociados con cada archivo está un conjunto de 9 bits de permiso. Puede ver estosbits gráficamente al ejecutar el comando ls -l, que dará como resultado una salida similar a lasiguiente:seit$ ls -ltotal 1424-rw-r--r-- 1 root root 0 Apr 3 13:21 NSCERTMAP.0-rw-r--r-- 1 gpaez alumnos 0 Apr 21 07:17 NSCERTMAP.1033-rw-r--r-- 1 root other 14428 May 18 15:19 daemonstat.any.80-rw-r--r-- 1 root other 3676 May 12 08:21 daemonstat.any.8888-rw-rw-r-- 1 root bin 661849 Mar 18 1996 hvtmpAAAa001Qm-rw-rw-rw- 1 root root 10757 May 30 07:23 license_log-rw-rw-r-- 1 root sys 4796 Apr 3 13:21 ps_datadrwxr-xr-x 2 rsolis staff 279 Apr 27 15:21 simp-rwxr-xr-- 1 rsolis staff 48 May 27 07:31 sunpro

Los códigos al inicio de cada línea identifican los nueve bits de permiso de cada archivo.

Podemos tomar uno de estos códigos, el del archivo sunpro que es -rwxr-xr-x ypartirlo en las siguientes partes:(-) (rwx) (r-x) (r-x)

El primer guión identifica al tipo de archivo como archivo regular. Los posibles caracteresque pueden ir en esta primera posición son:Carácter Tipo de Archivo

- Regulard Directorioa Especial de carácterb Especial de bloquel Enlace suave

El siguiente conjunto de marcas (rwx) indica si al dueño del archivo se le permite leer(r), escribir (w) y ejecutar el archivo. Si el correspondiente permiso no es concedido, unguión se muestra en su lugar. Los permisos concedidos al dueño del archivo (rsolis) son delectura, escritura y ejecución.

El segundo grupo de permisos (r-x) indica las capacidades de los usuarios quepertenecen al grupo del usuario. El nombre del grupo es staff, así que cualquier usuario en elgrupo tiene derecho a leer y ejecutar el archivo, pero no a sobreescribirlo.



El tercer grupo de permisos se aplica al resto de los usuarios (denominadocomúnmente como other) , entonces (r--) indica que el resto de los usuarios sólo puedenleer el archivo.

El siguiente campo ya vimos que es el número de enlaces al contenido y lossiguientes son el nombre del propietario y el nombre del grupo al que pertenece.

Cuando un archivo es creado, el ID del usuario y el ID del grupo del usuario activoson almacenados en el inodo del archivo y se le aplica un conjunto default de bits depermisos. Se pueden cambiar cualquiera de estos parámetros - el ID del usuario, el del grupoo sus bits de permiso, con los comandos de sistema apropiados.

Después de que un archivo es creado, cada intento de acceso es verificado usandolos permisos del archivo. Si la verificación falla, el acceso es prohibido.

Ahora bien, las operaciones que afectan la existencia de un archivo, tal como crearloo removerlo, son alteraciones al directorio que contiene el archivo. Por lo tanto, para crearun archivo o borrarlo se requiere tener permisos de escritura en el directorio que locontenga.

Por otro lado, el alterar los permisos de un archivo solo se le permite al dueño delarchivo.

Veamos pues ahora los comandos que nos permitirán el manejo de los permisos,primeramente para determinar nuestra identidad se puede usar el comando id. Este comandomuestra el nombre y número de usuario que tenemos así como el nombre y número delgrupo en el cual nos encontramos en ese momento.

seit$ iduid=1001(rsolis) gid=10(staff)

Se le puede dar la opción -a para que muestre no solamente el grupo activo sinotodos los grupos a los cuales pertenecemos.

seit$ id -auid=1001(rsolis) gid=10(staff) groups=10(staff),14(sysadmin),101(docentes)

Para entrar a uno de los grupos a los cuales pertenecemos se puede usar el comandonewgrp dándole como argumento el nombre del grupo. Aunque podemos pertenecer avarios grupos solo podemos estar activos en uno a la vez. En el siguiente ejemplo podemosver que una vez emitido el comando newgrp entramos a un nuevo grupo, el cual puede versedando el comando id.

seit$ newgrp docentes



seit$ iduid=1001(rsolis) gid=101(docentes)

Analicemos ahora la forma en que se pueden cambiar los permisos de los archivos,así como el propietario o grupo al que pertenecen.

Para cambiar los bits de permiso de un archivo se usa el comando chmod el cualtiene la siguiente sintaxis:

chmod permisos archivo(s)

Para cambiar los permisos de un archivo se requiere ser el propietario del mismo obien ser el administrador del sistema.

Los permisos pueden ser indicados de 2 maneras: simbólica y numérica.

Los permisos de la manera simbólica se distribuyen de la siguiente manera:

[aquien] +|- cualesdonde aquien es un elemento opcional y especifica cual de los tres conjuntos de

permisos va a ser modificado y puede ser cualquier de los siguientes caracteres:Carácter Significado

u Usuariog Grupoo Otrosa Todos

Si no se especifica ningún carácter se asume que se aplicará a todos. O bien, sepueden poner varios de estos indicando que se quieren modificar los permisos para variosconjuntos (grupo y usuario, grupo y otros, etc.)

Posteriormente se pone un + si se quiere poner algún permiso o un - si se quierequitar. Y finalmente, se pone uno o varios caracteres que indican los permisos que sequieren poner o quitar los cuales pueden ser:Carácter Significado

r Lecturaw Escriturax Ejecución

Si se quisiera quitar el permiso de escritura para otros en el archivo index.html elcomando sería el siguiente:

chmod o-w index.html



Si se quisiera poner el permiso de ejecución en el archivo index2.html para todos elcomando sería el siguiente:

chmod a+x index2.htmlo bien,

chmod +x index2.htmlya que si no se indica a quien se le aplica la modificación de permisos se asume que es paratodos.

Si se quiere quitar el permiso de lectura y escritura para el grupo y otros en elarchivo Logo.gif el comando sería el siguiente:

chmod go-rw Logo.gif

Ahora veamos la forma numérica de cambiar los permisos.

En esta forma a cada permiso se le asigna un valor numérico pues se puede ver comosi fueran 3 bits rwx (lectura, escritura y ejecución) para cada conjunto (usuario, grupo yotros). Cada uno de los bits rwx tiene el valor 1 si es que el permiso está puesto o 0 si esque no lo está, por lo tanto y de acuerdo a la posición, el bit r vale 4, el bit w vale 2 y el bit xvale 1, si es que están puestos o activados o valen cero si es que no lo están. Entonces, deacuerdo a esto, cuando se modifican permisos de un archivo se especifican como permisos 3números octales (octales pues tienen 8 valores posibles que van de 0 cuando ninguno de lospermisos está activado a 7, cuando todos los permisos lo están), uno para el usuario, otropara el grupo y el último para los otros.

Así pues, de manera numérica para darle permiso de lectura y escritura a usuario ygrupo, pero solo de escritura a otros al archivo Logo.gif el comando sería:

chmod 664 Logo.gif

Se pudiera ver que para calcular el número que va en cada conjunto (usuario, grupoy otros) se saca sumando el valor de cada uno de los permisos que se quieren poner, en elejemplo anterior se quería lectura (4) y escritura (2) para usuario y grupo, por lo cual elnúmero para cada uno de estos sería 4+2=6, mientras que para los otros sólo se quierelectura (4), por lo que el número es 4.

Veamos otro ejemplo. Si se quisiera poner permiso de lectura, escritura y ejecuciónpara usuario, lectura y escritura para el grupo y ningún permiso para los otros en el archivoflecha.gif, el comando sería:

chmod 760 flecha.gif

Ahora bien, los permisos de lectura (r), escritura (w) y ejecución (x) se entienden dela siguiente manera en cuanto al manejo de los directorios, el permiso de lectura indica quese puede listar con ls el contenido del directorio, el permiso de escritura indica que sepueden crear nuevos archivos en el directorio y el permiso de ejecución (x) indica que eldirectorio puede accesarse, es decir, no basta con tener permiso de lectura en un directorio



para verlo sino que se requiere que también se tenga el permiso de ejecución para poderentrar a él. En cambio si no se tiene el permiso de lectura pero si el de ejecución no va a serposible listar el directorio pero si se va a poder entrar al directorio y ver el contenido de losarchivos si es que se conoce el nombre de ellos.

Hay una opción que se le puede aplicar al comando chmod cuando se aplica sobre undirectorio, la cual es -R que hace que el permiso se aplique sobre todos los archivos ydirectorios que contenga. Así pues el comando:

chmod -R 744 /tmp

hace que el directorio /tmp así como todos los subdirectorios y archivos quecontenga se queden con todos los permisos para el usuario o propietario y de lectura para elgrupo y los otros.

Para cambiar el propietario de un archivo se usa el comando chown el cual tiene lasiguiente sintaxis:

chown nuevoprop archivo

en donde nuevoprop es el nombre del quien se desea sea el propietario del archivo.

Al igual que el comando anterior se requiere ser el propietario del archivo o eladministrador del sistema para poder cambiar la propiedad del archivo aunque en lasversiones más recientes de UNIX este privilegio sólo se le permite al administrador delsistema ya que si un usuario aplica el comando chown sobre uno de sus archivos para darlela propiedad del mismo, no podrá regresarse la propiedad ya que no es más el dueño.

Así pues, el comando:chown sdelrio nuevo.txt

Hace que el archivo nuevo.txt sea ahora del usuario(a) sdelrio.

También, de manera similar al comando chmod, se le puede dar la opción -R cuandose aplica sobre un directorio indicando que se quiere cambiar la propiedad del directorio yde todo lo que contenga (archivos y directorios).

Por último, el comando chgrp sirve para cambiar el grupo al que pertenece elarchivo y su sintaxis es la siguiente:chgrp nuevogrupo archivodonde nuevogrupo es el grupo al cual se quiere que pertenezca el archivo. Para poderaplicar este comando se requiere ser el propietario del archivo y pertenecer al grupo al cualse quiere cambiar el archivo, o bien, ser el administrador del sistema. También se le puedeaplicar la opción -R cuando se aplica sobre directorios teniendo el mismo efecto que tieneesta opción en los anteriores dos comandos.



seit$ ls -ltotal 1552-rw-rw-rw- 1 rsolis staff 132194 Apr 27 15:04 Logo.gif-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif-rw-rw-r-- 2 rsolis staff 17904 Apr 27 15:04 index.htmlseit$ id -auid=1001(rsolis)gid=10(staff) groups=10(staff),14(sysadmin),101(docentes)seit$ chgrp docentes Logo.gifseit$ ls -ltotal 1552-rw-rw-rw- 1 rsolis docentes 132194 Apr 27 15:04 Logo.gif-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif-rw-rw-r-- 2 rsolis staff 17904 Apr 27 15:04 index.html

En el anterior ejemplo se ve que existe un archivo Logo.gif el cual pertenece algrupo staff, se emite el comando id -a para determinar a que otros grupos pertenece y con elcomand chgrp se cambia el grupo del archivo.

Otro comando más que tiene que ver con los permisos de un archivo es umask, estecomando usado sin argumentos nos muestra un número que indica que permisos se quitan aun archivo cuando se crea por un usuario.

Cuando un usuario crea un archivo el sistema quita los permisos de ejecución paratodos pues asume que el archivo no es ejecutable por default, entonces se puede ver que elsistema quita el permiso de ejecución para todos (111 de acuerdo a la notación numéricavista en el comando chmod) al conjunto de todos los permisos (777) quedando permisos delectura y escritura para todos (666); posteriormente el sistema le quita los permisos quedevuelve umask y los permisos que quedan son los que se guardan con el archivo. Así pues,si el comando umask devuelve 022, al crear un archivo éste queda con permisos de escrituray lectura para el usuario y lectura para el grupo y otros (644 = 777 - 111 - 022).

Si se quiere modificar los permisos que se deseen eliminar por default al crear unarchivo (aparte del 111 que ya determina el sistema) al comando umask se le da comoargumento los 3 números que indican que permisos hay que quitarle al usuario, grupo yotros. Entonces, si se quiere quitar el permiso de escritura a los otros pero ninguno al grupoo al usuario, el comando sería:

umask 002

Así pues, al crear un archivo después de este comando el permiso que tendría seríade lectura y escritura para usuario y grupo y lectura para otros (644 = 777 - 111 - 002).

2.3. Manipulación de archivos

Veamos ahora algunos de los comandos más útiles en el manejo de los archivos.

El comando ls como ya mencionamos, sirve para visualizar el contenido deldirectorio.



Este comando tiene varias opciones de las cuales las más importantes son:Opción Significado

-a Muestra los archivos que empiezan con . (punto), los cualesen un listado normal no son desplegados

-F Agrega un carácter a cada archivo dependiendo del tipo, porejemplo un / a los directorios, un * a los ejecutables y un @ alos enlaces suaves

-l Muestra un listado largo, con los siguientes datos:• Tipo de archivo• Permisos• Número de enlaces• Usuario propietario• Grupo propietario• Longitud en bytes• Fecha• Hora• Nombre del archivoAparte en la primera línea se indica el total de bloques que seestán utilizando en el directorio.

-t Los ordena por la fecha y hora en orden descendente, es decir,del más recientemente creado al más viejo

Cada una de estas opciones puede combinarse. A continuación se ven algunosejemplos:

seit$ lsFondo1.gif Logo.gif flecha.gif imagenes index.htmlnew.gifseit$ ls -a. .rhosts Logo.gif imagenes new.gif.. Fondo1.gif flecha.gif index.htmlseit$ ls -FFondo1.gif Logo.gif flecha.gif imagenes/ index.html*new.gifseit$ ls -ltotal 1488-rw-rw-rw- 1 rsolis staff 547785 Apr 27 15:04 Fondo1.gif-rw-rw-rw- 1 rsolis docentes 132194 Apr 27 15:04 Logo.gif-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gifdrwxr-xr-x 2 rsolis staff 69 Jun 3 18:44 imagenes-rwxrwxr-x 1 rsolis staff 17904 Apr 27 15:04 index.html-rw-rw-rw- 1 rsolis staff 3875 Apr 27 15:21 new.gifseit$ ls -timagenes new.gif Fondo1.gif Logo.gif flecha.gifindex.htmlseit$ ls -lttotal 1488



drwxr-xr-x 2 rsolis staff 69 Jun 3 18:44 imagenes-rw-rw-rw- 1 rsolis staff 3875 Apr 27 15:21 new.gif-rw-rw-rw- 1 rsolis staff 547785 Apr 27 15:04 Fondo1.gif-rw-rw-rw- 1 rsolis docentes 132194 Apr 27 15:04 Logo.gif-rw-rw-rw- 1 rsolis staff 30467 Apr 27 15:04 flecha.gif-rwxrwxr-x 1 rsolis staff 17904 Apr 27 15:04 index.html

Para crear un archivo vacío se usa el comando touch. Su sintaxis es touch nomarchdonde nomarch es el nombre del archivo a crear.

Para borrar un archivo se usa el comando rm. Para poder eliminar un archivo serequiere ser el propietario del mismo y aparte tener permisos de escritura en el directorio enel cual se encuentra, o bien, ser el administrador del sistema. Su sintaxis es rm nomarchivo.Se puede usar la opción -r para eliminar un directorio con todo y su contenido.

Para copiar un archivo se usa el comando cp. Este comando tiene la siguientesintaxis:cp fuente destino

Se requiere tener permisos de lectura sobre archivo fuente para poder copiarlo eindependientemente de quien sea el propietario del fuente el destino se guarda con lospermisos ya mencionado en la sección anterior siendo el propietario el usuario que emitió elcomando cp. Así pues, veamos el siguiente ejemplo:

seit$ ls -ltotal 1696-rwxr-xr-x 1 rsolis staff 15 Jun 3 19:44 compila-rw-r--r-- 1 rsolis staff 1104 Jun 3 19:44 href.txtseit$ cp compila copiaseit$ iduid=1034(88450331) gid=100(alumnos)seit$ ls -ltotal 1712-rwxr-xr-x 1 rsolis staff 15 Jun 3 19:44 compila-rwxr-xr-x 1 88450331 alumnos 15 Jun 3 19:45 copia-rw-r--r-- 1 rsolis staff 1104 Jun 3 19:44 href.txt

Se puede ver que existe un archivo compila el cual es propiedad de rsolis, comotiene permiso de lectura para otros el usuario 88450331 puede copiarlo y la copia espropiedad de tal usuario.

Para mover un archivo a otra posición se usa el comando mv. Debe ser el dueño delarchivo para poder moverlo así como tener permisos de escritura sobre los directorios dondese encuentra el archivo actualmente y al que se quiera mover. Este comando también sepuede usar para cambiar el nombre del archivo. Su sintaxis es:

mv fuente destino

seit$ mv copia renombrado



seit$ ls -ltotal 1712-rwxr-xr-x 1 rsolis staff 15 Jun 3 19:44 compila-rw-r--r-- 1 rsolis staff 1104 Jun 3 19:44 href.txt-rwxr-xr-x 1 88450331 alumnos 15 Jun 3 19:45 renombrado

En este ejemplo se uso mv para cambiarle el nombre al archivo copia llamándoseahora renombrado.

Para determinar el tipo de archivo se puede usar el comando file. Este comando leelas primeras líneas del archivo e intenta descrubrir de que tipo es. Veamos algunos ejemplos:

seit$ file Logo.gifLogo.gif: GIF file, v87seit$ file index.htmlindex.html: commands textseit$ file /usr/bin/ls/usr/bin/ls: ELF 32-bit MSB executable SPARC Version 1,dynamically linked, strippedseit$ file /etc/passwd/etc/passwd: ascii text

Para ver el contenido de un archivo se usa el comando cat. Su sintaxis es catnomarch. El problema que tiene este comando es que si el archivo no cabe en pantallasolamente alcanzamos a ver las últimas líneas del mismo. Para solucionar este problema setienen otros comandos que mencionaremos a continuación.

Para ver el contenido de un archivo por páginas o pantalla se usa el comando more.Este comando muestra el contenido de un archivo y si no cabe en pantalla hace una pausapara continuar, si se presiona la barra espaciadora se avanza otra página, si se presiona Enterse avanza una sola línea o si se presiona q termina la visualización del archivo. Su sintaxis esmore nomarchivo.

Otro comando que sirve para visualizar un archivo por páginas es pg, el cual tieneaparte de las características de more otras posibilidades como son la búsqueda de patrones ola ejecución de comandos. Cuando una pantalla se llena se detiene en espera de un comandoal igual que more, si se quiere ver la lista de comandos disponible se puede dar h y Enterpara ver la lista de comandos, lo que hace que salga una pantalla similar a la siguiente:

------------------------------------------------------- h help q or Q quit <blank> or <newline> next page l next line d or <^D> display half a page more . or <^L> redisplay current page



f skip the next page forward n next file p previous file $ last page w or z set window size and display next page s savefile save current file in savefile /pattern/ search forward for pattern ?pattern? or ^pattern^ search backward for pattern !command execute command

Most commands can be preceeded by a number, as in:+1<newline> (next page); -1<newline> (previous page); 1<newline>(page 1).

See the manual page for more detail.-------------------------------------------------------:

En algunos sistemas no se encuentra el comando pg (por ejemplo Linux) pero existeun comando similar que es less, de la misma manera cuando se llena la pantalla se detiene yse puede teclear h y Enter para ver la lista de comandos disponibles.

Para ver las primeras líneas de un archivo se puede usar el comando head. Estecomando cuando no se dan opciones muestra las primeras 10 líneas del archivo dado comoargumento, si se quiere otra cantidad se le da la cantidad de líneas deseadas precedida porun - como opción antes del argumento.

seit$ head index.html<HTML><HEAD> <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1"> <META NAME="GENERATOR" CONTENT="Mozilla/4.04 [en] (WinNT; I) [Netscape]"> <TITLE>\server\admin\Escritorio\simposium</TITLE></HEAD><BODY BACKGROUND="Fondo1.gif"> <TABLE BORDER COLS=1 WIDTH="100%" ><TR>seit$ head -15 index.html<HTML><HEAD> <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1"> <META NAME="GENERATOR" CONTENT="Mozilla/4.04 [en] (WinNT; I) [Netscape]"> <TITLE>\server\admin\Escritorio\simposium</TITLE></HEAD><BODY BACKGROUND="Fondo1.gif"> <TABLE BORDER COLS=1 WIDTH="100%" ><TR><TD><CENTER><B><FONT FACE="Arial Rounded MT Bold"><FONT COLOR="#000099"><FONT SIZE=+4>2º</FONT><FONT SIZE=+3>Simposium Internacional en Sistemas Computacionales e Informática</FONT></FONT></FONT></B> </CENTER></TD></TR>



El comando tail se usa para ver las últimas líneas de un archivo. Si no se danopciones se muestran las últimas 10 líneas del archivo dado como argumento. Si se quierenmás o menos líneas se indica la cantidad de líneas anteponiéndole un -.seit$ tail href.txt<FORM NAME="URLframe"><TABLE BORDER="0" ALIGN="CENTER"><TR><TD VALIGN="MIDDLE" ALIGN="CENTER"><BR><FONTSIZE="3" COLOR="#FF0000"FACE="VERANDA,ARIAL,HELVETICA"><B>http://</B></FONT><INPUTTYPE="TEXT" NAME="Dest" SIZE="55" MAXLENGTH="50"></TD></TR><TR><TD ALIGN="CENTER"><P><INPUT TYPE="BUTTON" VALUE=" Go to.. " ONCLICK="GoToURL(this)"WIDTH="50"></P></TD></TR></TABLE></FORM><P>seit$ tail -15 href.txtwindow.status=('Connecting to ' + URLis + ' Please wait........'); } }//--></SCRIPT><FORM NAME="URLframe"><TABLE BORDER="0" ALIGN="CENTER"><TR><TD VALIGN="MIDDLE" ALIGN="CENTER"><BR><FONTSIZE="3" COLOR="#FF0000"FACE="VERANDA,ARIAL,HELVETICA"><B>http://</B></FONT><INPUTTYPE="TEXT" NAME="Dest" SIZE="55" MAXLENGTH="50"></TD></TR><TR><TD ALIGN="CENTER"><P><INPUT TYPE="BUTTON" VALUE=" Go to.. " ONCLICK="GoToURL(this)"WIDTH="50"></P></TD></TR></TABLE></FORM><P>

Si el número es precedido por un + en vez de un -, entonces lo que pasa es que elarchivo es mostrado a partir de la línea indicada.seit$ tail +32 href.txt<TR><TD VALIGN="MIDDLE" ALIGN="CENTER"><BR><FONTSIZE="3" COLOR="#FF0000"FACE="VERANDA,ARIAL,HELVETICA"><B>http://</B></FONT><INPUTTYPE="TEXT" NAME="Dest" SIZE="55" MAXLENGTH="50"></TD></TR><TR><TD ALIGN="CENTER"><P><INPUT TYPE="BUTTON" VALUE=" Go to.. " ONCLICK="GoToURL(this)"WIDTH="50"></P></TD></TR></TABLE></FORM><P>

En el ejemplo anterior, se muestra el contenido del archivo href.txt a partir de la línea30.

El comando find sirve para encontrar archivos en la estructura de directorios delUNIX. Su sintaxis es:

find dirinicial opciones



donde dirinicial es el directorio en el cual se empezará a hacer la búsqueda. Hay que hacernotar que la búsqueda es recursiva, es decir, también se busca en los subdirectorios quepartan del dirinicial.

Algunas de las opciones son:Opción Significado

-name nombre Para indicar el nombre del archivo a buscar-print Para imprimir el nombre del archivo que

coincida con lo buscado-user nomusuario Para buscar los archivos que pertenezcan a un

usuario dado-atime +n Muestra los archivos que hayan sido accesados

hace más de n días-mtime +n Muestra los archivos cuyos datos hayan sido

modificados hace más de n días-exec comando Para ejecutar un comando por cada archivo que

encuentre, el comando debe ir terminado por unespacio y punto y coma. Aparte si se quiere usarcomo argumento el nombre del archivoencontrado se hace referencia a él con {}

-ctime +n Muestra los archivos cuyos permisos hayan sidomodificados hace más de n días

-newer nomarch Muestra los archivos que tengan una fecha másreciente que los de numarch

-size +nc Muestra los archivos que midan más de n bytes-type tipo Muestra los archivos del tipo especificado:

• f Archivo regular• c Especial de carácter• b Especial de bloque• d Directorio• l Enlace suave

Así pues, el comando:find / -type d -print

muestra el nombre de todos los directorios a partir del directorio raíz.Otro comando útil para el manejo de archivo es wc, el cual devuelve la cantidad de

líneas, palabras y caracteres contenidas en un archivo.

seit$ wc href.txt 38 104 1104 href.txt

Se pueden usar las siguientes opciones si no se quieren las 3 cuentas:

Opción Significado



-l Muestra el número de líneas-w Muestra el número de palabras-c Muestra el número de caracteres

Se pueden combinar las opciones.

seit$ wc -l href.txt 38 href.txtseit$ wc -lw href.txt 38 104 href.txt

El primer comando devuelve el número de líneas y el segundo el número de líneas yde palabras.

El comando pr muestra el contenido de un archivo dándole un formato paraimpresión el cual incluye en la parte superior la fecha y el número de página, por default seasumen para el formateo 66 líneas y 72 columnas, pero se puede cambiar con las siguientesopciones:

Opción Significado-l nlin Especifica nlin líneas

-w ncol Especifica ncol columnas

Así pues, el comando:pr href.txt

muestra en pantalla el contenido del archivo como si fuera a imprimirse en hojas con 66líneas y 72 columnas. En cambio, el comando:

pr -w 40 -l 10 href.txt

lo formatea para hojas con 10 líneas de 40 columnas.

2.4. Impresión de archivos

Para imprimir archivos se usa el comando lp. Su sintaxis es la siguiente:lp nomarchivo(s)

seit$ lp compilarequest id is Printer1-3 (1 file(s))

En el ejemplo anterior se envía a la impresora por default el archivo compila y elcomando emite un mensaje indicando el número de identificación de la solicitud deimpresión. Este número es importante pues si posteriormente se desea cancelar el trabajo deimpresión se requiere de tal número. Hay que hacer notar que la impresión no



necesariamente es inmediata pues si hay trabajos pendientes las solicitudes se van agregandoa una cola impresión (spool).

Se puede dar una opción al comando lp para que nos avise cuando la impresión sehaya realizado, tal opción es -w.

seit$ lp -w compilarequest id is Printer1-4 (1 file(s))seit$seit$ Message from lp on seit (???) [ Thu Jun 4 11:11:20 ] ...Subject: Status of lp request Printer1-4

Your request Printer1-4 destined for Printer1

The job title was: /tmp/compila submitted from: seit at: Thu Jun 4 11:11:13 1998

has completed successfully on printer Printer1.<EOT>

Se puede ver que después de un tiempo se nos avisa que el trabajo de impresión hasido llevado a cabo con éxito.

Si existen más de 1 impresora en el sistema se puede indicar cual de ellas es eldestino con la opción -d destino.

seit$ lp -d Printer1 compilarequest id is Printer1-5 (1 file(s))

En este ejemplo se ve que el archivo compila se envía a la impresora Printer1.

Para ver el estado de los trabajos de impresión se usa el comando lpstat el cual indicael nombre del usuario al que pertenece el trabajo y la fecha y hora en que se emitió.

La opción -m hace que una vez que se realiza la impresión se envíe un correoelectrónico para notificárselo al usuario.

La opción -o nobanner hace que al momento de imprimirse no se imprima un bannerque contiene la identificación del trabajo.seit$ lp compilarequest id is Printer1-6 (1 file(s))seit$ lpstatPrinter1-6 rsolis 15 Jun 04 11:26

Para cancelar algún trabajo de impresión se usa el comando cancel al cual se le dacomo argumento el número de identificación del trabajo de impresión a cancelar.



seit$ cancel Printer1-6request "Printer1-6" cancelled

2.5. Comandos para desplegar mensajes

El comando echo escribe el mensaje dado como argumento.

seit$ echo ITZITZ

El comando echo reconoce las siguientes secuencias:Secuencia Significado

\c No envía un avance de línea después del mensaje\f Avance de página\r Avance de línea\t Tabulador\\ Diagonal invertida

seit$ echo '\t\tITZ\\' ITZ\

El comando banner saca el mensaje dado como argumento con letras grandes.

seit$ banner ITZ ### ####### ####### # # # # # # # # # # # # # # # ### # #######

El comando date despliega la fecha y la hora del sistema.

seit$ dateThu Jun 4 12:03:58 CST 1998

Se puede modificar la forma que se muestra la hora y fecha dando como argumentouna cadena que comience con + y en la cual pueden ir las siguientes opciones:

Opción Significado%m Mes%d Día%y Año



%H Hora%M Minutos%S Segundos

Así pues si se quiere que solo salgan la hora y los minutos el comando sería de lasiguiente manera:

seit$ date "+%H:%M"12:28

Por último, el comando cal sirve para mostrar un calendario del mes actual.

seit$ cal June 1998 S M Tu W Th F S 1 2 3 4 5 6 7 8 9 10 11 12 1314 15 16 17 18 19 2021 22 23 24 25 26 2728 29 30

Se le pueden dar como argumentos ya sea el año o el mes y año del cual se desea elcalendario.

seit$ cal 2 1999 February 1999 S M Tu W Th F S 1 2 3 4 5 6 7 8 9 10 11 12 1314 15 16 17 18 19 2021 22 23 24 25 26 2728



3. Manejo del shell

3.1. ¿Qué es un shell?

Un shell es un interprete de comandos. Es un programa que acepta entrada delusuario y lo interpreta en acciones que el kernel del sistema operativo entiende. Algunasinstrucciones del usuario requieren una acción del shell solamente, otras involucran al kernely otras accesan a otros programas. El programa shell determina que hacer con la entrada delusuario. El shell contiene variables que se pueden cambiar para personalizar el entorno. Sepueden crear nuevas variables y programas con los shells, de la misma manera que en loslenguajes de programación procedurales. Los shells varían en las facilidades que ofrecen alusuario y, hasta cierto punto, en los detalles de la sintaxis.

Los shells son orientados a líneas; le indican que esperan que introduzca uncomando. El indicador por default del shell Bourne es $; el del shell C es el % y en shellKorn, debido a similitudes que tiene con el Bourne, el default es $. Algunos comandosrequieren más de una línea. Para indicar que se espera más en la siguiente línea, los shellsusan un indicador secundario, usualmente el símbolo >.

Muchos programas UNIX no tienen interfaz de usuario y se apoyan en el programashell para proporcionar control sobre la entrada, salida y opciones de las operaciones delprograma. Otros programas tienen sus propias interfaces de usuario, pero se apoyan en elshell para que los inicie.

Los shells son programas. Se puede iniciar cualquier shell desde cualquiera de losotros shells. El shell Bourne es el programa sh, el shell C es csh y el shell Korn es ksh.

3.2. El Shell Bourne

Todos los sistemas UNIX le proporcionan el shell Bourne. Es el más viejo y suinterfaz es la más común a un sistema UNIX. Las facilidades del shell Bourne estándisponibles en todos los shells, aunque la sintaxis pudiera diferir.

El uso del shell Bourne es como llevar una conversación con la computadora. Con el$, el shell le indica que de instrucciones y debe responder diciéndole que hacer. Cuando elshell esté listo para otro comando (esto es, cuando el shell u otro programa hay completadosu tarea) emite nuevamente el indicador.

Cuando se entra al sistema UNIX se ejecutan dos procesos en forma automática:• login.

1. Checa el login y el password en el archivo /etc/passwd2. Selecciona las variables HOME, MAIL, PATH y LOGNAME3. Ejecuta el shell



• /etc/profile1. Despliega el mensaje del día2. Notifica si hay correo3. Selecciona otras variables4. Ejecuta el archivo .profile si se encuentra en el directorio raíz del usuario

Algunas de las características del Shell son:• Es posible redireccionar E/S sin límite• Análisis de metacaracteres en nombre de archivos• Contiene todo lo necesario para programar

Hay que hacer notar que el shell maneja tres archivos estándar: entrada estándar, lacual es por default el teclado y que recibe un número de 0, la salida estándar que es donde seescriben los resultados de los comandos y que recibe el número 1 y por último, el errorestándar que es donde se generan los mensajes de error y que tiene un número 2.

Los metacaracteres son caracteres que tienen un significado especial en el shell yson los siguientes:Metacaracter Significado* Sustituye cualquier cadena de caracteres incluyendo la cadena nula? Sustituye un carácter cualquiera[ ] Sustituye por cualquiera de los caracteres puestos entre corchetes[ - ] Sustituye por cualquiera de los caracteres dentro del rango especificado& Ejecuta los comandos en modo background liberando la terminal para

otras tareas; Permite separar varios comandos en una sola línea\ Elimina el significado de los caracteres especiales“ … “ Elimina el significado del espacio y de todos los caracteres especiales

excepto el $ y el `´ .. ‘ Elimina el significado del espacio y de todos los caracteres especiales` … ` Ejecuta los comandos encerrados y toma el valor de la salida generada

por ellos> Redirecciona la salida de un comando a un archivo (si ya existe se

reemplaza su contenido)< Redirecciona la entrada de un comando a el contenido de un archivo>> Redirecciona la salida de un comando para agregarla a un archivon> Redirecciona la salida o la entrada estándar (n puede ser 1 o 2)| Crea una conexión (pipe) entre la salida de un comando y la entrada del

otro$ Utilizada con parámetros posicionales y con variables definidas por el

usuario, además utilizado como el indicador default del sistema.

Ejemplos del uso de estos comandos:



seit$ ls -ltotal 234-rw-r--r-- 1 rsolis staff 5556 Nov 18 1997 DISC97.html-rw-r--r-- 1 rsolis staff 235 Oct 31 1997 ant.html-rwxr-xr-x 1 rsolis staff 16655 Mar 13 09:07 backtec1.gif-rw-r--r-- 1 rsolis staff 14893 Nov 7 1997 emailed.gif-rw-r--r-- 1 rsolis staff 604 Mar 13 09:21 index.html-rw-r--r-- 1 rsolis staff 67101 Oct 31 1997 salma.jpg-rw-r--r-- 1 rsolis staff 8149 Nov 18 1997 tutoriales.html-rw-r--r-- 1 rsolis staff 2799 Nov 7 1997 underconst.gifseit$ ls *.gifbacktec1.gif emailed.gif underconst.gifseit$ ls [ab]*.gifbacktec1.gifseit$ ls [a-f]*.gifbacktec1.gif emailed.gif

Primeramente se muestra un listado de todos los archivos contenidos en el directorio,el segundo comando, ls *.gif muestra todos los archivos que terminen en .gif. El tercercomando, ls [ab]*.gif, muestra todos los archivos que terminan en .guif y aparte empiezancon a o con b y el último comando muestra los archivos que terminan en .gif y empiezan conalgún carácter entre a y f.

seit$ echo '$LOGNAME'$LOGNAMEseit$ echo "$LOGNAME"rsolisseit$ echo La hora es `date "+%H:%M"`La hora es 12:56

El primer comando echo muestra el mensaje tal cual esta entre apóstrofos pueselimina el significado de todos los caracteres especiales.

El segundo comando echo muestra el contenido de la variable LOGNAME ya quelas comillas no eliminan el significado de $, el cual es obtener el contenido o valor de lavariable a la cual precede.

El tercero muestra el uso que tienen los apostrófos invertidos los cuales hacen que elcomando o comandos que encierran se ejecuten y que se sustituya por la salida que generan.

seit$ ls -l > directorioseit$ cat directoriototal 234-rw-r--r-- 1 rsolis staff 5556 Nov 18 1997 DISC97.html-rw-r--r-- 1 rsolis staff 235 Oct 31 1997 ant.html-rwxr-xr-x 1 rsolis staff 16655 Mar 13 09:07 backtec1.gif-rw-r--r-- 1 rsolis staff 0 Jun 4 13:03 directorio-rw-r--r-- 1 rsolis staff 14893 Nov 7 1997 emailed.gif-rw-r--r-- 1 rsolis staff 604 Mar 13 09:21 index.html-rw-r--r-- 1 rsolis staff 67101 Oct 31 1997 salma.jpg-rw-r--r-- 1 rsolis staff 8149 Nov 18 1997 tutoriales.html



-rw-r--r-- 1 rsolis staff 2799 Nov 7 1997 underconst.gifseit$ echo Linea agregada >> directorioseit$ cat directoriototal 234-rw-r--r-- 1 rsolis staff 5556 Nov 18 1997 DISC97.html-rw-r--r-- 1 rsolis staff 235 Oct 31 1997 ant.html-rwxr-xr-x 1 rsolis staff 16655 Mar 13 09:07 backtec1.gif-rw-r--r-- 1 rsolis staff 0 Jun 4 13:03 directorio-rw-r--r-- 1 rsolis staff 14893 Nov 7 1997 emailed.gif-rw-r--r-- 1 rsolis staff 604 Mar 13 09:21 index.html-rw-r--r-- 1 rsolis staff 67101 Oct 31 1997 salma.jpg-rw-r--r-- 1 rsolis staff 8149 Nov 18 1997 tutoriales.html-rw-r--r-- 1 rsolis staff 2799 Nov 7 1997 underconst.gifLinea agregada

El primer comando manda la salida del ls -l al archivo directorio, se puede ver que alver el contenido del archivo es la salida genera por ls -l. Posteriormente se hace que elmensaje generado por el comando echo se agregue al archivo directorio.

Veamos ahora el uso del símbolo \ . Consideremos que se quiere emitir el mensaje:5 > 20

seit$ echo 5 > 20seit$ cat 205seit$ echo 5 \> 205 > 20

Con el primer comando no se obtuvo el resultado esperado pues el símbolo > yatiene un significado especial por lo cual lo que sucede es que el mensaje 5 es almacenado enel archivo 20 como se puede ver con el comando cat aplicado al archivo 20. Entonces, si noqueremos que se entienda el carácter > con su significado se le antepone un \, por eso elsegundo comando echo si dió el resultado esperado.

seit$ pwd/home/rsolis/public_htmlseit$ cd /tmp; ls -l; cd $HOME/public_htmltotal 1712-rwxr-xr-x 1 rsolis staff 15 Jun 3 19:44 compila-rw-r--r-- 1 rsolis staff 1104 Jun 3 19:44 href.txt-rwxr-xr-x 1 88450331 alumnos 15 Jun 3 19:45 renombradoseit$ pwd/home/rsolis/public_html

Se puede ver que el punto y coma permite poner varios comandos en una sola línealos cuales ejecuta de corrido antes de volver a poner el indicador.

El carácter & indica que el comando se ejecute en modo background, es decir, quese ejecute en segundo plano dejando que el indicador aparezca inmediatamente para dar máscomandos en vez de esperar a que termine la ejecución del comando al que se le puso el &.



seit$ csh &1671

El número que se regresa es el número de proceso que le toco al comandoejecutándose en background, el cual puede ser utilizado posteriormente para terminar suejecución.

Y el carácter | sirve para hacer que la salida de un comando sea la entrada para elsiguiente comando.

seit$ cal | wc 8 39 128

En este ejemplo, el comando cal genera como salida el calendario del mes actualpero en vez de enviarlo a la salida estándar se envía como entrada al comando wc el cualcomo ya sabemos cuenta las líneas, palabras y caracteres que en este caso tiene la salida decal, y este resultado es enviado a la salida estándar.

3.3. Comandos para el Control de Procesos

Toca ahora analizar algunos de los comandos utilizados para el manejo de losprocesos, es decir, de los comandos que se encuentran en ejecución.

Primeramente, para ver una lista de los procesos en ejecución se usa el comando ps.

seit$ ps PID TTY TIME CMD 1131 pts/4 0:00 sh

La salida de ps consiste de los siguientes datos para cada proceso:PID Número identificador de procesoTTY Terminal desde la cual se está ejecutandoTIME Tiempo de ejecución del procesoCMD Comando en ejecución

ps por si solo muestra solamente los procesos iniciados en la sesión en la que seemite el comando. Si el usuario tiene abiertas varias sesiones y se desea ver los procesos quehay en todas ellas se le da la opción -a:

seit$ ps -a PID TTY TIME CMD 825 pts/6 0:00 csh 1610 pts/5 0:01 workman 830 pts/5 0:00 csh 1612 pts/5 2:45 cddaslav 1687 pts/4 0:00 ps 1666 pts/6 0:00 nslookup



Si se desea listar los procesos de todos los usuarios entonces se le da la opción -f.

Para eliminar un proceso en ejecución se usa el comando kill al cual se le pasa comoargumento el PID del proceso que se quiere eliminar.

seit$ kill 1666seit$ ps -a PID TTY TIME CMD 825 pts/6 0:00 csh 1610 pts/5 0:01 workman 830 pts/5 0:00 csh 1612 pts/5 2:51 cddaslav 1689 pts/4 0:00 ps

Se ve que después del kill el proceso nslookup con PID 1666 ya no esta enejecución.

Si se desea que un proceso se quede ejecutando aún y cuando la sesión termine seusa el comando nohup el cual tiene como argumento el nombre del comando a dejar enejecución.

seit$ nohup nslookup &1700Sending output to nohup.out

El primer número que se emite de salida es el PID del proceso y en la siguiente línease indica que cualquier salida generada por el comando nslookup se estará guardando en elarchivo nohup.out.

Para ver que comando está haciendo cada usuario se puede usar el comando w. Elcomando muestra como encabezado la hora actual, cuanto tiempo ha estado encendido elsistema, el número de usuarios en el sistema y el número promedio de procesos ejecutándoseen el último minuto, en los últimos 5 y en los últimos 15. Posteriormente se muestran lossiguientes campos para cada usuario: el nombre del usuario, nombre de la terminal en la quese encuentra, la hora en que entró al sistema, tiempo de ocio (tiempo transcurrido desde loúltimo que tecleo) en horas:minutos, el tiempo de CPU usado por todos todos los procesosen esa terminal en minutos:segundos, el tiempo de CPU usado por los procesos activosactualmente (en minutos:segundos) y el nombre del comando ejecutándose en ese momento.

seit% w 2:46pm up 1 day(s), 19:06, 8 users, load average: 0.03, 0.04, 0.05User tty login@ idle JCPU PCPU whatroot console 10:45am93days /sbin/sh -crsolis pts/7 10:46am 8 wroot pts/4 10:45am 4:01 /sbin/shrsolis pts/8 11:07am 2:59 3 -shroot pts/6 10:45am 4:01 /usr/openwin/bin/cmdt



93450427 pts/2 2:46pm pico srvidor.croot pts/10 1:35pm 17 1:19 /sbin/sh93450445 pts/13 2:14pm 1 2 pico cliente.c

Se pueden ejecutar comandos en forma diferida, es decir, hacer que se ejecuten enotra hora ya sea especificada o en una hora que el sistema decida en base a su carga detrabajo.

El comando at sirve para indicar que se ejecuten comando en una determinada hora,como argumento se le puede dar la hora, o bien una indicación de cuanto tiempo más.

Una vez dado el argumento aparecerá un indicador de la forma at> en el cual sedarán los comandos a ejecutar, cuando ya se hayan terminado se presiona Ctrl-D. Comoresultado nos dará un número identificador del trabajo el cual puede ser utilizadoposteriormente para cancelarlo. Lo que genere la lista de comandos dada será enviada porcorreo electrónico.

seit$ at 15:00at> ls -lat> <EOT>warning: commands will be executed using /bin/shjob 896994000.a at Thu Jun 4 15:00:00 1998seit$ at 18 Jun 06at> cat index.htmlat> <EOT>warning: commands will be executed using /bin/shjob 897177600.a at Sat Jun 6 18:00:00 1998seit$ at now + 40 minutesat> ps -aat> <EOT>warning: commands will be executed using /bin/shjob 896995966.a at Thu Jun 4 15:32:46 1998

El primer comando at indica que se genera un listado largo a las 15:00.El segundo comando at indica que a las 18:00 del día 6 de junio se mostrará el

contenido del archivo index.htmlEl tercer comando at indica que 40 minutos después de la hora actual se verán los

procesos en ejecución.

Al comando at se le puede dar la opción -l para listar los trabajos pendientes:

seit$ at -l896994000.a Thu Jun 4 15:00:00 1998896995966.a Thu Jun 4 15:32:46 1998897177600.a Sat Jun 6 18:00:00 1998

Con la opción -r se puede eliminar un trabajo:



seit$ at -r 897177600.aseit$ at -l896994000.a Thu Jun 4 15:00:00 1998896995966.a Thu Jun 4 15:32:46 1998

El comando batch tiene una función similar a la de at pero el sistema es el quedetermina a que hora lo ejecuta en base a su carga de procesamiento, si no tiene muchacarga. El uso es igual al de at, una vez emitido el comando batch aparece el indicador at> enel cual se dan los comandos a ejecutar y con Ctrl-D se indica la terminación apareciendo elidentificador del trabajo y la hora en la que será ejecutado. Se puede ver que en realidadbatch es un at cuya hora de ejecución se determina por el sistema.

seit$ batchat> cd /tmpat> ls -lat> pwdat> <EOT>warning: commands will be executed using /bin/shjob 897067912.b at Fri Jun 5 11:31:52 1998

Por último en cuanto a los comandos para la ejecución diferida están el cron, cron esun programa en background que continuamente checa para ver si hay trabajos que realizarpara los usuarios, es decir, se pueden dar comandos que se ejecuten periódicamente, cadahora, cada mes, etc. Con el comando crontab se indica el nombre de un archivo donde seencuentran los comandos a realizarse así como la hora y días en que se realizará. Veamos elformato que debe tener el archivo. En cada línea se tienen 6 campos separados por espacio:• Minuto (0-59)• Hora (0-23)• Día del mes (1-31)• Mes (1-12)• Día de la semana (0 - 6 siendo 0=Domingo)• Comando a ejecutar

Los primeros 5 campos pueden ser un solo valor, varios separados por coma, unrango (dos números separados por un -) o bien un asterisco indicando que puede tomarcualquier valor. La salida de los comandos es enviada por correo electrónico a menos que seredireccione la salida con >.

Así pues, si se tiene un archivo llamado tareas con la siguientes líneas:15 5,7 6 6-8 * ls -l0 * * 6 5 echo Es viernesy se emite el comando crontab tareas, a partir de ese momento de acuerdo a la primera líneael comando ls -l se ejecutaría a las 5:15 y 7:15 de los días 6 del mes de junio, julio y agosto;y de acuerdo a la siguiente línea se ejecutaría el comando echo Es viernes cada hora todoslos viernes del mes de junio.



Para listar los trabajos puestos por crontab se usa la opción -l y para eliminarlos laopción -r.

seit$ cat tareas15 5,7 6 6-8 * ls -l0 * * 6 5 echo Es viernes

seit$ crontab tareasseit$ crontab -l15 5,7 6 6-8 * ls -l0 * * 6 5 echo Es viernes

seit$ crontab -rseit$ crontab -lcrontab: can't open your crontab file.

En este ejemplo se puede ver el contenido del archivo tareas, posteriormente se haceel crontab del archivo, con crontab -l se ve el listado de tareas a realizar y con crontab -r seeliminan, por lo que el segundo crontab -l genera un error.

3.4. Shell de C

También conocido como shell de Berkeley. Su nombre deriva del hecho de que susintaxis es similar a la del lenguaje de programación C. Los administradores de sistemasUNIX, desarrolladores de sistemas y otros pasan mucho de su tiempo trabajando al nivel delshell en vez de estar utilizando programas de aplicación. Se quería una interfaz de UNIX quepermitiera facilitar la emisión de comandos complejos repetidas veces. Por ejemplo, undesarrollador de software puede repetitivamente usar el editor vi para editar un programa,invocar al compilador (cc) con algunas opciones y entonces ejecutar el programa resultante.Con el shell Bourne, la secuencia de comandos sería la siguiente:$ vi prog.c$ cc -o prog prog.c$ prog$ vi prog.c$ cc -o prog prog.c$ prog$ vi prog.c$ cc -o prog prog.c$ prog

Con el shell C, esto no se tiene que hacer. Su lista de comandos se vería de lasiguiente manera:% vi prog.c% cc -o prog prog.c% prog% !vvi prog.c% !ccc -o prog prog.c



% !pprog% !vvi prog.c% !ccc -o prog prog.c% !pprog

Note que el usuario teclea lo que está en las líneas que empiezan con %, lo demás esmostrado por el sistema.

Esto se debe a que el shell C mantiene una lista de los comandos ejecutados (lalongitud de la lista es determinada por una variable del shell, history; el valor usual es de20). El carácter ! en el comando le dice al shell C que busque hacia atrás en la lista decomandos por el primer comando que empiece con los caracteres que le siguen al !. El shellimprime lo que encontró y reejecuta el comando.

Puede volver a emitir cualquier comando. Para elegir un comando de la historia sinhacer una búsqueda hacia atrás, pónga el número de comando después del !. Si no conocelos números de comandos, use el comando history:% history

1 cal2 vi prog.c3 cc -o prog prog.c4 prog5 history

% !1calJune 1998 S M Tu W Th F S 1 2 3 4 5 6 7 8 9 10 11 12 1314 15 16 17 18 19 2021 22 23 24 25 26 2728 29 30

El shell C ofrece la posibilidad de edición (reducida) de línea de comandos. Porejemplo, para volver a emitir el comando previo con una sustitución, introduzca un acentocircunflejo (ˆ), el texto a ser sustituido, otro ˆ y el texto que lo sustituirá:

% echo Hola RufisHola Rufis% ûfisôbertoecho Hola RobertoHola Roberto

La sustitución puede ser hecha con un solo argumento, por lo que se da lo siguiente:

% ^Hola RobertoÂdios Rufis



echo Hola RobertoModifier failed

Sin embargo, si para el echo se encerró entre comillas el mensaje entonces se tomacomo un solo argumento y la modificación anterior si haría efecto:

% echo "Hola Roberto"Hola Roberto% ^Hola Roberto^Adios Rufisecho "Adios Rufis"Adios Rufis

Otra característica del shell C son los aliases, o sea, se le puede dar un nombrealterno a una expresión de comando. Dado un alias, el shell lo sustituye por la expresiónantes de intentar ejecutarlo. Para hacer un alias es con el comando:

alias nuevonom comando

Si está acostumbrado a los comandos MS-DOS, podría querer tener los siguientesalias:% alias dir ls -l% alias del rm% alias type cat

Sin embargo, el shell C tiene sus deficiencias. No es siempre el shell más eficiente, ysu sintaxis de programación y palabras clave son significativamente diferentes del shellBourne. Es común para un usuario de UNIX usar el shell C como la interfaz estándar con elsistema y usar el shell Bourne para tareas más complejas. Hoy en día hay un shell con lascaracterísticas del shell C y el lenguaje y eficiencia del shell Bourne: el shell C.

3.5. El Shell Korn

Este shell al igual que el shell C, está mejorado con capacidad de alias, historia yedición de comandos. Sin embargo, tiene muchas más opciones que le permiten personalizarel shell para sus tareas específicas. Tiene también una sintaxis más simple que la del shell C.Fue desarrollado por David Korn mientras estaba en AT&T y viene como un estándar en elUNIX System V.4, aparte de ser el preferido en muchas licencias comerciales. En vez dediferir completamente de la sintaxis del shell Bourne, retiene la mayor parte de ella.

El indicador del shell Korn es el mismo del Bourne, pero en algunos sistemas estáprecedido por el número de comando actual en la lista de historia. A diferencia del shell C,los comandos históricos son re-emitidos usando el comando especiales del shell r. Si no sele pone argumento ejecuta nuevamente el último comando, o bien, se le puede dar comoargumento el número o las primeras letras del comando a ejecutar.

$ history



1 echo Hola2 ls3 pwd4 cd5 history$ r ppwd/home/rsolis$ r 1echo HolaHola

Además, se puede editar la línea de comando o cualquier comando histórico con lasintaxis del editor vi, el cual veremos en la siguiente unidad. Con el editor se puede mover elcursor hacia atrás y hacia adelante en la línea, un carácter o una palabra a la vez. Puedetambién sustituir palabras, expander aliases y realizar muchas otras operaciones de edición.



4. Edición de textos y manejo de filtros

4.1. Editor ed

ed es el editor estándar de texto. Es un editor de líneas. Si se especifica comoargumento un nombre de archivo al ejecutarlo, tal archivo es leído a un buffer (que enrealidad es un archivo temporal) para que pueda ser editado.

Opera sobre la copia del archivo que se está editando; los cambios hechos a la copiano tienen efecto hasta que se emite el comando de escribir.

Los comandos de ed tienen una estructura simple: cero, uno o dos direccionesseguidas por un comando de un solo carácter, posiblemente seguidos por parámetros para elcomando. Las direcciones especifican una o más líneas en el buffer. Cada comando querequiere de direcciones tiene direcciones por default, para que las direcciones puedan seromitidas con frecuencia.

En general, sólo un comando puede aparecer en una línea. Ciertos comandospermiten la entrada de texto. Este texto es colocado en el lugar apropiado en el buffer.Mientras se encuentra aceptando texto, se dice que está en modo de entrada. En este modo,no se reconoce ningún comando; toda la entrada es simplemente recolectada. Para dejar elmodo de entrada se teclea un punto al principio de la línea seguido inmediatamente de unEnter.

En resumen pues, un comando es de la siguiente forma:[direccion1 [, direccion2]] comando [parametros]

4.1.1. Comandos básicos

Comando SignificadoP Pone el indicador * lo cual nos dice que estamos en modo comandoa Agrega texto después de la línea actuali Inserta líneas después de la actualc Cambia la línea actual. Termina el modo entradap Lista líneas en la terminald Elimina líneas+ Despliega la siguiente línea en el buffer- Despliega la anterior línea en el bufferw Escribe el contenido del buffer en el archivoq Termina ed y regresa al shellu Deshace el último comandoH Se pone en modo de ayuda, el cual se termina también con Hf Despliega el nombre del archivo editándose



f nomarch Cambia el nombre del archivo a nomarch! comando Sale temporalmente al shell y ejecuta el comando especificado

4.1.2. Formas de indicar la dirección de las líneas

Forma SignificadoN El número de línea del buffer. Línea actual (la última línea accesada)$ La última línea del archivon1, n2 El conjunto de líneas desde la n1 hasta la n2, El conjunto de líneas desde la 1 hasta la última; El conjunto de líneas desde la actual hasta la última+n La línea localizada n líneas después de la línea actual-n La línea localizada n líneas antes de la línea actual/patron/ Línea que contenga el patrón especificado

Ejemplos:

1,$p Se despliegan todas las líneas-5p Se mueve 5 líneas hacia atrás y se despliegan+5p Se mueve 5 líneas hacia adelante y se despliegan1,/x/p Se despliega de la línea 1 hasta la que contenga un carácter x.

4.1.3. Caracteres Especiales para Búsquedas y Reemplazos(Expresiones Regulares)

Carácter Significado. Checa con cualquier carácter en el patrónr* Checa con 0 o más ocurrencias del carácter r.*r Checa con 0 o más ocurrencias de caracteres terminadas con rˆ Checa con el inicio de la línea$ Checa con el final de la línea\ No toma en cuenta el significado del carácter especial siguiente& Repite el texto anterior al nuevo texto% Checa con el último patrón reemplazado[…] Checa con la primera ocurrencia de los caracteres entre corchetes[ˆ…] Checa con la primera ocurrencia de un carácter que no este entre

los corchetes

4.1.4. Comandos para realizar búsquedas



Forma Significado/abc Se utiliza para buscar hacia adelante en el buffer la primera línea con abc?abc Se utiliza para buscar hacia atrás en el buffer la primera línea con abcg/abc Muestra todas las líneas que contienen abcv/abc Muestra todas las líneas que no contienen abc

Ejemplos:g/.at$ Lista todas las líneas que terminen con un carácter cualquiera y “at”v/pri Lista todas las líneas que no contienen “pri”

Comandos para Realizar Reemplazos.

4.1.5. Comandos para Realizar ReemplazosForma Significado<rango>s/Expresion regular/cadena/ Reemplazar la primera ocurrencia de la expresión

regular por cadena en la línea<rango>s/Expresion regular/cadena/g Reemplazar todas las ocurrencias de la expresión

regular por cadena en la línea<rango>g/Expresion regular/cadena/g Reemplazar todas las ocurrencias de la expresión

regular por cadena en todo el archivo

Ejemplos:1,$s/hola/adios/ Cambia la primera ocurrencia de “hola” por “adios” en cada una de

las líneas1,$s/hola/adios/g Cambia todos los “hola” por “adios” en todas las líneaq/hola/adios/g Igual que el anteriors/roo*/ro Reemplaza todas las repeticiones de “o” por una sola “o” en la

primera ocurrencia de la línea1,$s/ˆ/Inicial Inserta al inicio de cada línea la palabra “Inicial”s/hombre/& moderno/ Cambia la primera ocurrencia de “hombre” por

“hombre moderno”1,$s/grupo [ˆAB]/grupo A/g Cambia la cadena “grupo ?” por “grupo A” donde “?”

es un carácter diferente de “A” y “B”

4.1.6. Comandos para Realizar Movimientos de TextoForma Significado<rango>m<linea> Mueve el rango especificado a la línea dada como parámetro<rango>t<linea> Copia el rango especificado a la línea dada como parámetro<rango>w<archivo> Guarda el rango especificado en el archivo dado como parámetror<archivo> Pone una copia del archivo en el buffer a partir de la línea actual

Ejemplos:1,5m10 Mueve las líneas de la 1 a la 5 a la 101,2t23 Copia las líneas 1 y 2 a la línea 23



r n.txt Copia el contenido del archivo n.txt a partir de la línea actual.

NOTA: En caso de que se terminará la sesión abruptamente durante la edición dealgún archivo sin haberlo guardado el archivo temporal en el que se encuentran los cambioses ed.hup.

4.2. Editor vi

El editor vi es un editor orientado a pantalla basado en un editor denominado ex.Cuando se usa vi, los cambios que se hacen al archivo son reflejados en la pantalla. Laposición del cursor en la pantalla indica la posición dentro del archivo. La invocación alcomando view es una invocación al comando vi pero con la bandera readonly (solo lectura)establecida. El comando vedit es una configuración de vi para principiantes que lo hace másfácil de aprender a usar.

El vi trabaja en dos modos: modo comando y modo inserción. Para entrar a modoinserción se usan algunos de los comandos que permiten insertar o agregar texto los cualesvamos a ver más adelante y para regresar a modo comando se presiona la tecla ESC.

4.2.1. Entrando a vi

vi nomarchivo Abre nomarchivo para ediciónvi +n nomarchivo Abre nomarchivo y va a la línea nvi -r nomarchivo Se recupera de una sesión de edición fallida

4.2.2. Movimiento en vi

Cuanto Hacia atrás Hacia adelantecarácter h llínea k ó - j ó +palabra b wpárrafo { }½ pantalla Ctrl-U Ctrl-D1 pantalla Ctrl-B Ctrl-F

A estos comandos se les puede poner de prefijo un número que indica cuantas vecesse desea que se repita. Por ejemplo, el comando 5w mueve el cursor 5 palabras a la derechay el comando 10k se mueve 10 líneas hacia arriba

Indicador Significado0 o ˆ Inicio de la línea actual$ Fin de la línea actualH Línea inicial de la pantalla



L Línea final de la pantallaM Línea intermedia de la pantallanG:n

Ir hacia la línea n (si no especifica unnúmero se va a la última línea.

nt<char> Colocarse antes del n-ésimo <char>buscandolo hacia la derecha

nT<char> Colocarse antes del n-ésimo <char>buscandolo hacia la izquierda

nf<char> Colocarse en el n-ésimo <char>búscandolo hacia la derecha

nF<char> Colocarse en el n-esimo <char>búscandolo hacia la izquierda

En estos últimos comando si no no se especifica se toma como 1, es decir, busca laprimera ocurrencia.

4.2.3. Inserción de texto

Carácter Significadoi Inserta texto antes del cursora Agrega texto después del cursorA Agrega texto al final de la líneao Abre una nueva línea (en blanco) abajo del cursor y entra

a modo de inserciónO Abre una nueva línea (en blanco) en la posición del cursor

y entra a modo de inserción:r nomarch Inserta el contenido de nomarch en la línea actual

Presionar la tecla ESC terminará el modo de inserción.

4.2.4. Eliminación de texto

Carácter Significadox Elimina el carácter en el cursordw Elimina la palabra actualdd Elimina la línea actualD Elimina el resto de la líneaX Elimina el carácter antes del cursor

Como con los comandos de movimiento, a estos comandos se les puede poner deprefijo un número para indicar la cantidad de veces que se desea se repita (a excepción deD). Por ejemplo, el comando 3dw elimina las siguientes 3 palabras.



4.2.5. Comandos de búsqueda y reemplazo

Comando Significador Reemplaza el carácter actualR Reemplaza todos los caracteres que se tecleen los ya

existentes, hasta que se presiona la tecla ESCs Sustituye un carácter por lo que se teclea hasta ESCS Sustituye una línea por lo que se teclea hasta ESC:s/str1/str2 Reemplaza el primer str1 por str2 en la línea:s/str1/str2/g Reemplaza todos los str1 por str2 en la línea:%s/str1/str2/g Reemplaza todos los str1 por str2 en todas las líneas/expreg Busca la expreg hacia adelante?expreg Busca la expreg hacia atrásn Repite el último comando de búsquedaN Repite el último comando de búsqueda en sentido

contrario

A los primeros comandos se le puede anteponer un número para que se repitan lacantidad de veces especificada.

4.2.6. Otros Comandos

Comando SignificadoY Pone una copia de la línea en un bufferP Pone las línes del buffer que hayan sido copiadas o

eliminadas en la línea actualp Pone las línes del buffer que hayan sido copiadas o

eliminadas después de la línea actualu Deshace el último comando. Repite el último comando

Al . y al comando Y se les puede anteponer un número para que se repita unadeterminada cantidad de veces.

4.2.7. Para guardar y salir de vi

Comando Significado:w Guarda el archivo sin salir:w nomarch Para guardar con el nombre nomarch:q Salir:q! Salir sin guardar:x Salvar si se han hecho cambios y salir



ZZ igual que :x

4.2.8. Algunas Opciones de vi

Comando Significado:set autoindent Automaáticamente indenta al mimo nivel de la línea

anterior:set number Despliega números de línea:set showmode Indica si vi está en modo de inserción:set wrapmargin=n Automáticamente pasa la palabra al siguiente renglón

en las últimas n columnas:set wrapscan Las búsqueda regresan al inicio una vez que se termina

el archivo

Para quitar cualquiera de estas opciones, pongáles el prefijo no. Por ejemplo, elcomando :set nonumber elimina los números de línea. Para hacer los cambios permanentes,colóquelos en el archivo .exrc en su directorio hogar.

4.3. Archivos utilizados por los shell para su inicialización

El shell de Bourne al iniciar lee y ejecuta los comandos que se encuentran el archivo/etc/profile, el cual tiene comandos generales a todos los usuarios y que es mantenido por eladministrador del sistema y posteriormente el archivo $HOME/.profile el cual contienecomandos del usuario particular. Esta ejecución es siempre y cuando los archivos existan.Los mismos archivos son ejecutados si se ejecuta el shell de Korn.

En caso de ser el shell de C, primero se ejecutan los comandos que se encuentran elarchivo /etc/.login, el cual es para todos los usuarios y es mantenido por el sistema,posteriormente se ejecuta el archivo .cshrc que se encuentra en el directorio personal de losusuarios y por último se ejecutan los comandos del archivo .login del directorio personal,estos dos últimos se pueden modificar por cada usuario (usualmente el archivo .login se usapara determinar el entorno de ambiente). Esta ejecución se hace siempre y cuando losarchivos mencionados existan.

Se puede por lo tanto editar los archivos .cshrc, .login y .profile para personalizar elentorno o ambiente del shell.



4.4. Comunicaciones en UNIX

4.4.1. Comando mailExisten algunos comandos útiles para poder comunicarse con otros usuarios en el

sistema UNIX. El primero de ellos es mail, el cual es utilizado para enviar correoselectrónicos a los usuarios, no se requiere que el usuario esté conectado para poder enviarleun correo puesto que es almacenado en su buzón.

La sintaxis del comando es:mail direccionLa dirección es simplemente el nombre de login del usuario en caso de que sea del

mismo sistema o bien de la forma nombre@nommaq donde nombre es el login del usuario ynommaq es el nombre de la máquina en la cual está registrado el usuario. nommaq puedeestar dado como nombre de dominio o como direccion IP. (Estos conceptos se ven aprofundidad en Sistemas Abiertos o con menos profundidad en Sistemas Distribuidos).

Entonces, para enviar un correo al usuario vicman se teclea:mail vicmany se empieza a teclear el mensaje a enviar línea por línea. Cuando se haya terminado

de teclar el mensaje se teclea como primer carácter de la línea un punto y luego Enter.

Si por ejemplo el contenido del mensaje ya se encuentra almacenado en un archivo sele puede indicar al comando mail que lo tome de ahí de la siguiente forma:

mail vicman < nomarch

Ejemplo:seit$ mail 88450331HolaAdios

.seit$ cat mensajeHolaAdiosseit$ mail 88450331 < mensaje

Ahora bien, si se teclea el comando mail sin argumentos se pueden ver los correosque se han recibido apareciendo el primero de los mensajes que es nuevo y un indicadorcomo se muestra a continuación:

seit$ mailFrom rsolis Thu Jun 11 11:23 CST 1998Date: Thu, 11 Jun 1998 11:23:58 -0600From: "I.S.C. Roberto Solis Robles" <rsolis>Message-Id: <[email protected]>Content-Length: 12

HolaAdios

?



En este indicador se pueden dar los siguientes comandos:Comando Significado

? Ayuda de los comandosh Muestra una lista de los mensajesd [#] Elimina el mensaje # (por default es el actual)- Muestra el mensaje previo+ Muestra el siguiente mensaje# Muestra el mensaje número #m usuario Envía el mensaje actual a usuario y elimina el mensajeu [#] Desmarca el mensaje # para no borrarlos [nomarch] Salva el mensaje en un archivo (por default el nombre

del archivo es mbox)r Responde al mensaje actualx Salir sin guardar cambiosq Salir eliminando los mensajes marcado y visualizados

4.4.2. Comando finger

El comando finger se usa para obtener datos de los usuarios conectados en elsistema, el comando muestra para cada usuario conectado el login, nombre completo,terminal en la que se encuentra, tiempo de ocio, hora a la que entró y desde donde estáconectado.

seit$ fingerLogin Name TTY Idle When Wherersolis I.S.C. Roberto Solis console 1:08 Wed 09:09 :0rsolis I.S.C. Roberto Solis *pts/7 Thu 10:41 10.2.3.1

Se puede usar el comando finger para determinar los datos de una persona enparticular dando como argumento el nombre de login:

seit$ finger sdelrioLogin name: sdelrio In real life: Sahara del

Rio VenegasDirectory: /home/sdelrio Shell: /bin/shLast login Wed Jun 10 11:08 on pts/7 from seit.itz.edu.mxMail last read Wed Jun 10 11:09:20 1998

Se muestra el login, nombre, directorio, shell, última vez que entró o cuanto tiempoha estado conectado según sea el caso y la última vez que leyó su correo.

También se pueden pedir los datos del usuario de otro sistema poniendo el loginseguido de un @ y luego el nombre de la maquina.

seit$ finger ltorres@mapaches[mapaches.itz.edu.mx]Login: ltorres Name: I.S.C. Luis Torres

HernandezDirectory: /home/personal/ltorres Shell: /bin/bash



Office: Centro de Computo, 45366Last login Wed Jun 10 13:41 (CDT) on ttyp2 from serverNT2.itz.edNew mail received Thu Jun 11 09:08 1998 (CDT) Unread since Wed Jun 10 13:41 1998 (CDT)No Plan.

4.4.3. Comando write

Otro comando para comunicarse con otros usuarios es write el cual permite escribirmensajes en la terminal de otros usuarios siempre y cuando estos tengan activada talcaracterística.

Para escribir por ejemplo en la terminal de sdelrio se teclea:write sdelrioY todo lo que se teclee se verá también en la terminal del usuario. Para terminar se

teclea Ctrl-D.Si el usuario se encuentra trabajando en varias sesiones para poder enviarla a una

terminal dada se da como segundo argumento el nombre de la terminal, por ejemplo:write sdelrio pts/4

Para usar este comando se requiere que el usuario este conectado.

Para ver si un usuario tiene activado el permiso de escribir se puede usar el comandofinger y si el campo de terminal está precedido por un * el usuario no permite que se leenvíen mensajes con write.

Un usuario puede ver si puede recibir mensaje usando el comando mesg. El comandomuestra n si no se permiten mensajes o y si lo permite. Para cambiar esto se puede dar comoargumento a mesg una n para no aceptar o una y para aceptar.

seit$ mesgis nseit$ mesg yseit$ mesgis y

4.4.4. Comando talk

Otro comando para establecer una comunicación es el comando talk. La sintaxis es:talk usuarioLa comunicación que se establece es en tiempo real a diferencia del correo

electrónico por lo que se requiere que el usuario esté conectado y que acceda dando elcorrespondiente talk usuario. También se requiere que ambos tengan activados losmensajes. Una vez que se establece la comunicación la pantalla se divide en dos, en una seve lo que tecla el usuario local y en la otra la del usuario remoto. Para terminar se tecleaCtrl-C.



4.5. Filtros

Un filtro es un programa que toma un archivo como entrada, le hace ciertastransformaciones tales como eliminar líneas, sustituir, ordenar y genera como salida elresultado de tal transformación.

4.5.1. Comando cut

Este comando sirve para extraer las columnas o campos de las líneas de un archivo.Los campos pueden ser de longitud variable o de longitud fija. Sus opciones pueden ser lassiguientes:

Opción Significado-d delimitador Para indicar que carácter se usa de delimitador de campos (Por

default es el tabulador)-f campos Para indicar los campos que se quieren extraer (uno o varios campos

separados por coma).Los campos se pueden especificar de manerasimple o como un rango x-y.

-c posiciones Para indicar las posiciones de carácter a extraer (una o variasseparadas por coma), las posiciones se pueden especificar simples ocomo un rango x-y

Para especificar la extracción de campos de longitud fija se usa la opción -c. Paraespecificar la extracción de campos de longitud variable se usa la opción -f para indicar quecampos en combinación con la opción -f para indicar que carácter los separa.

Veamos algunos ejemplos:seit$ cat nombres.datSahara del Rio VenegasFabiola Ortega RoblesLiliana Cardenas RiveraXochitl Raygoza FierrosVictor Ba~uelos AlvarezGuillermo Martinez HernandezFrancisco Garcia LuevanoCarlos Macias SoteloCarlos Ordaz GarciaErika Perez Martinezseit$ cut -c1-6 nombres.datSaharaFabiolLilianXochitVictorGuilleFranciCarlosCarlosErika



seit$ cut -c1-6,12-15 nombres.datSaharaRioFabiolegaLiliandenaXochitgozaVictorelosGuilleartiFranciarciCarlosas SCarlosz GaErika Mar

Se muestra primero el contenido del archivo nombres.dat, posteriormente con elprimer cut se extraen los caracteres del 1 al 6 de cada línea, y en el segundo cut se extran loscaracteres del 1 al 6 y del 12 al 15. Esto es lo que se haría para campos de longitud fija.

seit$ cut -f1 -d' ' nombres.datSaharaFabiolaLilianaXochitlVictorGuillermoFranciscoCarlosCarlosErikaseit$ cut -f1,3 -d' ' nombres.datSahara RioFabiola RoblesLiliana RiveraXochitl FierrosVictor AlvarezGuillermo HernandezFrancisco LuevanoCarlos SoteloCarlos GarciaErika Martinez

Ahora vemos un ejemplo de campos de longitud variable, en tal caso es necesarioespecificar cual es el carácter que delimita los campos (en estos ejemplo el espacio enblanco) con la opción -d y con la opción -f en el primer cut se extrae el primer campo y en elsegundo cut el primer y tercer campos.

Si al comando cut no se le da el nombre de algún archivo como parámetro entoncesse toman los datos de la entrada estándar y se termina con Ctrl-C:seit$ cut -f1,4 -d' 'Ingenieria en Sistemas ComputacionalesIngenieria ComputacionalesInstituto Tecnologico de ZacatecasInstituto Zacatecas^C



4.5.2. Comando paste

El comando paste sirve para concatenar las líneas de los archivos de entrada enforma de columna al reemplazar el avance de línea por un TAB en todos los archivos aexcepción del último dado y generar de salida las líneas resultantes.

seit$ cut -f1 -d' ' nombres.dat > nom.datseit$ cut -f2 -d' ' nombres.dat > nom2.datseit$ cat nom.datSaharaFabiolaLilianaXochitlVictorGuillermoFranciscoCarlosCarlosErikaseit$ cat nom2.datdelOrtegaCardenasRaygozaBa~uelosMartinezGarciaMaciasOrdazPerezseit$ paste nom.dat nom2.datSahara delFabiola OrtegaLiliana CardenasXochitl RaygozaVictor Ba~uelosGuillermo MartinezFrancisco GarciaCarlos MaciasCarlos OrdazErika Perez

En el ejemplo se puede ver que primero se extra el primer campo del archivonombres.dat y se almacena en el archivo nom.dat, posteriormente se extrae el segundocampo y se almacena en el archivo nom2.dat, y al aplicarle el comando paste a los dosarchivos los combina en la salida poniendo en cada línea la fusión de las líneascorrespondientes de ambos archivos.

4.5.3. Comando sort

El comando sort sirve para ordenar o fusionar archivos. Tiene como argumentos elnombre de los archivos a ordenar y sus opciones pueden ser las siguientes:



Opción Significado-r Ordena en forma descendente-f Para la conversión convierte todo a mayúscula+n Ordena empezando por el campo n, cada campo

separado por un espacio, el primer campo es el 0, si nose delimita se evalúa hasta el final de la línea

-t char Se usa para especificar el carácter char que se usa comoseparador de los campos

-o nomarch Especifica el nombre del archivo en el cual sealmacenará la salida. Usada si no se desea que la salidasea enviada a la salida estándar

seit$ sort nombres.datCarlos Macias SoteloCarlos Ordaz GarciaErika Perez MartinezFabiola Ortega RoblesFrancisco Garcia LuevanoGuillermo Martinez HernandezLiliana Cardenas RiveraSahara del Rio VenegasVictor Ba~uelos AlvarezXochitl Raygoza Fierrosseit$ sort nom.dat nom2.datBa~uelosCardenasCarlosCarlosErikaFabiolaFranciscoGarciaGuillermoLilianaMaciasMartinezOrdazOrtegaPerezRaygozaSaharaVictorXochitldel

Para ordenar por el segundo campo el archivo nombres.dat:seit$ sort +1 nombres.datVictor Ba~uelos AlvarezLiliana Cardenas RiveraFrancisco Garcia LuevanoCarlos Macias SoteloGuillermo Martinez HernandezCarlos Ordaz GarciaFabiola Ortega Robles



Erika Perez MartinezXochitl Raygoza FierrosSahara del Rio Venegas

Para que el resultado se guarde en un archivo:seit$ sort +1 nombres.dat -o nomorde.datseit$ cat nomorde.datVictor Ba~uelos AlvarezLiliana Cardenas RiveraFrancisco Garcia LuevanoCarlos Macias SoteloGuillermo Martinez HernandezCarlos Ordaz GarciaFabiola Ortega RoblesErika Perez MartinezXochitl Raygoza FierrosSahara del Rio Venegas

4.5.4. Comando diffEl comando diff compara el contenido de los dos archivos nomarch1 y nomarch2

que se dan como argumento al comando y escribe en la salida estándar una lista de cambiosnecesarios para convertir nomarch1 en nomarch2. Ninguna salida será generada si losarchivos son idénticos. La salida normal contiene líneas de las siguientes formas:

n1 a n3,n4 n1,n2 d n3 n1,n2 c n3,n4

donde n1, n2 representan los números de línea en nomarch1 y n3 y n4 son números de líneaen nomarch2. Estas líneas se parecen a comandos del editor ed para convertir nomarch1 ennomarch2.

Siguiendo a estas líneas vienen todas las líneas que son afectadas en el primer archivomarcadas con un ‘<’ y después todas las líneas que son afectadas en el segundo archivomarcadas con un ‘>’.

Si se le da la opción -e solamente se generan los comandos de ed para convertirnomarch1 en nomarch2, lo cual puede ser utilizado como entrada al comando ed pararealizar los cambios.seit$ cat archivo1Ingenieria en SistemasLicenciado en InformaticaArquitecturaIngenieria IndustrialIngenieria ElectromecanicaIngenieria en MaterialesLicenciado en Administracionseit$ cat archivo2Ingenieria en SistemasLicenciado en InformaticaArquitecturaIngenieria IndustrialIngenieria Electro-mecanicaIngenieria en Materiales



Licenciado en Administracionseit$ diff archivo1 archivo25c5< Ingenieria Electromecanica---> Ingenieria Electro-mecanicaseit$ diff -e archivo1 archivo25cIngenieria Electro-mecanica.

Se muestra en el ejemplo primero el contenido de los dos archivos Archivo1 yArchivo2, posteriormente el comando diff sin opciones muestra primeramente una línea 5c5indicando que se debe cambiar la línea 5 de Archivo1 a la línea 5 de Archivo2 para queambos queden iguales dando posteriormente como es la línea en Archivo1 y por últimocomo es la línea en Archivo2.

En el segundo diff se usa la opción -e lo cual genera de salida los comandos que sedeberían de dar en ed para que Archivo1 se convierta en Archivo2.

4.5.5. Comando grep

El comando grep sirve para buscar un patrón en un archivo e imprime todas laslíneas que contienen el patrón. Su sintaxis es la siguientes:

grep exprreg archivo(s)

Donde exprreg es una expresión regular que describe el patrón que deseamos buscary archivo(s) es el nombre del archivo u archivos en los cuales queremos hacer la búsqueda.Hay que tener cuidado en usar los caracteres $, *, [, ^, |, (, ), y \ pues tienen unsignificado en el shell. Es más seguro encerrarla entre apostrófos.

Si no se especifican archivos de entrada se asume que los datos vienen de la entradaestándar. Normalmente, cada línea encontrada es copiada a la salida estándar. El nombre delarchivo es normalmente antes de cada línea si hay más de un archivo de entrada.

seit$ grep 'Carlos' nombres.dat nom.datnombres.dat:Carlos Ordaz Garcianombres.dat:Carlos Macias Sotelonom.dat:Carlosnom.dat:Carlos

Las opciones que grep puede tener son:Opción Significado

-c Despliega el número de líneas que contiene el patrón-l Reporta sólo los nombres de los archivos que contienen el

patrón.-i No hace diferencia entre mayúsculas y minúsculas-n Pone el número de línea antes de la línea encontrada



-v Despliega las líneas que no contienen el patrón

seit$ grep -in '^C' nombres.dat8:Carlos Ordaz Garcia10:Carlos Macias Soteloseit$ grep -v 'Carlos' nombres.datSahara del Rio VenegasFabiola Ortega RoblesLiliana Cardenas RiveraXochitl Raygoza FierrosVictor Ba~uelos AlvarezGuillermo Martinez HernandezFrancisco Garcia LuevanoErika Perez Martinez

En el primer ejemplo se muestran las líneas así como el número que tienen quecontienen al inicio una letra C (sea minúscula o mayúscula).

En el segundo ejemplo se muestran las líneas del archivo nombres.dat que nocontienen la cadena Carlos.

4.5.6. Comando uniq

Este comando lee un archivo de entrada y compara las líneas adyacentes escribiendosolo una copia de las líneas a la salida. La segunda y subsecuentes copias de las líneas deentrada adyacentes repetidas no serán escritas. Las líneas repetidas no se detectarán a menosque sean adyacentes. Si no se especifica algún archivo de entrada se asume la entradaestándar.

seit$ cat repetidosIngenieriaLicenciadoArquitecturaIngenieriaIngenieriaIngenieriaLicenciadoseit$ uniq repetidosIngenieriaLicenciadoArquitecturaIngenieriaLicenciado

Se puede ver en este ejemplo que el comando solo detecto la repetición de“Ingenieria” cuando estaban adyacentes, pero las que no estaban adyacentes tal como“Licenciado” no se detectan.

En cambio, si le aplicamos un sort y le pasamos el resultado a uniq quedaría comosigue:seit$ sort repetidos | uniqArquitectura



IngenieriaLicenciado

El comando uniq tiene las siguientes opciones:Opción Significado

-c Precede a cada línea con un conteo de las veces que apareceen la entrada

-d Suprime el despliegue de las líneas que no se repiten-u Suprime el despliegue de las líneas que se repiten

seit$ sort repetidos | uniq -c 1 Arquitectura 4 Ingenieria 2 Licenciadoseit$ sort repetidos | uniq -dIngenieriaLicenciadoseit$ sort repetidos | uniq -uArquitectura

4.5.7. Comando sed

El comando sed es un editor de flujos que lee uno o mas archivos de texto, hacecambios o ediciones de acuerdo a un script de comandos de edición y escribe los resultadosa la salida estándar. El script es obtenido del argumento de ordenes o con la opción -f seindica de que archivo tomarlas.

Su sintaxis es:sed ordenes archivo(s)osed -f archordenes archivo(s)

Las ordenes o script consisten de comando que utilizan el formato vistoanteriormente con el comando ed :

[direccion1, [direccion2]] comando [argumentos]

Las direcciones se espefican de la misma forma que en ed.Se pueden dar múltiples comandos separandolos con punto y coma. Los comandos

que tiene el sed son los siguientes:Comando Significado

d Elimina líneap Despliega líneaq Abandonars/str1/str2/flag Sustituye str1 por str2, si flag=g entonces se reemplazan

todas las ocurrencias= Despliega el número de línea actualw nomarch Escribe línea actual en nomarchr nomarch Lee el contenido de nomarch y lo despliega



y/str1/str2/ Reemplaza cada carácter que esté en str1 con elcorrespondiente de str2

Se le puede anteponer un ! al comando cuando la dirección es una patrón a buscarpara indicar que se ejecute cuando el patrón no se encuentre.

Si no se desea que aparezcan las líneas en la salida más que las indicadas en el scriptentonces se le pone la opción -n.

seit$ sed '/Carlos/p' nombres.datSahara del Rio VenegasFabiola Ortega RoblesLiliana Cardenas RiveraXochitl Raygoza FierrosVictor Ba~uelos AlvarezGuillermo Martinez HernandezFrancisco Garcia LuevanoCarlos Ordaz GarciaCarlos Ordaz GarciaErika Perez MartinezCarlos Macias SoteloCarlos Macias Soteloseit$ sed -n '/Carlos/p' nombres.datCarlos Ordaz GarciaCarlos Macias Sotelo

En el primer sed se puede ver que se pide se muestren todos las líneas que contenganCarlos, pero como por default se imprime cada línea las líneas que contengan Carlos semuestran 2 veces. Si le ponemos la opción -n ya no se muestran las líneas mas que las que sepide explícitamente en el string.

seit$ sed '1,2d;y/aeiou/uoiea/' nombres.datLiliunu Curdonus RivoruXechitl Ruygezu FiorresVicter Bu~aoles AlvurozGaillorme Murtinoz HornundozFruncisce Gurciu LaovuneCurles Orduz GurciuEriku Poroz MurtinozCurles Mucius Setole

En este ejemplo de sed se pide se elimine las líneas de la 1 a la 2 y posteriormentecambie las ‘a’ por ‘u’, las ‘e’ por ‘o’, las ‘i’ quedan igual, las ‘o’ por ‘e’ y las ‘u’ por ‘a’.

Los comandos se pueden tener en un archivo y especificarle al sed de que archivohay que tomar las ordenes. Las ordenes en el archivo se encuentran una por línea.

$ cat scriptsed1,2dy/aeiou/uoiea/$ sed -f scriptsed nombres.datLiliunu Curdonus Rivoru



Xechitl Ruygezu FiorresVicter Bu~aoles AlvurozGaillorme Murtinoz HornundozFruncisce Gurciu LaovuneCurles Orduz GurciuEriku Poroz MurtinozCurles Mucius Setole

sed es adecuado para manejar entradas arbitrariamente grandes, porque se parecenucho a ed en sus expresiones regulares y procesamiento de una línea a la vez y porque esrápido; sin embargo, tiene limitaciones tales como: ofrece un forma bastante reducida dememoria , solo hace un paso sobre los datos, no es posible hacer referencia hacia adelante ohacia atrás y tampoco proporciona recursos para manipular números: no es mas que uneditor de texto.

4.5.8. Comando awk

Algunas de las limitaciones de sed se remedian por medio de awk. La idea de awk separece mucho a la de sed, pero los detalles se basan más en el lenguaje de programación Cque en un editor de textos. El nombre viene de las iniciales de sus tres autores, Al aho, PeterWeinberger y Brian Kernighan. Es un lenguaje interpretado.

El comando awk tiene el siguiente formato:awk [-Fc] [ -f prog | ‘programa’ ] [archivo(s)]

Aunque cualquiera de los argumentos u opciones puede ser omitido, al menos unodebe proporcionarse en la línea de comando: puede escribir las instrucciones en un archivo ydespués especificarle al awk que archivo las contiene con la opción -f o bien se puedenescribir al momento de llamar a awk en la línea de comandos.

awk trabaja sobre campos del archivo de entrada. Por default, los campos de unalínea se asume estan separados por un espacio (blanco o un tabulador). Se puede espeficarotro separador con la opción -F.

Por default, awk lee su entrada de la entrada estándar si no se da como argumentoalgún nombre de archivo. Cuando se dan múltiples archivos awk los trata como si estuvieranconcatenados, automáticamente cerrando uno y abriendo el siguiente hasta que se llega alúltimo archivo.

Las sentencias en el lenguaje toman la forma general:

patrón { acción }...



Ambas partes son opcionales pero una de ellas debe estar presente. Si se omite laparte de patrón la parte de acción siempre se ejecuta. De otra forma, la parte de acción seejecuta sólo cuando el patrón concuerda con la línea actual de la entrada. Si se omite laparte de acción, la acción por default es realizada, la cual imprime la línea actual de laentrada (en la salida estándar)

awk ejecuta un ciclo de procesamiento automático para cada línea de entrada quelee. Su programa awk no necesita describir los pasos de este ciclo y de hecho tiene pocainfluencia sobre el ciclo. En cada cilo, awk hace lo siguiente:

1. Lee la siguiente línea de entrada2. Asigna el texto completo de la línea a la variable simbólica $03. Divide la línea en sus campos4. Asigna el valor del primer campo a la variable simbólica $1, el segundo campo a

$2, y así sucesivamente5. Intenta concordar el patrón dado en el programa con la primer línea.6. Si concuerda, se ejecuta la acción indicada por el programa7. Pasa a la siguiente sentencia del programa y repite la operación de concordancia8. Cuando se ejecuta la última sentencia del programa se pasa a la siguiente línea y

comienza con la primer sentencia.

Formato de los Patrones

Un patrón puede ser tan simple como una /ER/, donde cualquier expresión regularencerrada entre los delimitadores es buscada en cada línea de la entrada. Si el patrón esencontrado en cualquier parte de la línea, la parte de acción de la sentencia es ejecutada; deotra forma, awk simplemente pasa a la siguiente sentencia del programa.

Un patrón puede también ser una expresión lógica formada usando cualquiera de lossiguientes operadores:

== != > >= < <= ~ !~ && ||

A excepción de ~ y !~, todos tienen la misma interpretación que en el C. El operador~ significa contiene y el operador !~ significa no contiene.

seit$ awk '$1 ~ "Car"' nombres.datCarlos Ordaz GarciaCarlos Macias Sotelo

Hay dos patrones especiales: BEGIN y END. BEGIN sirve para especificar accionesa realizar antes de empezar a procesar la primera línea y END sirve para especificar accionesa realizar después del procesamiento de la última línea.

Formato de las acciones

Las acciones son en realidad pequeños programas. Una acción puede consistir decualquier número de instrucciones separados por avances de línea o por punto y coma.



Como con los lenguajes de programación, awk soporta el uso de variables y valoresliterales. Excepto por los valores de los campos de la línea actual, que son representados por$0, $1, $2, …$n, todos los nombres de variables se requieren sean una secuencia de letras ydígitos, el primero de los cuales debe ser letra.

Hay dos tipos de valores literales: literales de string y literales numéricas. Un stringliteral es una secuencia arbitraria de caracteres encerrada en comillas. La expresión “ABC”es una literal string válida, ‘ABC’ causa un error de sintaxis y ABC se toma como el nombrede una variable. Una literal numérica es cualqueir secuencia de dígitos, posiblementeconteniendo un punto decimal. Note que awk soporta la aritmética en punto flotante.

Una instrucción awk puede ser de los siguientes tipos:

var = expLa sentencia de asignación calcula el valor de una expresión y asigna el resultado ala variable en la izquierda del signo =. Las expresiones se escriben usando losoperadores de C mostrados en la siguiente tabla.

Operador Significado+ Suma- Resta* Multiplicación/ División% Residuo++ Incremento-- Decrementoespacio Concatenación de cadenas+= Agregar a variable-= Restar a variable*= Multiplicar por variable/= Dividir la variable

if (exp) sentencia1 [else sentencia2]Si la expresión exp se evalúa a un valor distinto de cero (verdadero) se ejecuta lasentencia 1, de otra manera se ejecuta la sentencia2 en caso de existir el else

while (exp) sentenciaLa sentencia se ejecuta mientras exp sea verdadera

for (exp1; exp2; exp3) sentenciaLa expresión exp1 se ejecuta al inicio del ciclo (solo la primera vez), y la expresiónexp3 se ejecuta después de cada iteración del ciclo, el cual se repite mientras exp2sea verdadera

break



Inmediatemente sale del ciclo

continueInicia inmediatemente la siguiente iteración del ciclo actual, ignorando las restantesinstrucciones en el ciclo

print exp [ [,] exp …]Cada uno de los exp es calculado e impreso como una línea de la salida estándar. Losvalores separados por coma se separan por un espacio en la línea, los que no seseparan se ponen juntos en la línea.

print formato [, exp …]Los valores de cada exp son calculados y sustituidos en el string formato de acuerdoa las reglas del printf de C.

nextEl procesamiento de las líneas restantes de la sentencia actual y todas las sentenciasrestantes en el programa awk son inmediatamente saltadas. El procesamientocontinua en la forma normal con la siguiente línea de la entrada.

exitEl procesamiento del archivo de entrada y el programa awk son inmediatamenteterminados.

Hay un conjunto de variable interconstruidas, los valores de las cuales sonautomáticamente asignadas y mantenidas por awk. Estas variables son:

Variable SignificadoFS El carácter separador de campo como se especifico por la opción -FFILENAME La ruta del archivo actualNF Número de campos en la línea actualNR Número de línea de la línea actualOFMT El formato de los números escritos por la instrucción print, por default

es %.6gOFS El separador de campos en la salida. El valor por defautl es el espacioORS El separador de registros desplegado por el print al final de cada línea.

Por default es el carácter de avance de línea

awk también reconoce un número de funciones ya hechas que pueden ser usadascuanodo se permita una expresión, incluyendo el patrón de una sentencia. Estas funcionesson:

Función Significadolength(exp) Longitud en caracteres del string expsplit(s,a [,d]) El string s es partido en campos usando el primer carácter del string d,

o el valor de FS si se omite d. Cada uno de los campos es almacenado



en elementos sucesivos del arreglo denominado a empezando con elelemento 1. El valor de la función es el número de camposalmacenados. Así, split(“10/16/91”,dt,”/”) tiene un valor de 3 y losvalores “10”, “16” y “91” son almacenados en cada una de lasposiciones de dt.

substr(s,m [,n]) Obtiene la secuencia de caracteres empezando en la posición m (elprimero es el 1) del string s y extendiendose por una longitud de ncaracteres. Si n se omite, se toma la longitud restante de s

index(s1,s2) Regresa la posición en la que empieza s2 dentro de s1 o 0 si s2 no estaen s1

getline Regresa 0 si ocurrió un fin de archivo cuando se intenta leer lasiguiente entrada o 1 si si se pudo, quedando en NR y los parámetros$0, $1, etc los valores correspondientes a la nueva línea



5. PROGRAMACION DEL SHELL BOURNE

Así como se usa el shell para ejecutar comandos también se puede usar su lenguajede programación interconstruido para escribir sus propios comandos o programas. Sepueden poner los comandos en un archivo -conocido como shell script - y entonces ejecutarese archivo como cualquier otro comando o programa.

Se puede ver pues que la programación del shell:• Permite abreviar los comandos más utilizados• Permite definir alias de los comandos más utilizados• Simplifica la ejecución de comandos complejos• Permite crear nuevos comando, los cuales irán de acuerdo a las necesidades del

usuario

La programación del shell es utilizada para la elaboración de herramientas y órdenesnecesarias para la administración del sistema. Normalmente, los diseñadores del sistemaescriben una aplicación en el lenguaje de programación shell cuando la eficiencia y velocidadde tiempo de ejecución son menos importantes que el construir una aplicación fácil deentender y modificar; sin embargo, el shell moderno obtiene excelentes rendimientos alejecutar los shell scripts.

5.1. Ordenes multilínea

Cuando se escribe una línea para el shell, esta puede ser más larga que el ancho de laterminal. Mientras no se de ENTER la mayoría de las terminales continuarán en el ladoizquierdo de la línea siguiente de la pantalla y se podrá proseguir introduciendo la orden.Cuando se de ENTER, el shell comenzará a procesar la línea. Además, el shell permite quelas órdenes se extiendan por más de una línea. Esto es útil si se desea segmentar una ordenpor razones de legibilidad. Se puede continuar una orden en una segunda línea (o enmúltiples líneas) introduciendo una diagonal inversa (\) como último carácter de la líneaantes del ENTER. De este modo se elimina la interpretación que el shell da al ENTER y secontinúa en la línea siguiente. Una orden multilínea también se genera si se abren comillas oapóstrofos y se da ENTER antes de cerrarlos (para algun parámetro por ejemplo).

En cualquier caso, el shell almacena la parte de la orden ya introducida y visualiza unindicador diferente (normalmente >, el cual es dado por el valor de la variable PS2), como semuestra a continuación:

seit$ echo 'Hola que> tal'Hola quetalseit$ echo Hola que \> talHola que tal



El primer echo se convierte en un comando multilínea al no cerrar los apóstrofos, yel segundo por haber puesto un \ como último carácter de la línea.

5.2. Documentos incluidos (Here Documents)

El shell trata a cualquier comando que se introduce en múltiples líneas como si fuerauna sola línea; sin embargo, el indicador PS2 también puede aparecer en otro caso, eloperador << nombre, el cual introduce un documento incluido, denominado de esta maneraporque los datos de entrada están “incluidos” en la orden en vez de estar almacenados en unarchivo. El nombre puede ser cualquier cadena de caracteres y el << actúa análogamente aloperador de redirección normal de un archivo. No se permiten espacios en blanco en elnombre. A continuación del operador <<nombre, comenzados en la línea siguiente,aparecen los datos efectivos que el comando va a leer. Una línea que solo contenga nombrefinaliza el documento incluido.

seit$ cat <<FINAL> Asi es> esto es una prueba> de un documento incluido> FINALAsi esesto es una pruebade un documento incluido

5.3. Sustitución de comandos

Para incluir la salida de un comando dentro de la línea de comando de otro seencierran los comandos cuya salida va a ser incluida en la salida con apóstrofos inversos (`).Por ejemplo:

echo La fecha actual es `date +%d/%m/%y`La fecha actual es17/05/95

La salida del comando date +%d/%m/%y es sustituida en la localidad apropiadadentro de una línea de comando que usa el comando echo.

5.4. Comentarios en un shell script

Los shell scripts, especialmente los largos y complejos, necesitan generalmente decomentarios para recordar a quienes los leen que es lo que hacen. El operador # se utilizapara introducir un comentario en un shell script. El shell ignora todo los que haya en lamisma línea de comando a continuación del carácter #.



Los comentarios son muy valiosos en el mantenimiento de los shell script y nocuestan nada en términos de rendimiento.

5.5. Creación y ejecución de un shell script

Para crear un shell script se siguen los siguientes pasos:1. Se hace uso de vi o cualquier otro editor para escribir los comandos que se

quieran incluir en el shell script.2. Se almacenan tales comandos en un archivo3. Se le da permiso de ejecución al archivo almacenado (y de lectura) en cada uno de

los elementos a los que se quiera dar permiso (usuario, grupo y otros)

Para ejecutarlo se puede hacer llamando al shell (sh) y pasándole como argumento elnombre del archivo (en tal caso no es necesario que tenga permiso de ejecución el archivo),o bien, simplemente se escribe el nombre del archivo a ejecutar (o su ruta absoluta o relativasi es que se encuentra en algún directorio que no este en los directorios de búsqueda).

Un ejemplo de script shell con algunas de las características mencionadas es elsiguiente, el cual muestra la fecha, hora, nombre de usuario (login) y directorio actual.

seit$ cat display# Este script despliega la fecha, hora, nombre de usuario# y directorio actualecho "Fecha y hora: \c"dateechoecho "Su nombre de usuario es: `whoami` \n"echo Su directorio actual es: `pwd`

Hay que hacer notar que el \c en el comando echo hace que no avance de línea unavez generada la salida.

El archivo se denomina display, y se puede ejecutar una vez editado llamando alshell:seit$ ls -l display-rw-r--r-- 1 rsolis staff 196 Jul 1 10:22 displayseit$ sh displayFecha y hora: Wed Jul 1 11:53:06 CST 1998

Su nombre de usuario es: rsolis

Su directorio actual es: /home/rsolis

Se puede ver que no tiene permisos de ejecución, pero se puede ejecutar pues estamanera no los requiere; sin embargo, si se intenta ejecutar poniendo solo el nombre delarchivo (display) entonces se generará un error.

seit$ display



display: execute permission denied

Este error se debe a que no se puede ejecutar por falta de permiso para tal efecto.Por lo tanto, para poder ejecutarlo de esta forma se necesita darle permisos de ejecución:

seit$ chmod a+x displayseit$ ls -l display-rwxr-xr-x 1 rsolis staff 196 Jul 1 10:22 displayseit$ displayFecha y hora: Wed Jul 1 11:57:19 CST 1998

Su nombre de usuario es: rsolis

Su directorio actual es: /home/rsolis

Es una buena costumbre indicar en la primera línea de todo script shell el shell que lodebe ejecutar, lo cual evita que se generen errores si se ejecuta desde un shell distinto al quese programó. Para ello, en la primer línea se usa la siguiente sintaxis:#!ruta_absoluta_shell

donde ruta_absoluta_shell es la ruta en la que se encuentra el shell que debe interpretar oejecutar el shell script. Así, si se usa el shell de Bourne, el cual se encuentra en el directorio/bin, la primera línea sería:#!/bin/sh

Se debe hacer notar que cuando se ejecuta un shell script se crea un proceso shellpara interpretar el shell script separado del de la sesión abierta, por lo tanto, las variables delshell se heredan y si se cambian en el shell script, estos cambios solo son reconocidos por elshell que hizo los cambios, para que tales cambios se reflejen en posteriores comandos o enel shell de la sesión se debe hacer una operación de exportación con el comando export elcual tiene la sintaxis export variable y se debe ejecutar anteponiendo un punto y un espacioal nombre del archivo. Veamos un ejemplo de esto:

seit$ cat cambiavar#!/bin/sh# Este shell script simplemente cambia el valor de la variable PS2

PS2="Siguele >"echo $PS2seit$ echo $PS2>seit$ cambiavarSiguele >seit$ echo $PS2>

Se puede ver que el script cambiavar modifica el valor de la variable PS2 a “Siguele>” y lo muestra en pantalla, antes y después de la ejecución del script el valor de PS2 es “>”ya que los cambios solo son para el shell script, en cambio si agregamos al final del shell



script el comando para exportar la variable PS2 entonces el cambio queda para todos losshell de la sesión:

seit$ cat cambiavar#!/bin/sh# Este shell script simplemente cambia el valor de la variable PS2

PS2="Siguele >"echo $PS2export PS2seit$ echo $PS2>seit$ . cambiavarSiguele >seit$ echo $PS2Siguele >

5.6. Variables utilizadas en los shell script

Aparte de las variables de ambiente ya mencionadas con anterioridad se tiene otrasvariables que se usan en la programación del shell como son las variables posicionales yotras variables especiales. Las variables posicionales son usadas para referirse a losargumentos que se le hayan dado al shell script, se puede hacer referencia a 9 parámetros deeste tipo, mediantes las variables $1, $2, …, $9. La variable $0 hace referencia al nombre delshell script. Otras variables especiales son las mostradas en la siguiente tabla:

Variable Significado$# Número de argumentos$? Valor regresado por el último comando ejecutado

(Código de retorno)$* Todos los argumentos

También se pueden crear nuevas variables mediante la asignación:variable=valor

o bien, mediante una lectura con el comando read.read variable

Cuando se le va a dar un valor o se va a leer una variable no se le antepone el $.

Veamos algunos ejemplos. El primero de ellos muestra la forma de referirse a losargumentos mediante las variables posicionales.

seit$ cat argumentos#!/bin/sh# Este shell script muestra el nombre del shell script y los primeros 3parametros o argumentos

echo El nombre del programa es $0



echo El primer parametro es $1echo El segundo parametro es $2echo El tercer parametro es $3seit$ argumentos nom1 nom2 nom3El nombre del programa es ./argumentosEl primer parametro es nom1El segundo parametro es nom2El tercer parametro es nom3

En el segundo ejemplo se ve el uso de las variables especiales $# y $*:seit$ cat ejemplo2#!/bin/sh# Este shell script despliega el nombre del programa, la cantidad deargumentos que sele pasaron y todos los argumentos

echo En esta llamada al shell script $0 se le pasaron $# argumentosecho Los argumentos son: $*

seit$ ejemplo2 unoEn esta llamada al shell script ./ejemplo2 se le pasaron 1 argumentosLos argumentos son: unoseit$ ejemplo2 uno dosEn esta llamada al shell script ./ejemplo2 se le pasaron 2 argumentosLos argumentos son: uno dos

En el último ejemplo se ve como asignar valores a variables y como se puede leer elvalor de ellas mediante el comando read:seit$ cat ejemplo3#!/bin/sh# Este shell script ejemplifica la asignacion y lectura de variables

echo Se asigna un valor a la variable NuevaNueva=Holaecho El valor que se le dio es $Nuevaecho "Dame el valor a almacenar en la variable Num: \c"read Numecho El valor que tecleaste es $Num

seit$ ejemplo3Se asigna un valor a la variable NuevaEl valor que se le dio es HolaDame el valor a almacenar en la variable Num: 25473El valor que tecleaste es 25473

5.7. La sentencia if

Esta sentencia permite evaluar condiciones y ejecutar acciones dependiendo delresultado de la evaluación. La sintaxis es la siguiente:

if expresion ; then comandos ; fi



Los comandos pueden ir en varias líneas (de hecho si va un comando en cada líneano se requiere del punto y coma antes del fi). La expresión es cualquier expresión lógica oun comando que devuelve un valor. Si devuelve un cero (verdadero), los comandos quesiguen a then son ejecutados, hasta que aparece fi.

Existen dos sentencias especiales: true, la cual siempre devuelve el valor verdadero(cero) y false la cual siempre devuelve el valor falso (diferente de cero).

En el caso de que se requiere hacer algo cuando la expresión sea falsa, se puedeutilizar la cláusula else. Los comandos que siguen al else se ejecutan cuando la expresióndevuelve un valor distinto de cero. La sintaxis es ahora:

if expresion ; then comandos ; else comandos; fi

El else puede ir seguido de construcciones if adicionales. Estas se introducen demanera abreviada con elif (else if). La sintaxis es ahora:

if expresion ; then comandos ; elif expresion ; then comandos; fi

5.8. La sentencia test

test permite evaluar una condición e indica el resultado de la evaluación por sucódigo de retorno. Un código de cero indica que el resultado de la evaluación fue verdaderay un valor de 1 que fue falso. Existen 2 formas de utilizar el test:

test condicion[ condicion ]

En la segunda forma, los corchetes son argumentos separados por espacios.

test tiene las siguientes primitivas para construir condiciones:Primitiva Función

-r nomarch Verdadero si el archivo nomarch existe y si se puede leer-w nomarch Verdadero si el archivo nomarch existe y si se puede escribir-x nomarch Verdadero si el archivo nomarch existe y si es ejecutable-f nomarch Verdadero si el archivo nomarch existe y si es un archivo regular-d nomarch Verdadero si nomarch existe y es un directorio-h nomarch Verdadero si nomarch existe y es un enlace suave o simbólico-c nomarch Verdadero si nomarch existe y es un archivo de carácter-b nomarch Verdadero si nomarch existe y es un archivo de bloque-s nomarch Verdadero si nomarch existe y tiene una longitud > cero-z string Verdadero si la longitud de string es cero-n string Verdadero si la longitud de string no es cerostr1 = str2 Verdadero si el string str1 es igual al string str2str1 != str2 Verdadero si el string str1 no es igual al string str2str1 Verdadero si str1 no es un string nuloexp1 -eq exp2 Verdadero si los enteros exp1 y exp2 son algebraicamente

iguales



exp1 -ne exp2 Verdadero si los enteros exp1 y exp2 no son algebraicamenteiguales

exp1 -gt exp2 Verdadero si el entero exp1 es algebraicamente mayor que exp2exp1 -ge exp2 Verdadero si el entero exp1 es algebraicamente mayor o igual

que exp2exp1 -lt exp2 Verdadero si el entero exp1 es algebraicamente menor que exp2exp1 -le exp2 Verdadero si el entero exp1 es algebraicamente menor o igual

que exp2

Se tienen los siguientes operadores para combinar estas primitivas:Operador Función

! Operador de negación (NOT)-a Operador AND-o Operador OR( condicion ) Los paréntesis se usan para agrupar y como tienen un

significado para el shell deben precederse con un \

Como ejemplo de estas sentencias (if y test) hagamos un shell script al cual se lepasen 2 argumentos, el primero indicara una cadena a buscar y el segundo el archivo en elcual se buscara. El shell script debe desplegar si se encuentra o no la cadena. Esta claro quepara esto requerimos el uso del comando grep, el cual regresa un cero si encuentra lacadena. Entonces, el shell script quedaría de la siguiente manera:

seit$ cat ejemplo4#!/bin/sh# Este shell script busca una cadena dada dentro de un archivo e indicasi se encuentra o no.

grep $1 $2 >/dev/null 2>/dev/null # La salida se envia al dispositivonulo

if [ $? -eq 0 ] ; then echo La cadena \"$1\" si se encuentra en el archivo $2else echo La cadena \"$1\" no se encuentra en el archivo $2fi

seit$ ejemplo4 cad ejemplo4La cadena "cad" si se encuentra en el archivo ejemplo4seit$ ejemplo4 entrada ejemplo4La cadena "entrada" no se encuentra en el archivo ejemplo4

La línea if [ $? -eq 0 ] ; then pudo ser cambiada por la otra forma del test quedandode la siguiente forma:

if test $? -eq 0 ; then

También, para ahorrarse el test, se pudo poner el comando grep como expresión (yaque su resultado es un número) y quedaría de la siguiente manera:

if grep $1 $2 >/dev/null 2>/dev/null ; then



Ahora, se le pueden hacer mejoras a este shell script tal como verificar que se den 2argumentos y que se cheque si el archivo existe para poder hacer la prueba:

seit$ cat ejemplo5#!/bin/sh# Este shell script busca una cadena dada dentro de un archivo e indicasi se encuentra o no haciendo una comprobacion de los argumentos

if [ $# -ne 2 ] ; then echo Sintaxis $0 cadena nomarchelif [ -r $2 ] ; then grep $1 $2 > /dev/null 2>/dev/null # La salida se envia aldispositivo nulo if [ $? -eq 0 ] ; then echo La cadena \"$1\" si se encuentra en el archivo $2 else echo La cadena \"$1\" no se encuentra en el archivo $2 fielse echo El archivo $2 no existe o no se tienen permisos de lecturafiseit$ ejemplo5Sintaxis ./ejemplo5 cadena nomarchseit$ ejemplo5 cad ejemplo4La cadena "cad" si se encuentra en el archivo ejemplo4seit$ ejemplo5 cad sdsdEl archivo sdsd no existe o no se tienen permisos de lectura

En este shell script primero se determina si se da la cantidad correcta de argumentos(2) y posteriormente se verifica si el archivo dado como segundo argumento existe.

5.9. Sentencia exit

Esta sentencia hace que el shell script (o shell de la sesión) termine con el código deretorno de n (n es un argumento que se le da a exit cuyo valor esta entre 0 y 255). Si seomite n, el código de retorno es el del último comando ejecutado.

Cuando se utilicen códigos de retorno dentro de un shell script, se debe seguir laconvención estándar: las órdenes que terminan correctamente deberían devolver cero. Loscódigos de retorno distintos de cero deberían estar reservadas para distintas condiciones defallo.

5.10. Sentencia expr

Aunque el lenguaje de programación del shell no esta optimizado para cálculosnuméricos, dispone de órdenes que realizan cálculos. La orden expr es la más útil de ellas.Acepta números y operadores aritméticos como argumentos y calcula el resultado,devolviendo la respuesta por la salida estándar, como se muestra a continuación:seit$ expr 4 + 59



Se permiten órdenes mas largas, pero cada parte de la expresión debe estar rodeadapor espacios en blanco, ya que expr trata a cada argumento individual como parte de laexpresión a evaluar. Sólo se permiten enteros y los operadores +, - , *, / y %(residuo). Espreciso anteponer un \ a * y /. Por ejemplo:seit$ expr 5 \* 4 +10 \/225

Se utiliza la precedencia aritmética normal, primero las multiplicaciones y divisionesy posteriormente las sumas y restas.

También se pueden agrupar las expresiones mediante paréntesis, los cuales tambiénque estar precedidos por un \.

expr también realiza operaciones lógicas. Los operadores que se pueden usar son: =,!=, <, <=, >, >=. Devuelve un 1 si es verdadera la expresión o un 0 si no lo es. Si losargumentos para estos operadores son números, se efectúa una comparación numérica; sison cadenas, se efectúa una comparación basada en el código ASCII.

5.11. Sentencia case

La sentencia case tiene la siguiente sintaxis:case word in

patron1)lista_comandos;;

patron2)lista_comandos;;

esac

Se ejecuta la lista de comandos asociada con el primer patrón con el que concuerdeword. Cada patrón debe ser terminado con un ;;. Los patrones son similares a los usadospara la generación de nombres de archivos.

El siguiente ejemplo muestra como se puede limitar a los usuarios a ejecutar solociertos comandos:echo “Dame un comando \c”read cmdcase $cmd

ls|dir)ls ;;

finger)finger ;;

date)date ;;

*)echo Comando invalido



;;esac

Se puede ver que solo se permiten los comandos dir, ls, finger y date comoargumentos, si se da ls o dir se ejecuta ls, si se da finger se ejecuta finger, si se da date seejecuta date y si se da cualquier otro comando (que es como se interpreta el patron *) seemite un mensaje de comando inválido.

El case devuelve como código de retorno el del último comando ejecutado.

5.12. Sentencia for

La sentencia for tiene las siguiente formas:for variable in wordsdo

lista_comandosdone

for variabledo

lista_comandosdone

Este comando ejecuta la lista de comandos para cada una de las palabras separadaspor IFS en words, estableciendo el valor de variable a la siguiente palabra en words en cadaiteración. Si no se da words, el for se ejecuta para cada parámetro posicional establecido enla línea de comandos ($*).

El for devuelve el código de retorno del último comando ejecutado.

5.13. Sentencia while

Su sintaxis es la siguiente:while comandodo

lista_comandosdone

Se ejecuta la lista de comandos mientras el código de retorno de comando sea cero.Si la primer ejecución de comando devuelve un valor distinto de cero, la lista de comandosnunca se ejecuta. Esta sentencia devuelve el código de retorno de la última iteración de lalista de comandos a menos que no se ejecutara ninguno, en cuyo caso se regresa un cero.



5.14. Sentencia until

Su sintaxis es la siguiente:until comandodo

lista_comandosdone

Esta sentencia ejecuta comando y si el código de retorno es distinto de cero, ejecutala lista de comandos. La ejecución continúa hasta que el comando termine con un 0 comocódigo de retorno.

Esta sentencia devuelve el código de retorno de la última iteración de la lista decomandos a menos que no se ejecutara ninguno, en cuyo caso se regresa un cero.

5.15. Funciones

La sintaxis para definir funciones es la siguiente:name(){

comandos}

Las funciones son leídas en el proceso shell actual y son almacenadas internamente.Para llamar a una función, simplemente se da su nombre. El shell ejecuta los comandos entrellaves cuando una función es llamada. Una función tiene acceso a las variables de entornodel shell actual.

El siguiente ejemplo muestra como hacer una función dir que liste los archivos deldirectorio actual:dir(){

ls -l}

Las funciones devuelven el código de retorno del último comando ejecutado a menosque se tenga un return para devolver un código específico (return hace lo mismo que exitpero dentro de una función, es decir, termina la ejecución de una función).

5.16. Sentencia trap

Tiene la siguiente sintaxis:trap [comando] [señal] …



trap establece un comando a ejecutarse cuando el shell recibe una señal. Sinargumentos, trap imprime las trampas (traps) en efecto actualmente. Si no se especifica uncomando, todas las trampas para la señal son restablecidas. Si el comando es nulo (:, ‘’ o“”), este shell y todos los comando que invoque ignorarán la señal. Si la señal es 0, trapejecuta el comando cuando se termine el shell.

Una señal es una solicitud de interrupción. Una señal puede ser generada por elsistema o por un programa de usuario. Una señal es sólo una solicitud, debido a que comoacaba de mencionarse puede ser ignorada por el proceso que la recibe.

Las señales posibles son las siguientes:Señal Significado

0 Salida del shell por cualquier motivo1 Hangup. Esta señal es generada cuando se sale del sistema, se apaga la terminal,

o se de cuelga en una conexión dial-up remota.2 Interrupción. Cuando se presiona la tecla Ctrl-C.3 Quit. Cuando se presiona la tecla Del.15 Terminación por software. Cuando el programa sale.

5.17. Depuración de shell scripts

Si el shell encuentra un error de sintáxis mientras se ejecuta un shell script, termina laejecución y regresa un código distinto de cero. Varios métodos puede ser usados para tratarde encontrar el error.

Primeramente se debe examinar cuidadosamente el shell script para determinar si elprograma es sintácticamente correcto (todos los apóstrofos o comillas en balance, correctaescritura de los comandos, etc).

Después, se puede usar la opción -x del sh o ksh como sigue:seit$ sh -x prog

para imprimir los comandos y sus argumentos conforme son ejecutados. La opción -xtambién puede ser establecida por el comando

set -xen cualquier parte del shell script mismo. Esta opción le permite observar la ejecución delshell script para ver donde esta fallando.

Otro método de depurar es colocar comandos echo en el archivo para imprimirinformación conforme el shell script es ejecutado. También se pueden usar comandos exit envarios lugares para probar porciones específicas del programa y determinar exactamentedonde yace el problema.



6. CONTROL DE PROCESOS

6.1. Introducción

Básicamente, un proceso es una ejecución de un programa. Si escribimos el comandols en la terminal, el sistema crea un proceso para ejecutar el programa ls. Si 3 usuariosdiferentes ejecutan simultáneamente el comando ls en sus terminales; 3 procesos son creadosaún cuando todos los usuarios ejecutan el mismo programa.

De manera similar, si se introduce un pipe, tal comopr report | lp

entonces 3 procesos están involucrados; el proceso del shell activo que lee e interpreta elcomando pipe (tubería); un proceso creado por ese shell para ejecutar el comando pr y otroproceso también creado por el shell para ejecutar el comando lp.

Todos los 3 procesos parece que se ejecutan al mismo tiempo. Sin embargo, en lamayoría de las computadoras no es posible esto literalmente. Una sola computadora puedeejecutar solo una instrucción a la vez, así que ¿cómo hace el sistema para hace que parezcaque se están ejecutando 3 programas a la vez?

Cada uno de los 3 procesos es interrumpido varias veces durante su ejecución, comocuando se solicita un servicio del sistema o cuando otro usuario presiona alguna tecla en suterminal. Cuando un proceso en ejecución es interrumpido, el kernel guarda su estado, queincluye una notación que dice que instrucción sería la siguiente ejecutada por el proceso ytambién el contenido de los registros de la máquina al momento de la interrupción. Habiendoguardado esta información, el kernel esta libre para hacer otras cosas. Más adelante, cuandoel kernel determina que la computadora no tiene nada que hacer, volverá a cargar lainformación almacenada y dejará que la computadora vuelva a la ejecución del procesointerrumpido.

La apariencia de la ejecución simultánea de 2 o más procesos se debe entonces a doscosas:

1. La computadora es muy veloz, así que los retardos en la ejecución de cualquierproceso no son notables generalmente.

2. La mayoría de los programas durante su ejecución tienen que esperar que ocurranciertos eventos externos tales como la lectura de un bloque de bytes del disco.

El concepto de proceso es creado por el sistema operativo y consiste en realidad dela responsabilidad del sistema de regresar a un programa interrumpido. El sistema cumpleesta responsabilidad al apartar un área de memoria para recordar la existencia del proceso ysu estado al tiempo de su interrupción.

Habiendo tomado un mayor paso en la suspensión de programa en ejecución, elkernel, una vez que ha manejado la causa de la interrupción se encuentra con un gran



decisión. Puede haber más de un proceso actualmente esperando ganar control de lamáquina y el kernel debe decidir que proceso interrumpido debe obtener el recurso. Haceresta decisión se denomina planificación (scheduling) de procesos y es una de las funcionesprincipales del kernel.

Debido a que UNIX es un sistema operativo multiusuario, algunas veces forzaactualemente una interrupción del proceso ejecutándose actualmente para evitar que unusuario monopolice la computadora. Cuando eso sucede, el kernel arregla el retardo de talproceso hasta que otros procesos de usuario hayan tenido oportunidad de ejecutarse. Lacantidad máxima de tiempo que el kernel está dispuesto a permitir a un proceso monopolizarel sistema se denomina rebanada de tiempo (time slice). El sistema usa una rebanada detiempo para forzar la compartición de la computadora entre procesos en competencia ysucesivamente roba la computadora de un proceso para prestárselo al siguiente hasta quetodos hayan tenido oportunidad de ejecutarse.

6.2. Componentes de un proceso

Un proceso consiste de un espacio de direcciones t un conjunto de estructuras dedatos dentro del kernel. El conjunto de direcciones es un conjunto de páginas de memoria(bloques de memoria de 1K a 4K) que el kernel ha marcado para el uso del proceso;contiene segmentos para el código, las variables usadas por el proceso, la pila y diversainformación extra necesaria para el kernel mientras el proceso está en ejecución.

Las estructuras de datos internas del kernel registra el valor de prioridad del proceso,el cual determina cuanto tiempo de CPU va a tener, un valor que determina la terminal decontrol y 7 identificadores diferentes, cada identificador con su propio significado y uso, loscuales son los siguientes:

• El identificador de proceso, comúnmente denominado PID es un entero positivoen el rango de 1 a 30,000 (El límite superior del PID puede ser mayor o menordependiendo del sistema). El PID se asigna a un proceso cuando es creado conuna llamada a fork y se garantiza que sea único en el tiempo en que es creado.Este PID no puede ser cambiado. Eventualmente el PID se reasignará si noreinicializa el sistema antes de que los 30,000 valores hayan sido usados

• El identificador de proceso padre, denominado PPID, es el PID del proceso quecreó el proceso actual. Cuando se ejecuta un fork, el PID del proceso hijo seregresa al padre y el PID del padre queda asociado permanentemente con elproceso hijo como su PPID. El PPID no puede ser cambiado.

• El identificador real de usuario es un numero entero en el rango de 0 a 60,000 (Elvalor máximo varía de acuerdo al sistema). Este identificador se hereda de suproceso padre y viene del shell del login creado por el programa /bin/login el cualtoma el valor del tercer campo de la línea del archivo /etc/passwd que contiene elnombre del usuario como primer campo. Este valor es para identificar al usuarioen cuyo nombre se ejecuta el proceso y es un componente principal de laseguridad de los datos en UNIX. Este identificador puede ser alterado por elsuperusario (administrador del sistema).



• El identificador efectivo de usuario del proceso actual es un valor entero similaren significado, uso y rango al identificador real de usuario. El ID efectivo deusuario de un proceso se establece cuando se carga un nuevo texto (código) deprograma por alguna llamada a exec, su valor es establecido al valor delidentificador real de usuario a menos que el archivo del cual el programa se leetenga la bandera de setuid entre sus permisos (el valor 4000 octal en los permisosdel archivo). En tal caso, el ID efectivo de usuario se establece al del dueño delarchivo. Un ID efectivo de usuario 0 concede privilegios de superusuario alproceso. Este identificador se puede modificar por el superusuario.

• El identificador real de grupo es un valor entero en el rango de 0 a 60,000 (ellímite máximo varía de acuerdo al sistema). Este valor se hereda del procesopadre y viene del shell del login creado por el programa /bin/login el cual toma elvalor del cuarto campo de la línea del archivo /etc/passwd que contiene el nombredel usuario como primer campo. Este valor es para identificar al grupo del cual elusuario es miembro y en cuyo nombre se ejecuta el proceso y es un componenteprincipal de la seguridad de los datos en UNIX. Este identificador puede seralterado por el superusario (administrador del sistema).

• El identificador efectivo de grupo del proceso actual es un valor entero similar ensignificado, uso y rango al identificador real de grupo. El ID efectivo de usuariode un proceso se establece cuando se carga un nuevo texto (código) de programapor alguna llamada a exec, su valor es establecido al valor del identificador real degrupo a menos que el archivo del cual el programa se lee tenga la bandera desetgid entre sus permisos (valor octal de 2000). En tal caso, el ID efectivo degrupo se establece al del grupo del archivo. Un ID efectivo de grupo 0 no tiene unsignificado especial. Este identificador se puede modificar por el superusuario.

• El identificador de grupo de procesos identifica al grupo de procesos del cual esmiembro el proceso actual. El ID de grupo de procesos es el PID del líder delgrupo de procesos. El proceso actual hereda su ID de grupo de procesos de suproceso padre cuando es creado. Un nuevo ID de grupo de procesos es creado alabrir una sesión (al ejecutarse getty, que es un proceso que establece el modo dela terminal y velocidad de la línea). Por lo tanto, cada shell de una sesión tiene unID de grupo de procesos único; todos los procesos invocados por el shell directao indirectamente automáticamente se vuelven miembros del grupo de procesospor la herencia. Se puede cambiar este valor mediante una función del sistemadenominada setpgrp que hace que su valor sea igual al PID del proceso actualconvirtiéndose este último en el líder de su grupo (del cual el es el únicomiembro). Normalmente, esta función es llamada por los procesos daemon ya quese vuelve independiente de la terminal y el hecho de cerrar la sesión ya no afectapara nada al proceso.

6.3. Ciclo de vida de un proceso



Para crear un nuevo proceso, un proceso se copia a sí mismo usando la llamada alsistema fork.

El proceso padre puede suspender su ejecución (espera) hasta que el proceso hijo secompleta. Normalmente, el shell ejecuta comando creando procesos hijo y esperandoentonces a que el hijo se complete antes de emitir el siguiente indicador al usuario. Elproceso hijo hereda la siguiente información de entorno del padre:

• ID de grupo de procesos• Archivos abiertos• Directorio actual• Máscara de creación de archivos (umask)• ID’s real y efectivo de usuario• ID’s real y efectivo de grupo• Acciones establecidas para las señales• Variables exportadas

Así, el proceso hijo es inicialmente idéntico a su padre. Conforme el proceso hijo seejecuta, puede modificar su información de ambiente. La información de ambiente delproceso padre no es afectada por los cambios que el proceso hijo haga.

Cuando el proceso se completa, el control regresa a su padre. Cualquier recurso queel proceso haya obtenido regresa al sistema operativo para uso de futuros procesos. Unproceso hijo regresa un número a su padre que indica si ocurrieron errores. El número comoya se ha mencionado anteriormente se denomina código de retorno o código de salida (uncero indica éxito y algo distinto de cero un error).

Después del fork, un nuevo proceso a menudo usará la llamada al sistema exec, lacual carga un programa nuevo en el espacio de memoria del proceso actual. A diferencia defork, exec no crea un nuevo proceso.

La figura muestra el efecto de exec.



El -sh fue el proceso de entrada (login) y su padre fue /etc/init. Después el comandoexec ls fue introducido, el proceso -sh fue sobrepuesto con el proceso ls. Note que elproceso ls hereda el PID del proceso -sh. Al completarse el comando ls, el control esregresado al padre, /etc/init, que causa que un indicador login: sea emitido a través de/etc/getty.

6.4. El proceso login

Los eventos que ocurren durante la entrada al sistema ilustran como funcionan lasllamadas al sistema fork y exec. El proceso /etc/init (PID 1) empieza durante la inicializacióndel sistema y se continúa ejecutando hasta que el sistema es apagado. /etc/init es un procesodel sistema y no está adherido a ninguna terminal. Los procesos de esta naturaleza sedenominan daemons.

/etc/init continuamente examina el archivo /etc/inittab en busca de trabajos porrealizar. Este archivo contiene líneas que le dicen a /etc/init que comandos debe ejecutarpara los diversos niveles de ejecución y eventos del sistema. Algunas líneas en este archivocontienen comandos que imprimen el indicador login: en cada terminal activa. Estas líneastienen la forma de:

11: 234:respawn:/etc/getty tty11

Esta entrada le dice a /etc/init ejecutar un comando /etc/getty para la tty11. Elrespawn indica que cada vez que el proceso /etc/getty muera debe ser reiniciado por/etc/init. La siguiente figura muestra los eventos que ocurren cuando un usuario entra alsistema.



Primero, /etc/init hace un fork para el proceso /etc/getty como está indicado en laentrada de /etc/inittab. El proceso /etc/getty imprime el mensaje login: en la terminal.Cuando un usuario introduce su nombre de cuenta, /etc/getty ejecuta por medio de unallamada a exec el comando /bin/login con el nombre de cuenta como argumento. /bin/loginpide al usuario su password. Después de que este se introduce, /bin/login valida el nombrede cuenta y el password, si ambos son correctos, /bin/login ejecuta mediante exec elcomando /bin/sh, que imprime el indicador $ después de que el sistema lee los archivos/etc/profile y $HOME/.profile.

El shell continúa ejecutándose hasta que el usuario salga del sistema. Cuando el shelltermina, se regresa al proceso padre, el cual es /etc/init (hay que hacer mención que esto escuando se entra desde la consola de la máquina o de terminales conectadas directamentemediante puertos; si el acceso es remoto, entonces el proceso padre no es /etc/init sino undaemon que se encarga de los accesos remotos denominado telnetd o in.telnetd según elsistema, este y otros daemons se verán más adelante).

Las siguientes gráficas muestra como se comportan los fork y exec según seancomandos simples, secuenciales, por grupo, en tubería o en background.• Comando simple: $ ls



• Comando secuencial: $ ls; date

• Comandos en grupo: $ (ls; date)

• Comandos en tubería: $ who | sort

• Comando en background: $ ls &



6.5. Señales

Como ya se había mencionado antes, una señal es aviso al proceso de que se deseauna interrupción. Las señales pueden ser enviadas a un proceso a través del comando kill.Existen más de 30 tipos de señales definidas. Cuando una señal es entregada, una de doscosas suceden. Si el proceso ha designado una rutina manejadora para esa señal particular,esta rutina es llamada con la información sobre el contexto en el cual la señal es entregada.De otra forma, el kernel toma una acción por default en nombre del proceso. La acción pordefault varía de señal a señal; muchas señales terminan el proceso y algunas generan un coredump (vaciado de memoria).

El hecho de especificar una rutina de manejo para una señal se conoce como atrapar(catching) la señal. Cuando la rutina de manejo termina, la ejecución reinicia en el puntodonde la señal fue recibida.

Para prevenir que lleguen señales, los programas pueden solicitar que sean ignoradas.Una señal ignorada es simplemente descartada y no tiene efecto en el proceso. La siguientetabla muestra algunas de las señales de UNIX. La columna “Nombre” muestra el nombrepor el cual se conoce cada señal de acuerdo a los archivos cabecera en /usr/include. Estosnombres sólo se utilizan en programas en C. La mayoría de los comandos del shell usan unaforma abreviada del nombre que elimina el prefijo SIG; por ejemplo, HUP en vez deSIGHUP.

Las señales se usan como medio de comunicación entre procesos, para suspender ointerrumpir un proceso desde la terminal o por el kernel para muchas situaciones tales comoavisar la terminación del sistema.

ID Nombre Descripción Acción porDefault

Se puedeatrapar

Vaciado dememoria

1 SIGHUP Hangup o corte Terminar Si No2 SIGINT Interrupción Terminar Si No3 SIGQUIT Abandonar Terminar Si Si* SIGILL Instrucción ilegal Terminar Si Si



* SIGTRAP Ejecución por pasos Terminar Si Si* SIGFPE Excepción aritmética Terminar Si Si9 SIGKILL Eliminar Terminar No No* SIGBUS Error del bus Terminar Si Si* SIGSEGV Falla de segmentación Terminar Si Si* SIGSYS Argumento en llamada a

sistema erróneoTerminar Si Si

* SIGPIPE Tubería rota Terminar Si No15 SIGTERM Terminación por software Terminar Si No* SIGSTOP Para ejecución Parar No No* SIGCONT Continúa ejecución Ignorar Si No* SIGTSTP Para ejecución por teclado Parar Si No

Un * en la columna de ID significa que varía entre sistemas.

6.6. Estados de un proceso

Un proceso no es automáticamente elegible para recibir tiempo de CPU sólo porqueexiste. Hay esencialmente cinco estados de ejecución de los cuales se necesita estar al tantoy se muestran en la siguiente tabla:

Estado SignificadoEjecutable El proceso puede ser ejecutadoDurmiendo El proceso está en espera de algún recursoIntercambiado El proceso no está en memoriaZombie El proceso está tratando de morirSuspendido Al proceso no se le permite ejecutarse

Un proceso intercambiado es uno que ha sido escrito en disco y removido de lamemoria principal de la computadora. La mayoría de los sistemas intercambian procesoscuando hay mucha contención por la memoria, es decir, que hay muchos procesos queriendoejecutarse pero no hay suficiente memoria RAM para ellos.

Estrictamente hablando, intercambiado no es en realidad un estado. Un procesointercambiado puede también estar durmiendo o suspendido; permanece congelado en elestado en que se encuentre al momento de intercambiarse hasta que se trae nuevamente amemoria.

A un proceso suspendido se le prohibe ejecutarse. Son suspendidos mediante lasseñales STOP oTSTP y reiniciados por una señal CONT. Estar suspendido es similar a estardurmiendo, pero no hay forma de salir del estado suspendido más que otro proceso loreactive. Los procesos generalmente se suspenden en 3 situaciones:

• Cuando se presiona Ctrl-Z• Por una solicitud específica de un programa



• Cuando un proceso que ha sido puesto en background trata de accesar a suterminal de control

6.7. Comandos para el manejo de procesos

Algunos de los comandos para el manejo de procesos ya han sido vistos pero ahoraserán analizadas algunas opciones no mencionadas anteriormente:

6.7.1. Comando kill

El comando kill es a menudo usado para terminar la ejecución de un proceso. killpuede en realidad enviar cualquier señal a un proceso, pero por default envía la señalTERM, que es la señal de “terminación por software”. El comando kill puede ser usado porlos usuarios normales sobre sus propios procesos o por el superusuario en cualquierproceso. La sintaxis de kill es:

kill [-señal] pid

Donde señal es el número o nombre simbólico de la señal a ser enviada y pid es elnúmero de identificación del proceso destino. En algunos sistemas un pid de -1 se usa paradifundir una señal a todos los procesos excepto los procesos del sistema y el shell actual. Unkill sin número de señal no garantiza la terminación del proceso ya que la señal TERMpuede ser atrapada e ignorada. El comando

kill -9 pid

asegura que el proceso identificado por pid sea terminado ya que la señal 9 (KILL)no puede ser atrapada. Otra señal muy comúnmente usada es la señal 1 (HUP). Muchosdaemons del sistema atrapan esta señal y la interpretan como una orden de volver a leer losarchivos de configuración.

6.7.2. Comandos nice y renice

El “valor de amabilidad” (nice value) de un proceso le dice al kernel como debe sertratado el proceso en relación a otros que pelean por el CPU. El nombre viene por laamabilidad que se va a tener hacia los otros procesos. Entre menor es el valor de amabilidadmayor es su prioridad. El valor puede ir de -19 a 19. Un proceso hereda el valor deamabilidad de su padre al ser creado. Un proceso puede aumentar su valor de amabilidadpero no decrementarlo, esto solo lo puede hacer el superusuario. Se puede establecer suvalor al tiempo de crearlo con el comando nice:

nice [- valor ] comando

si no se especifica un valor se asume de 10. Un número negativo solo puede ser dado por elsuperusario.



Se puede cambiar el valor de amabilidad durante su ejecución con el comando renice:renice -p incremento PID

donde incremento es la cantidad que se le va a agregar al valor de amabilidad del procesoidentificado por PID.

6.7.3. Comando ps

El comando ps sirve para listar los procesos activos. En sistemas BSD (tal comoLinux), se pueden usar las opciones:

Opción Significado-a Muestra los procesos de todos los usuarios-u Muestra nombre de usuario y hora de inicio-x Muestra procesos que no tengan terminal de control

Así, por ejemplo si se dan las 3 opciones en Linux se obtiene:

[rsolis@mapaches rsolis]$ ps -auxUSER PID %CPU %MEM SIZE RSS TTY STAT START TIME COMMANDbin 164 0.0 0.6 900 396 ? S Jul 1 0:00 portmapnews 296 0.0 1.8 1668 1164 ? S Jul 1 0:08 /usr/sbin/innd -p4 -inews 298 0.0 0.8 1204 560 ? S Jul 1 0:00 sh /etc/rc.d/rc.newsnews 314 0.0 0.4 872 276 ? S Jul 1 0:00 /usr/lib/news/bin/cronews 315 0.0 0.4 872 276 ? S Jul 1 0:00 /usr/lib/news/bin/ovenews 358 0.0 0.9 1244 624 ? S Jul 1 8:36 sh /usr/lib/news/bin/news 8090 0.0 0.4 872 284 ? S 12:47 0:00 sleep 600nobody 5263 0.0 0.9 1168 624 ? S 11:06 0:00 httpdnobody 8780 0.0 0.9 1168 624 ? S Jul 6 0:00 httpd

Veamos que significa cada una de las columnas o campos:Campo Contenido

USER Nombre del usuario dueño del procesoPID ID del proceso%CPU Porcentaje del CPU que este proceso usa%MEM Porcentaje de la memoria real que el proceso usaSIZE Tamaño virtual del proceso en kilobytesRSS Tamaño residente (número de páginas de 1K en memoria)TTY ID de la terminal de controlSTAT Status del proceso actual:

R=Ejecutable D=En espera de discoI=Durmiendo (<20 seg) S=Durmiendo (>20 seg)T=Suspendido Z=Zombie

START Tiempo en que el proceso fue iniciadoTIME Tiempo de CPU que el proceso ha consumidoCOMMAND Nombre del comando y argumentos



Otro conjunto de opciones útil es -axl, que proporciona información más técnica (la les por formato largo). Es también más rápida en ejecutarse; esto puede ser importante si elsistema esta ya lento por otros procesos. ps es generalmente bastante costoso en lo que serefiere a tiempo de ejecución.

[rsolis@mapaches rsolis]$ ps -axl FLAGS UID PID PPID PRI NI SIZE RSS WCHAN STA TTY TIME COMMAND 100 0 1 0 0 0 880 344 do_select S ? 0:12 init [3] 40 0 2 1 0 0 0 0 bdflush SW ? 0:00 (kflushd) 40 0 3 1 -12 -12 0 0 kswapd SW< ? 0:00 (kswapd) 140 0 22 1 0 0 868 320 real_msgrcv S ? 0:00 /sbin/ker 140 0 133 1 0 0 904 408 do_select S ? 0:04 syslogd100140 0 142 1 0 0 1040 524 syslog S ? 0:00 klogd 140 0 153 1 14 0 904 408 sigsuspend S ? 0:00 crond100140 1 164 1 0 0 900 396 do_select S ? 0:00 portmap 140 0 175 1 0 0 1152 584 do_select S ? 0:00 /usr/sbin 140 0 187 1 0 0 884 360 do_select S ? 0:00 inetd

Alguna información extra que tiene esta opción es el ID del proceso padre (PPID),valor de amabilidad (NI) y el recurso por el que se espera (WCHAN).

En sistemas ATT (tal como Solaris), las opciones son distintas:Opción Significado

-e Se incluyen todos los procesos en ejecución-f Genera un listado completo-l Genera un listado largo

seit$ ps -ef | head UID PID PPID C STIME TTY TIME CMD root 0 0 0 Jun 23 ? 0:00 sched root 1 0 1 Jun 23 ? 72:59 /etc/init - root 2 0 0 Jun 23 ? 0:00 pageout root 3 0 0 Jun 23 ? 17:34 fsflush root 274 271 0 Jun 23 ? 0:00 /usr/lib/saf/listen tcp root 119 1 0 Jun 23 ? 0:15 /usr/sbin/in.named root 271 1 0 Jun 23 ? 0:00 /usr/lib/saf/sac -t 300 root 103 1 0 Jun 23 ? 0:04 /usr/sbin/rpcbind root 105 1 0 Jun 23 ? 0:00 /usr/sbin/keyserv

Las columnas en la salida de ps -ef tienen el siguiente significado:Columna Contenido

UID Nombre de usuario dueño del procesoPID Identificador del procesoPPID ID del proceso padreC Información de uso/planificación del proceso (información obsoleta)STIME Tiempo en que el proceso fue iniciadoTTY Terminal de controlTIME Tiempo de CPU consumidoCMD Comando y argumentos



Como ps -axl en los sistemas BSD, ps -elf en los sistemas ATT muestra detallesadicionales:

seit$ ps -efl | head F S UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME CMD19 T root 0 0 0 0 SY 10416cc0 0 Jun 23 ? 0:00 sched 8 S root 1 0 1 41 20 50115338 208 50115508 Jun 23 ? 73:00 /etc/init -19 S root 2 0 0 0 SY 50114cd8 0 10439e80 Jun 23 ? 0:00 pageout19 S root 3 0 0 0 SY 50114678 0 1043e104 Jun 23 ? 17:34 fsflush 8 S root 274 271 0 40 20 50114018 171 5007e706 Jun 23 ? 0:00 /usr/lib/saf/listen tcp 8 S root 119 1 0 41 20 50197340 360 5007eb66 Jun 23 ? 0:15 /usr/sbin/in.named 8 S root 271 1 0 40 20 50196ce0 177 50029c74 Jun 23 ? 0:00 /usr/lib/saf/sac -t 300 8 S root 103 1 0 41 20 50196680 233 5007ebde Jun 23 ? 0:04 /usr/sbin/rpcbind 8 S root 105 1 0 58 20 50196020 206 5007eb8e Jun 23 ? 0:00 /usr/sbin/keyserv

Las columnas que salen de más son las siguientes:Columna Contenido

F Banderas asociadas con el proceso. Solo por propósitos históricos, no tienenningún significado especial. Anteriormente significaban:00 = Terminado 01 = Proceso del sistema02 = Paso por paso 04 = Suspendido mientras esta paso por paso10 = En memoria principal

S Estado del proceso:O = Proceso actualmente ejecutándose S = DurmiendoR = Ejecutable I = Siendo creadoZ = Zombie T = Suspendido

PRI Prioridad de planificaciónNI Valor de amabilidad. SY si es proceso del sistemaADDR Dirección de memoria del procesoSZ Tamaño (en páginas) del proceso en memoria principalWCHAN Dirección del objeto por el cual el proceso esta esperando

6.7.4. Comando top

Este comando es similar a ps pero continuamente esta monitoreando el sistema yactualizando los datos en la terminal:[rsolis@mapaches rsolis]$ top1:24pm up 7 days, 6:59, 3 users, load average: 0.06, 0.02, 0.0053 processes: 52 sleeping, 1 running, 0 zombie, 0 stoppedCPU states: 1.9% user, 1.3% system, 3.1% nice, 96.9% idleMem: 63200K av, 58128K used, 5072K free, 20132K shrd, 23320K buffSwap: 130748K av, 68K used, 130680K free 21692K cached

PID USER PRI NI SIZE RSS SHARE STAT LIB %CPU %MEM TIME COMMAND 8937 rsolis 19 0 532 532 400 R 0 2.9 0.8 0:00 top 324 root 1 0 280 280 228 S 0 0.1 0.4 2:50 update 8923 root 1 0 700 700 508 S 0 0.1 1.1 0:00 in.rlogind 1 root 0 0 344 344 276 S 0 0.0 0.5 0:12 init 2 root 0 0 0 0 0 SW 0 0.0 0.0 0:00 kflushd 3 root -12 -12 0 0 0 SW< 0 0.0 0.0 0:00 kswapd 4725 rsolis 0 0 820 820 484 S 0 0.0 1.2 0:00 login

Por default, el desplegado es actualizado cada 10 segundos. Los procesos másactivos aparecen en la parte superior. top también acepta entrada del teclado y permite



enviar señales y cambiar el valor de amabilidad a los procesos, para que pueda observarcomo afectan las acciones a la condición general del sistema. top debe usarse parapropósitos de depuración solamente pues consume mucha porción del CPU.

6.7.5. Comando nohup

El comando hup evita que un comando haga caso a la señal HUP emitida cada vezque se termina la sesión y permita por lo tanto al comando seguir ejecutándose. Tambiéntiene el efecto de incrementar el valor de amabilidad en 5. Cualquier salida del proceso serácolocada en el archivo nohup.out si es que no se redirecciona. Su sintaxis es:

nohup comando &



7. INICIALIZACIÓN Y TERMINACIÓN DEL SISTEMA

7.1. Introducción

La inicialización de la computadora se denomina “bootstrapping” o bien solamente“booting”. Las facilidades normales del sistema operativo no están disponibles durante elproceso de inicialización. Durante el booting, el kernel es cargado en memoria y empieza aejecutarse. Se realizan una variedad de tareas de inicialización y el sistema es entoncesdisponibles a los usuarios.

El tiempo de booteo es de especial vulnerabilidad. Los errores en los archivos deconfiguración, equipo faltante o no confiable y sistemas de archivos dañados pueden todosprevenir que una computadora se levante. La configuración de booteo es a menudo una delas primeras tareas que un administrador debe realizar en un sistema nuevo.Desafortunadamente, es también uno de los más difíciles y requiere de algo de familiaridadcon muchos otros aspectos de UNIX.

7.2. Pasos en el Proceso de Booteo

Un proceso de inicialización típico consiste de 6 fases distintas:• Inicialización del kernel. El kernel de UNIX es por si mismo un programa y la

primer tarea de la inicialización es poner este programa en memoria para quepueda ser ejecutado. La ruta al kernel depende del sistema y es usualmente/kernel/unix o /unix. La mayoría de los sistemas implementa un proceso de cargade 2 fases. Durante la primer etapa, un pequeño programa de booteo es leído enmemoria de un disco o cinta. Este programa carga el kernel. Todo esto ocurrefuera del dominio de UNIX y no existe ninguna estandarización entre sistemas. Elkernel realiza pruebas para determinar cuanta memoria esta disponible. Lamayoría de los kernel corren en una cantidad fija de memoria y conocen desde elprincipio cuanta memoria reservar para sus áreas de almacenamiento interno ybuffers de E/S.

• Configuración del hardware. Una de las principales tareas del kernel es checarel ambiente de la máquina para ver que hardware esta presente. Cuando seconstruye un kernel para su sistema, se le dice que dispositivos de hardware debeesperar encontrar; cuando el kernel empieza a ejecutarse, trata de localizar einicializar cada dispositivo que se le notificó. La mayoría de los kernels imprimenuna línea de información bastante rara sobre cada dispositivo que encuentra. Lainformación de dispositivos proporcionada al tiempo de la configuración delkernel es a menudo subespecificada. En estos casos, el kernel trata de determinarla otra información que necesita probando el bus por dispositivos y pidiendo a losmanejadores apropiados información. Los manejadores para dispositivos que



faltan o no responden a una prueba serán deshabilitados. Aún si el dispositivo esconectado posteriormente, no será accesible a los procesos de UNIX hasta que lamáquina sea rebooteada.

• Procesos del sistema. Una vez que la inicialización básica está completa, el kernelcrea algunos procesos “espontáneos” en el espacio de usuarios. El número ynaturaleza de estos procesos varía de sistema a sistema. En sistemas BSD, estosson:

• swapper - proceso 0• init - proceso 1• pagedaemon - proceso 2

El número exacto de procesos espontáneos varía en sistemas ATT:• sched - proceso 0• init - proceso 1• Varios manejadores de memoria (excepto en Solaris)

De estos procesos, solo init es un proceso de usuario; los otros son porciones delkernel que han sido disfrazados para parece como procesos por razones deplanificación de procesos. El propósito de init es simplemente crear otrosprocesos. En este punto, el papel del kernel en el booteo está completo. Sinembargo, ninguno de los procesos que manejan las operaciones básicas (talescomo aceptar entradas al sistema en las terminales) ha sido creado, ni la mayoríade los daemons de UNIX ha iniciado. Todas estas tareas son manejadas (enalgunos casos indirectamente) por init.

• Intervención del operador (Solo en modo monousuario). Si el sistema va a serlevantado en modo monousuario, a init se le notifica de esto a través de unargumento en la línea de comandos pasado por el kernel. Durante el booteomonousuario, init simplemente crea un shell en la consola del sistema y espera quetermine (con exit) antes de continuar con el resto del procedimiento deinicialización. El shell monousuario es siempre el shell Bourne. Corre como root,el usuario privilegiado de UNIX. Desde el shell monousuario, el operador puedeejecutar comandos de la misma manera que como si estuviera en un sistemacompletamente inicializado; el operador debe montar otros sistemas de archivos amano para poder usar los programas que residen en /sbin, /bin o /etc. Losdaemons normalmente no corren en modo monousuario así que los comandos quedependen de procesos servidores (por ejemplo mail) no trabajarán correctamente.El comando fsck, que checa y repara sistemas de archivos es normalmenteejecutado durante un booteo automático. Cuando el sistema se levanta en modomonousuario, fsck debe ser ejecutado a mano.

• Scripts de Inicialización. El paso siguiente es la ejecución de los scripts deinicialización. Estos scripts son en realidad solo shell scripts e init ejecuta sh parainterpretarlos. La localización exacta, contenido y organización de los scriptsvaría de sistema a sistema. Hay dos formas prevalecientes de organizar los scriptsde inicialización, estos son mantenidos en el directorio /etc y tienen nombres quecomienzan con las letras rc. En sistemas ATT, los scripts se encuentran en



/etc/init.d y se hacen enlaces a estos en los directorios /etc/rc0.d, /etc/rc1.d, etc.La organización de ATT es más limpia y permite también al sistema ser apagadoen una manera ordenada. Algunas de las tareas que son a menudo realizadas porlos scripts de inicialización son:

• Establecer el nombre de la computadora• Establecer la zona horaria• Checar los discos con fsck• Montar los sistemas de archivos• Eliminar los archivos del directorio /tmp• Configurar las interfaces de red• Iniciar los daemons y servicios de red

• Activar las cuotas y contabilidadLa mayoría de los script son bastante comunicativos e imprimen una descripciónde todo lo que hacen. Esto es una tremenda ayuda si el sistema se queda atorado ala mitad del proceso de booteo o si trata de localizar un error en uno de losscripts.

• Operación Multiusuario. Después de la ejecución de los scripts de inicialización,el sistema es completamente operacional, excepto por el hecho de que nadiepuede entrar al sistema. Para poder aceptar entradas al sistema sobre una terminalparticular, debe haber un proceso getty escuchando en ella (excepto bajo Solaris,que usa un sistema más complejo). Después de los scripts, por lo tanto, initengendra procesos getty, completando el proceso de booteo.

En sistemas BSD, init tiene solo dos estados: monousuario y mutiusuario. Ensistemas ATT modernos, init tiene un “nivel de corrida” monousuario y varios multiusuarioque determinan que recursos del sistema son habilitados

7.3. Scripts de inicio tipo ATT

El daemon init en sistemas ATT soporta varios “niveles de corrida” (run levels) quepermiten diferentes conjuntos de recursos del sistema. Los scripts de inicialización sondivididos en pequeñas y manejables piezas que son invocadas conforme init se mueve entrelos niveles de corrida.

El proceso init reconoce 8 niveles:• S o s: es el nivel de corrida que especifica un modo monousuario• 0: Este es a menudo usado para realizar una terminación general del sistema. A

los usuarios se les advierte que deben salir del sistema; los sistemas de archivosson desmontados; los daemon son terminados dejando sin actividad al sistema.

• 1: Los comandos para este modo monousuario son diseñados para cambiar demultiusuario a monousuario y por lo tanto incluye comandos para eliminar losprocesos en background, desmontar sistemas de archivos y esencialmentedeshacer la mayor parte de lo que sucede cuando se entra al nivel 2. El estado 1



no es igual al estado S, el cual es definido internamente y no es dependiente delarchivo /etc/inittab.

• 2: Este es el modo multiusuario, y es usualmente diseñado como el estado al queinit entra inmediatamente después de que el procedimiento de inicialización delsistema es completado (aunque esto varía de acuerdo al sistema). Este estadomonta los sistemas de archivos, inicia los procesos daemon normales e iniciaprocesos getty para cada terminal de usuario.

• 3: Es un modo multiusuario alternativo en el cual se incluyen por lo generalsistemas de archivos NFS (Network File System) que permiten el acceso ymontaje de los sistemas de archivos desde otras máquinas.

• 4: En la mayoría de los sistemas no es utilizado este nivel, aunque pudiera serusado como un modo multiusuario alterno.

• 5: En algunos sistemas como Linux, se usa para entrar a un sistema gráfico desdela consola (X Windows) y en otros sistemas se usa para apagar la máquina.

• 6: Este nivel es usualmente definido como un estado de “reinicialización”; esto es,el sistema es apagado por completo como en el estado 0 y es entonces reiniciadocomo si se hubiera apagado la máquina y vuelto a encender. Este estado tienecomo propósito su uso para probar un nuevo kernel o para rebootear el sistemaperiódicamente sin intervención humana.

La definición exacta de cada nivel de corrida está gobernada por el archivo/etc/inittab. Si el archivo /etc/inittab no existe o está corrompido, solo es posible laoperación monousuario. El formato de cada línea en el archivo /etc/inittab es:

id:niveles:accion:comando

• El campo id puede ser hasta de 4 caracteres que identifican de manera única unaentrada. Este es un campo opcional.

• El campo niveles especifica que nivel o niveles para los cuales se aplica la entrada.Si es nulo, se asume el valor 0123456 (todos los niveles)

• El campo acción es una palabra reservada que determina el tipo de entrada de lalínea actual. Los tipos se definirán posteriormente.

• El campo comando es el comando a emitirse por init. Un comentario, empezandocon el carácter # , puede ser agregado después del comando.

Veamos ahora los posibles valores (tipos) usados en el campo acción:Valor ¿Espera? Significado

initdefault - Establece el nivel de corrida inicialboot No Se ejecuta cuando inittab se lee por primera vezbootwait Si Se ejecuta cuando inittab se lee por primera vezonce No Inicia el proceso una sola vezwait Si Inicia el proceso una sola vezrespawn No Siempre mantiene el proceso corriendoondemand No Igual que respawnpowerfail No Se ejecuta cuando init recibe una señal de falla de energíapowerwait Si Se ejecuta cuando init recibe una señal de falla de energía



sysinit Si Se ejecuta antes de accesar la consolaoff - Termina el proceso si es ejecutado

La columna ¿Espera? indica si init espera a que el comando se complete antes decontinuar.

El comando telinit -q le dice a init que se vuelva a leer el archivo /etc/inittab.

7.4. Inicialización en LINUX

En un sistema Linux, el cual es una combinación de sistemas tipo ATT y BSD, setienen niveles de corrida tipo ATT y cada nivel se usa de la siguiente manera:

0 - Terminación del sistema1 - Modo monousuario2 - Multiusuario sin NFS (Similar al 3, sin acceso a red)3 - Modo multiusuario completo4 - Sin usar5 - X11 (Sistema de ventanas gráficos6 - Reinicialización

El kernel del Linux (en la versión 2.x de RedHat) se encuentra en /boot/vmlinuz.Este sistema es configurado al instalarse por lo que si se requiere agregar nuevo hardware senecesita volver a instalarlo para que se configure de acuerdo al hardware. Los scripts deinicialización básicos se encuentran en el directorio /etc/rc.d y de acuerdo al nivel de corridadeseado los scripts de cada cual se encuentran en los directorios /etc/rc.d/rc0.d,/etc/rc.d/rc1.d, etc.

Analicemos ahora el archivo /etc/inittab usado en Linux:# Esta línea determina cual es el nivel de corrida por defaultid:3:initdefault:

# Inicialización del sistemasi::sysinit:/etc/rc.d/rc.sysinit

# Lineas que indican que comando ejecutar de acuerdo al nivelseleccionadol0:0:wait:/etc/rc.d/rc 0l1:1:wait:/etc/rc.d/rc 1l2:2:wait:/etc/rc.d/rc 2l3:3:wait:/etc/rc.d/rc 3l4:4:wait:/etc/rc.d/rc 4l5:5:wait:/etc/rc.d/rc 5l6:6:wait:/etc/rc.d/rc 6

# Cosas a hacer en todos los nivelesud::once:/sbin/update

# Se atrapa CTRL-ALT-DELETEca::ctrlaltdel:/sbin/shutdown -t3 -r now



# Cuando el UPS indica falla de energia, se asumen unos pocos minutos de# la misma y se programa una terminación del sistema en 2 minutospf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System ShuttingDown"

# Si se restaura la energía antes de la terminación, se cancelapr:12345:powerokwait:/sbin/shutdown -c "Power Restored; ShutdownCancelled"

# Se ejecutan gettys en los niveles determinados1:12345:respawn:/sbin/mingetty tty12:2345:respawn:/sbin/mingetty tty23:2345:respawn:/sbin/mingetty tty34:2345:respawn:/sbin/mingetty tty45:2345:respawn:/sbin/mingetty tty56:2345:respawn:/sbin/mingetty tty6

# Se ejecuta el xdm en el nivel 5 (servidor gráfico)x:5:respawn:/usr/bin/X11/xdm -nodaemon

La primer línea especifica cual es el nivel por default, el cual es el 3, tiene comoidentificador id y no tiene ningún comando asociado.

La siguiente entrada identificada como si hace que se ejecute el script/etc/rc.d/rc.sysinit en la inicialización del sistema.

Las siguientes líneas se ejecutan de acuerdo al nivel deseado, por ejemplo, si es elnivel por default, se ejecutaría lo que indica la línea:

l3:3:wait:/etc/rc.d/rc 3la cual indica la ejecución del script /etc/rc.d/rc teniendo como argumento un 3.

La siguiente línea identificada como ud hace que se ejecute el comando /sbin/updatecualesquiera sea el nivel al que se entró, este comando lo que hace es que los buffers enmemoria sean escritos en disco. Hay que notar que todos los datos que uno escribe primerose guardan en buffers para reducir el acceso a disco y consecuentemente el retardo queconlleva.

La siguiente línea tiene una acción especifica al LINUX que es ctrlaltdel, esta acciónlo que especifica es que si se presiona la combinación de teclas Ctrl-Alt-Del se ejecute elcomando especificado, que en este caso es shutdown, el cual veremos más adelante. Estanueva acción se debe a que LINUX es un UNIX para PC y como sabe en una PC estacombinación significa reiniciar la máquina.

La siguiente línea especifica que hacer en caso de que el no-break envíe una señal alsistema de que la energía eléctrica ha fallado. Esto siempre y cuando se tenga conectado elno-break al sistema.



La siguiente línea especifica una nueva acción, powerkokwait, la cual sirve paraindicar que hacer si el no-break envía una señal de que la energía eléctrica se ha restablecido.

Las siguientes líneas son para activar los getty para las terminales de la consola, ya semencionó que getty sirve para controlar la terminal. Estos procesos deben volverse a poneren ejecución si es que se terminan (es lo que indica el respawn), de otra forma, una vez quealguien entre a una terminal y se salga no podría ser posible volver a entrar por tal terminal.

La última línea indica que hay que ejecutar en caso de que se entre al nivel 5 (sistemagráfico de ventanas).

Analicemos ahora el script /etc/rc.d/rc.sysinit:#! /bin/sh## /etc/rc.d/rc.sysinit - se ejecuta una vez en la inicialización## Se establece el pathPATH=/bin:/sbin:/usr/bin:/usr/sbinexport PATH

# Se leen los datos de configuraciónif [ -f /etc/sysconfig/network ]; then . /etc/sysconfig/networkelse NETWORKING=no HOSTNAME=localhostfi

# Se inicia el intercambio de memoriaecho "Activating swap partitions"swapon -a

# Se establece el nombre del hosthostname ${HOSTNAME}echo hostname: `hostname`

if [ ! -f /fastboot ]; thenecho "Checking root filesystems."fsck -V -a /

rc=$?

# Un retorno de 2 o mayor significa que hay serios problemasif [ $rc -gt 1 ]; then

echoechoecho "*** An error occurred during the file system check."echo "*** Dropping you to a shell; the system will reboot"echo "*** when you leave the shell."

PS1="(Repair filesystem) #"; export PS1sulogin

echo "Unmounting file systems"umount -amount -n -o remount,ro /



echo "Automatic reboot in progress."reboot

elif [ "$rc" = "1" -a -x /sbin/quotacheck ]; thenecho "Checking root filesystem quotas"/sbin/quotacheck -vug /

fifi

if [ -x /sbin/quotacheck ]; then echo "Checking quotas. This may take sometime." /sbin/quotacheck -vug / echo "Done."fi

if [ -x /sbin/quotaon ]; then echo "Turning on user and group quotas" /sbin/quotaon -vug /fi

# Se vuelve a montar el sistema de archivos raíz read-writeecho "Remounting root filesystem in read-write mode."mount -n -o remount,rw /

if [ ! -f /etc/HOSTNAME ]; then echo ${HOSTNAME} > /etc/HOSTNAMEfi

# Se limpia mtab>/etc/mtab

# Se introduce el raíz en mtabmount -f /

# mount /procmount -t proc /proc /procif [ -f /proc/ksyms ]; then USEMODULES=yelse USEMODULES=fi

# este no se puede dejar montado pues confunde a “mount -a”umount /proc

if [ -x /sbin/depmod -a -n "$USEMODULES" ]; then # Get ready for kerneld if module support in the kernel echo -n "Finding module dependencies" depmod -a echo ""fi

if [ -x /sbin/kerneld -a -n "$USEMODULES" ]; then /sbin/kerneldfi

# Se checan los sistemas de archivosif [ ! -f /fastboot ]; then

echo "Checking filesystems."fsck -R -A -V -a



# Un retorno de 2 o mayor significa que hay serios problemasif [ $? -gt 1 ]; then

echoechoecho "*** An error occurred during the file system check."echo "*** Dropping you to a shell; the system will reboot"echo "*** when you leave the shell."

PS1="(Repair filesystem) #"; export PS1sulogin

echo "Unmounting file systems"umount -amount -n -o remount,ro /echo "Automatic reboot in progress."reboot

elif [ "$rc" = "1" -a -x /sbin/quotacheck ]; thenecho "Checking filesystem quotas"/sbin/quotacheck -v -R -a

fifi

# Se montan los otros filsystems(excepto NFS).# Contrario al uso estandar, los filesystems# no son desmontandos en modo monousuarioecho "Mounting local filesystems."

mount -a -t nonfs

if [ -x /sbin/quotaon ]; then echo "Turning on user and group quotas for local filesystems" /sbin/quotaon -avugfi

# Limpia /etc.rm -f /etc/mtab~ /fastboot /etc/nologin>/var/run/utmp

# Elimina los archivos de bloqueo UUCPrm -f /var/lock/LCK*

# elimina los archivos de bloqueo del subsistemarm -f /var/lock/subsys/*

# Elimina los archivos de pidrm -f /var/run/*.pid

# Elimina los archivos de X Windowsrm -f /tmp/.X*-lock

# Se establece el relojecho -n "Setting clock"

ARC=0UTC=0if [ -f /etc/sysconfig/clock ]; then . /etc/sysconfig/clock

# se convierte el anterior estilo a nuevos valores



if [ "${CLOCKMODE}" = "GMT" ]; then UTC=true

elif [ "${CLOCKMODE}" = "ARC" ]; then ARC=true

fifi

CLOCKFLAGS="-a"if [ $UTC = "true" ]; then CLOCKFLAGS="$CLOCKFLAGS -u"; echo -n " (utc)"fiif [ $ARC = "true" ]; then CLOCKFLAGS="$CLOCKFLAGS -A"; echo -n " (arc)"fiecho -n ": "clock $CLOCKFLAGS

date

# Se activa el intercambio para todos los filesystemecho "Enabling swap space."swapon -a 2>&1 | grep -v "busy"

# Initialize the serial ports.if [ -f /etc/rc.d/rc.serial ]; then

. /etc/rc.d/rc.serialfi

# Se cargan los modulos(para compatibilidad con versiones anteriores)if [ -f /etc/rc.d/rc.modules ]; then

/etc/rc.d/rc.modulesfi

# Si se detecta una cinta SCSI, se carga el moduloif cat /proc/scsi/scsi | grep -q 'Type: Sequential-Access' 2>/dev/null; then

if cat /proc/devices | grep -qv ' 9 st' ; thenif [ -n "$USEMODULES" ] ; then

# Try to load the module. If it fails, ignore it...modprobe st 2>/dev/null

fifi

fi

# Una vez cargados los modulos basicos se guardan los mensajes mostradosdmesg > /var/log/dmesg

Ahora veamos el archivo /etc/rc.d/rc:#!/bin/bash## rc Este archivo es responsable de iniciar/terminar# servicios cuando cambia el nivel de corrida. Es tambiem# responsable del establecimiento inicial de las cosas# importantes, tales como establecer el nombre del host## Librería de funciones fuente



. /etc/rc.d/init.d/functions

# Se encuentra el nivel actual y el previoargv1="$1"set `/sbin/runlevel`runlevel=$2previous=$1export runlevel previous

# Se obtiene el primer argumento. El nuevo nivel es este argumento. [ "$1" != "" ] && runlevel="$argv1"

# Existe un directorio rc para este nivel?if [ -d /etc/rc.d/rc$runlevel.d ]; then

# First, run the KILL scripts.for i in /etc/rc.d/rc$runlevel.d/K*; do

# Se verifica si existe el script[ ! -f $i ] && continue

# Se checa si el subsistema ya esta arribasubsys=${i#/etc/rc.d/rc$runlevel.d/K??}[ ! -f /var/lock/subsys/$subsys ] && \ [ ! -f /var/lock/subsys/${subsys}.init ] && continue

# Se termina el subsistema$i stop

done

# Ahora ejecuta los scriptsfor i in /etc/rc.d/rc$runlevel.d/S*; do

# Check if the script is there.[ ! -f $i ] && continue

# Se checa si el subsistema ya esta arribasubsys=${i#/etc/rc.d/rc$runlevel.d/S??}[ -f /var/lock/subsys/$subsys ] && \ [ -f /var/lock/subsys/${subsys}.init ] && continue

# Se levanta el subsistema$i start

donefi

Entonces, si el nivel es el default, el archivo /etc/rc.d/rc se encarga de ejecutar todoslos scripts que se encuentren en el directorio /etc/rc.d/rc3.d sabiendo que por convencion losnombres de los scripts tienen la forma K??nomservicio o S??nomservicio donde los ??indican un numero que especifica el orden en que se ejecutara. Los que empiezan con K sonpara terminar (kill) servicios y los que empiezan con S (start) para iniciar servicios.

Veamos ahora los mensajes generados por la inicialización de LINUX:klogd 1.3-3, log source = /proc/kmsg started.Loaded 4041 symbols from /boot/System.map.Symbols match kernel version 2.0.30.Loaded 32 symbols from 6 modules.BIOS query detected 65536KB RAM. Report errors to [email protected] RAM size was detected using BIOS function int 15h, ax=e801h.16 point font, 400 scans



colour VGA+ 80x25, 1 virtual console (max 63)BIOS32 Service Directory structure at 0x000fadc0BIOS32 Service Directory entry at 0xfb230PCI BIOS revision 2.10 entry at 0xfb260Probing PCI hardware.Calibrating delay loop.. ok - 53.04 BogoMIPS62872k/65536k available (704k kernel code, 384k reserved, 1248k data)Swansea University Computer Society NET3.035 for Linux 2.0Unix domain sockets 0.13 for Linux NET3.035.Swansea University Computer Society TCP/IP for NET3.034ICMP, UDP, TCPDiskquotas version dquot_5.6.0 initialized

Checking 386/387 coupling... Ok, fpu using exception 16 error reporting.Checking 'hlt' instruction... Ok.Linux version 2.0.30 ([email protected]) (gcc version 2.7.2.1) #1 WedJun 4 15:02:33 EDT 1997Serial driver version 4.13 with no serial options enabledtty00 at 0x03f8 (irq = 4) is a 16550Atty01 at 0x02f8 (irq = 3) is a 16550A16 ramdisks of 4096K sizei82371 PIIX (Triton) on PCI bus 0 function 57BM-DMA at 0x9000-0x9007BM-DMA at 0x9008-0x900fQUANTUM FIREBALL_TM3200A, 3067MB w/76kB Cache, LBA, CHS=779/128/63, DMAide0 at 0x1f0-0x1f7,0x3f6 on irq 14fd0 is 1.44M, fd1 is 1.2MStarted kswapd v 1.4.2.2FDC 0 is an 8272Amd driver 0.35 MAX_MD_DEV=4, MAX_REAL=80 hosts.detected total.Partition check:hda1 hda2 hda3 hda4Compressed image found at block 0checktime reached, running e2fsck is recommendedMounted root (ext2 filesystem).ok, detected 1 controller(s)PORTBASE=0x340, IRQ=11, SCSI ID=7, reconnect=enabled, parity=enabled,synchronous=disabled, delay=100, extended translation=disabledtrying software interrupt, ok.1.18 $1 host.048302Detected scsi disk sda at scsi0, channel 0, id 0, lun 00801hdwr sector= 512 bytes. Sectors= 1065664 [520 MB] [0.5 GB]sda1Mounted root (ext2 filesystem) readonly.Trying to unmount old root ... okay130748k swap-space (priority -1)Detected scsi tape st0 at scsi0, channel 0, id 6, lun 0Swansea University Computer Society IPX 0.34 for NET3.035IPX Portions Copyright (c) 1995 Caldera, Inc.Appletalk 0.17 for Linux NET3.035Presently autoprobing (not recommended) for a single card.loading device 'eth0'...smc-ultra.c:v2.00 6/6/96 Donald Becker ([email protected])



SMC Ultra at 0x220, 00 00 C0 4E DE 7A, IRQ 10 memory 0xc8000-0xcbfff.starting. named 4.9.5-P1 Wed Mar 12 10:15:25 EST 1997^[email protected]:/usr/src/colgate/BUILD/bind-4.9.5p1/namedcache zone "" loaded (serial 0)primary zone "0.0.127.IN-ADDR.ARPA" loaded (serial 2)secondary zone "itz.edu.mx" loaded (serial 133)secondary zone "184.248.207.in-addr.arpa" loaded (serial 55)Ready to answer queries.

7.5. Inicialización en Solaris

En un sistema Solaris, el cual es tipo ATT se tienen los siguientes niveles de corrida:0 - Terminación del sistema1 - Modo monousuario2 - Multiusuario sin NFS (Similar al 3, sin acceso a red)3 - Modo multiusuario completo4 - Sin usar5 - Terminación del sistema apagando el CPU6 - Reinicialización

El kernel de Solaris (en la versión 2.5.1) se encuentra en /kernel/genunix. Estesistema es autoconfigurable, es decir, una vez instalado se pueden agregar nuevosdispositivos sin necesidad de volver a instalarlo ya que se basa en la carga de módulodinámicamente de acuerdo a los que se necesite, solo basta con crear el archivo /reconfigurey reiniciar el sistema para que Solaris detecte los nuevos dispositivos y se configure deacuerdo a ellos.

Los scripts de inicialización se encuentran en /sbin/rcS, /sbin/rc0, etc., los cuales seejecutan de acuerdo al nivel solicitado, los scripts para cada nivel específico se encuentranen los directorios /etc/rc0.d, /etc/rc1.d, etc.

Veamos el archivo /etc/inittab de Solaris:ap::sysinit:/sbin/autopush -f /etc/iu.apfs::sysinit:/sbin/rcS >/dev/console 2>&1 </dev/consoleis:3:initdefault:p3:s1234:powerfail:/usr/sbin/shutdown -y -i5 -g0 >/dev/console 2>&1s0:0:wait:/sbin/rc0 >/dev/console 2>&1 </dev/consoles1:1:wait:/usr/sbin/shutdown -y -iS -g0 >/dev/console 2>&1 </dev/consoles2:23:wait:/sbin/rc2 >/dev/console 2>&1 </dev/consoles3:3:wait:/sbin/rc3 >/dev/console 2>&1 </dev/consoles5:5:wait:/sbin/rc5 >/dev/console 2>&1 </dev/consoles6:6:wait:/sbin/rc6 >/dev/console 2>&1 </dev/consolefw:0:wait:/sbin/uadmin 2 0 >/dev/console 2>&1 </dev/consoleof:5:wait:/sbin/uadmin 2 6 >/dev/console 2>&1 </dev/consolerb:6:wait:/sbin/uadmin 2 1 >/dev/console 2>&1 </dev/consolesc:234:respawn:/usr/lib/saf/sac -t 300co:234:respawn:/usr/lib/saf/ttymon -g -h -p "`uname -n` console login: "-T sun -d /dev/console -l console -m ldterm,ttcompat



Las primeras 2 líneas identificadas como ap y fs se ejecutan al inicio del sistema, laprimera es para ejecutar el comando autopush, el cual es usado para configurar los módulosque se cargan automáticamente cuando un dispositivo es usado. La segunda línea indica laejecución del script /sbin/rcS el cual monta los sistemas de archivo mínimos necesarios, loscheca y hace la reconfiguración del sistema si es que fue solicitada.

Posteriormente, la línea identificada como is determina que el nivel por default es el3.

Vienen posteriormente las líneas para cada nivel, que son las identificadas con s0, s1,s2, s3, s4, s5 y s6.

Las líneas identificadas con fw, of y rb se ejecutan en los niveles 0, 5 y 6respectivamente (las cuales son para hacer una terminación o reinicialización del sistema) yllaman a uadmin, el cual sirve para el control de funciones administrativas, el primer númeroque tiene como argumento (6) indica una terminación del sistema y el segundo especificacomo es la terminación, un (0) indica parar el procesador, un (6) apagar el procesador y un(1) reiniciar el sistema después de terminarlo.

Por último, las líneas identificadas con sc y co sirve para el manejo de las terminalesen base a los comandos sac y ttymon (lo que hace getty en los otros sistemas).

Veamos el script /sbin/rc3 el cual es el script para el nivel por default:#!/sbin/sh# "Run Commands" ejecutado cuando el sistema cambia a nivel 3# el cual es igual al 2 (multi-usuario) pero con compartición de# archivos remotos

PATH=/usr/sbin:/usr/binset `/usr/bin/who -r`if [ -d /etc/rc3.d ]then

for f in /etc/rc3.d/K*{

if [ -s ${f} ]then

case ${f} in*.sh) . ${f} ;; # interpretalo*) /sbin/sh ${f} stop ;; # sub shell

esacfi

}

for f in /etc/rc3.d/S*{

if [ -s ${f} ]then

case ${f} in*.sh) . ${f} ;; # interpretalo*) /sbin/sh ${f} start ;; # sub shell

esacfi



}fi

modunload -i 0 & > /dev/null 2>&1

if [ $9 = 'S' -o $9 = '1' ]then

echo 'The system is ready.'fi

Y ahora, los mensajes generados en la inicialización de Solaris:8800000/sd@0,0:a fstype ufsSBus0 slot 0xf offset 0x1100000 Onboard device sparc9 ipl 12zs0 is /sbus@1f,0/zs@f,1100000SBus0 slot 0xf offset 0x1000000 Onboard device sparc9 ipl 12zs1 is /sbus@1f,0/zs@f,1000000keyboard is </sbus@1f,0/zs@f,1000000> major <29> minor <2>mouse is </sbus@1f,0/zs@f,1000000:b> major <29> minor <3>stdin is </sbus@1f,0/zs@f,1000000> major <29> minor <2>UPA 0x1e 0x0SUNW,ffb0 is /SUNW,ffb@1e,0stdout is </SUNW,ffb@1e,0> major <54> minor <0>boot cpu (0) initialization complete - onlineFEPS (Rev Id = 22) FoundSBus0 slot 0xe offset 0x8c00000 and slot 0xe offset 0x8c02000 and slot0xe offset 0x8c04000 and slot 0xe offset 0x8c06000 and slot 0xe offset0x8c07000 Onboard device sparc9 ipl 6SUNW,hme0 is /sbus@1f,0/SUNW,hme@e,8c00000dump on /dev/dsk/c0t0d0s1 size 131456KUsing Internal Transceiver10 Mbps Link Upno PCMCIA adapters foundzerosyncing file systems... 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 done 3352 static and sysmap kernel pages 38 dynamic kernel data pages 970 kernel-pageable pagesSBus0 slot 0xe offset 0x8c00000 and slot 0xe offset 0x8c02000 and slot0xe offset 0x8c04000 and slot 0xe offset 0x8c06001b6ee4, offset 193152SUNW,UltraSPARC (upaid 0 impl 0x10 ver 0x40 clock 167 MHz) SunOS Release 5.5.1 Version Generic [UNIX(R) System V Release 4.0]Copyright (c) 1983-1996, Sun Microsystems, Inc.mem = 131072K (0x8000000)avail mem = 127688704Ethernet address = 8:0:20:82:fc:16root nexus = Sun Ultra 1 UPA/SBus (UltraSPARC 167MHz)UPA 0x1f 0x0 ...fas0: rev 2.2 FEPS chipSBus0 slot 0xe offset 0x8800000 and slot 0xe offset 0x8810000 Onboarddevice sparc9 ipl 4target 0 lun 0sd0 is /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0

<SUN2.1G cyl 2733 alt 2 hd 19 sec 80>target 1 lun 0sd1 is /sbus@1f,0/SUNW,fas@e,8800000/sd@1,0


<>



root on /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0:a fstype ufsSBus0 slot 0xf offset 0x1100000 Onboard device sparc9 ipl 12zs0 is /sbus@1f,0/zs@f,1100000SBus0 slot 0xf offset 0x1000000 Onboard device sparc9 ipl 12zs1 is /sbus@1f,0/zs@f,1000000keyboard is </sbus@1f,0/zs@f,1000000> major <29> minor <2>mouse is </sbus@1f,0/zs@f,1000000:b> major <29> minor <3>stdin is </sbus@1f,0/zs@f,1000000> major <29> minor <2>UPA 0x1e 0x0SUNW,ffb0 is /SUNW,ffb@1e,0stdout is </SUNW,ffb@1e,0> major <54> minor <0>boot cpu (0) initialization complete - onlineFEPS (Rev Id = 22) FoundSBus0 slot 0xe offset 0x8c00000 and slot 0xe offset 0x8c02000 and slot0xe offset 0x8c04000 and slot 0xe offset 0x8c06000 and slot 0xe offset0x8c07000 Onboard device sparc9 ipl 6SUNW,hme0 is /sbus@1f,0/SUNW,hme@e,8c00000dump on /dev/dsk/c0t0d0s1 size 131456KUsing Internal Transceiver10 Mbps Link Upno PCMCIA adapters foundSUNW,UltraSPARC (upaid 0 impl 0x10 ver 0x40 clock 167 MHz) SunOS Release 5.5.1 Version Generic [UNIX(R) System V Release 4.0]Copyright (c) 1983-1996, Sun Microsystems, Inc.mem = 131072K (0x8000000)avail mem = 127688704Ethernet address = 8:0:20:82:fc:16root nexus = Sun Ultra 1 UPA/SBus (UltraSPARC 167MHz)UPA 0x1f 0x0 ...fas0: rev 2.2 FEPS chipSBus0 slot 0xe offset 0x8800000 and slot 0xe offset 0x8810000 Onboarddevice sparc9 ipl 4target 0 lun 0sd0 is /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0



<>root on /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0:a fstype ufsSBus0 slot 0xf offset 0x1100000 Onboard device sparc9 ipl 12zs0 is /sbus@1f,0/zs@f,1100000SBus0 slot 0xf offset 0x1000000 Onboard device sparc9 ipl 12zs1 is /sbus@1f,0/zs@f,1000000keyboard is </sbus@1f,0/zs@f,1000000> major <29> minor <2>mouse is </sbus@1f,0/zs@f,1000000:b> major <29> minor <3>stdin is </sbus@1f,0/zs@f,1000000> major <29> minor <2>UPA 0x1e 0x0SUNW,ffb0 is /SUNW,ffb@1e,0stdout is </SUNW,ffb@1e,0> major <54> minor <0>boot cpu (0) initialization complete - onlineFEPS (Rev Id = 22) FoundSBus0 slot 0xe offset 0x8c00000 and slot 0xe offset 0x8c02000 and slot0xe offset 0x8c04000 and slot 0xe offset 0x8c06000 and slot 0xe offset0x8c07000 Onboard device sparc9 ipl 6SUNW,hme0 is /sbus@1f,0/SUNW,hme@e,8c00000dump on /dev/dsk/c0t0d0s1 size 131456KUsing Internal Transceiver



10 Mbps Link Upno PCMCIA adapters foundSUNW,UltraSPARC (upaid 0 impl 0x10 ver 0x40 clock 167 MHz) SunOS Release 5.5.1 Version Generic [UNIX(R) System V Release 4.0]Copyright (c) 1983-1996, Sun Microsystems, Inc.mem = 131072K (0x8000000)avail mem = 127688704Ethernet address = 8:0:20:82:fc:16root nexus = Sun Ultra 1 UPA/SBus (UltraSPARC 167MHz)UPA 0x1f 0x0 ...fas0: rev 2.2 FEPS chipSBus0 slot 0xe offset 0x8800000 and slot 0xe offset 0x8810000 Onboarddevice sparc9 ipl 4target 0 lun 0sd0 is /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0



<>root on /sbus@1f,0/SUNW,fas@e,8800000/sd@0,0:a fstype ufsSBus0 slot 0xf offset 0x1100000 Onboard device sparc9 ipl 12zs0 is /sbus@1f,0/zs@f,1100000SBus0 slot 0xf offset 0x1000000 Onboard device sparc9 ipl 12zs1 is /sbus@1f,0/zs@f,1000000keyboard is </sbus@1f,0/zs@f,1000000> major <29> minor <2>mouse is </sbus@1f,0/zs@f,1000000:b> major <29> minor <3>stdin is </sbus@1f,0/zs@f,1000000> major <29> minor <2>UPA 0x1e 0x0SUNW,ffb0 is /SUNW,ffb@1e,0stdout is </SUNW,ffb@1e,0> major <54> minor <0>boot cpu (0) initialization complete - onlineFEPS (Rev Id = 22) FoundSBus0 slot 0xe offset 0x8c00000 and slot 0xe offset 0x8c02000 and slot0xe offset 0x8c04000 and slot 0xe offset 0x8c06000 and slot 0xe offset0x8c07000 Onboard device sparc9 ipl 6SUNW,hme0 is /sbus@1f,0/SUNW,hme@e,8c00000dump on /dev/dsk/c0t0d0s1 size 131456KUsing Internal Transceiver10 Mbps Link Upno PCMCIA adapters foundvol0vol0 is /pseudo/vol@0SBus0 slot 0xf offset 0x1400000 Onboard device sparc9 ipl 11SUNW,fdtwo0 is /sbus@1f,0/SUNW,fdtwo@f,1400000UPA 0x1e 0x0SUNW,ffb0 is /SUNW,ffb@1e,0SBus0 slot 0xd offset 0xc000000 Onboard device sparc9 ipl 9SUNW,CS42310 is /sbus@1f,0/SUNW,CS4231@d,c000000

7.6. Reinicialización y terminación del sistema



Se debe reinicializar cuando se agrega un nuevo dispositivo de hardware, si semodifica un archivo de configuración que solo se lee en la inicialización, y si el sistema estatan cargado que no se puede entrar a hacer una diagnosis del problema.

Existen varias formas de terminar o reiniciar el sistema:• Apagar el sistema. Incluso en un sistema UNIX de pequeña escala, esta no es

una forma aceptable de terminar el sistema. No solo potencialmente se perderándatos y se dejará al sistema en un estado inconsistente sino que se pueden dañarciertos tipos de discos que esperan que su cabeza sea estacionada antes deapagarse.

• Comando shutdown. Este es el modo más seguro, considerado y completo determinar o reiniciar el sistema, o bien, regresar a modo monousuario.Desafortunadamente, cada sistema tiene sus propias opciones y argumentos. Sepuede pedir al comando que espere un tiempo antes de terminar el sistema, tiempodurante el cual se envian mensajes a los usuarios conectados. La sintaxis generaldel comando en LINUX es:

shutdown [-t seg] [-hrcf] tiempo [mensaje]donde la opción -t sirve para indicar cuantos segundos antes de la terminación dedebe enviar el mensaje. time indica cuando se debe terminar en formato hh:mm(hora:minuto), +m (donde m es la cantidad de minutos a esperar) y now queindica una terminación inmediata. La opción -h indica que es una terminación. Laopción -r indica una reinicialización. La opción -f indica una reinicializaciónrápida. La opción -c es para cancelar una solicitud de terminación previa. Elmensaje es el texto a enviar a los usuarios conectados.En Solaris la sintaxis es:

shutdown [-g seg] [-i nivel] [mensaje]donde la opción -g es para indicar cuantos segundos a esperar antes de terminar elsistema (por default son 60), la opción -i es para indicar el nivel al que se quiere iry mensaje es el texto a enviar a los usuarios conectados.

• Comando halt. Este comando realiza las tareas esenciales para terminar elsistema, mata los procesos, guarda los buffers en los filesystems y detiene alkernel.

• Comando reboot. Este es casi idéntico al anterior pero causa que la máquina sereinicialice en vez de parar el sistema.

• Comando telinit. Este permite indicar un cambio de nivel, se le da comoargumento el número de nivel deseado (0 al 6), S para monousuario o q paraindicar la relectura del archivo /etc/inittab.

Sistema Operativo UNIX -...

Documents

Transcript of Sistema Operativo UNIX -...