     
UNIX
================
* cat -> Nos permite ver el contenido de un archivo.
* ls -li -> Nos lista los archivos del directorio actual.
* ls /* ->
* pwd -> Nos dice en que directorio nos encontramos.
* history -> Todo lo que hemos tecleado desde el principio de la sesion.
* finger -> Nos dice quien esta conectado.
Ejemplo:
Login Name TTY Idle When Where
root Responsable del sistema p2 trueno.fi.upm.es
* chfn -> Nos permite cambiar el nombre < name > del finger.
* w -> Nos dice quien esta conectado y que esta haciendo.
Ejemplo:
User tty login@ idle JCPU PCPU what
* more -> Nos permite ver el contenido de un archivo.
* cd -> Permite cambiar de directorio.
* cd .. -> Sube al directorio anterior.
* man -> Manual de ayuda. Su formato es man < comando >.
* rm -> Borra archivos.
* mail -> Para entrar en el correo electronico.
k0123@asterix.fi.upm.es
* telnet -> Para conectarnos con otra mquina.
* connect -> Para conectarnos con otra mquina.
* ftp -> Para poder conectarnos con otra mquina y poder traer ficheros.
Subordenes:
* help
* open -> abre la sesion de ftp
* close -> cierra la sesion de ftp
* bye -> Nos devuelve al prompt del UNIX < $ >
* bin -> Activa el modo binario
* ascii -> Activa el modo ascii
* hash -> Para ver graficamente como va el proceso de
download
* get -> get < filename > Se trae un archivo concreto
* mget -> mget * Se trae todos los archivos
* put -> Lo contrario de get.
* abort -> Anula ltimo comando si no ha terminado de
ejecutarse
* ! -> Solo ordenes del DOS. Ej: !a: !dir c:\juegos
* lcd a: -> Y me puedo traer las "cosas" al diskete a:
* mkdir -> Crea un directorio.
* rmdir -> Borra un directorio.
* logout -> Para cerrar la cuenta y salir.
* exit -> Para cerrar la cuenta y salir.
* mv -> Para renombrar un archivo.
* grep -i -> Busca en un archivo ignorando mayscula y minsculas (-i) la
cadena que queramos.
* prog -> prog < lo que sea > para buscar en archie.
* passwd -> Para cambiar el password.
* ps u -> Nos da todos tus procesos abiertos.
* ps u a -> Todos los procesos de todos los usuarios.
PID -> Identificador de proceso
* fg -> Para continuar con un proceso parado con Ctrl-Z
* kermit -> ?  Help
* kill -> Mata procesos. kill -9 -1 mata todos los procesos y te hecha
a la calle.
Kill -9 <PID>  nmero de proceso, mata ese proceso
concretamente.
* chmod ->
* /usr/X11R5/bin/xarchie -> Para poder ejecutar xarchie
* cd /usr/bin/X11/xrn & -> Para poder usar las news
* uuencode < filename > -> De Bin a Ascii
* uudecode < filename > -> De Ascii a Bin
* compress -> Comprime
* uncompress -> Descomprime
Instrucciones para iniciar una sesin UNIX en el AULA-D
RESET
pctcp
win
Telnet> open aulad?+
Login: f931069
Password: ********
Para pasar ficheros de MSDOS a UNIX usaremos WFtp en el 
Administrador de programas de Windows.
Procederemos:
New
Hostname ? aulad
User name ? f931069
Password ? ********
Intro
Para enviar mails:
931092 ? Mariano
931040 ? Carlos
UNIX
-------------------------------
- S.O bsico (sistema de archivo, directorios, archivos, dispositivos, utilidades)
- Manual
- Editores de texto (ed -lneas-, vi -bloques-)
- Sistema de programacin (cc, ld, ar, make)
- Gestor de red (uucp, tcp/ip)
INDICE
1 Sistema de archivo
Dispositivo
- orientados a carcter (tty's)
- orientados a bloque
Archivos ordinarios (de usuario)
- sistema de proteccin
rwx-rwx-rwx
usuario grupo otros
Archivos directorio
Fifos y Pipes (sincronizacin de procesos)
Conceptos bsicos
- inodo (lista de inodos)
- utilidades
- usuario ? gestin de archivos
- mail
- impresin
2 Procesos
Estado (ps)
Prioridad o planificacin (nice)
Ejecucin
- fork( ) ? secundaria
- exec ? solapada
3 Programacin shell (8 puntos)
Descripcin de un lenguaje
- E/S
- estructuras de control
- subprogramas
- estructuras de datos ? arrays
AWK (subconjunto del lenguaje C)
4 Administracin del sistema (sysadmsh)
 
 
 
 
 
 
 
 
 
 
 
 
 
CARACTERISTICAS DEL SISTEMA OPERATIVO UNIX
Es un sistema operativo multiusuario y multitarea.
1. Multiusuario
 
 
 
 
Requisitos de conexin:
1. Tarjeta de red
- Configuracin hardware
direccin de memoria de E/S
IRQ (interrupciones HW)
2. Cableados
- Ethernet fino
- Ethernet grueso
- Par trenzado
3. Conectores
- T-BNC
- RJ-45
HARDWARE:
- tarjeta
- conectores
- cables
- concentradores
SOFTWARE:
- protocolo
- TCP/IP
DOS/WINDOWS
Utilidades
-ftp (envo y recepcin de archivos entre sistemas)
- telnet (sesin)
Programa ejemplo:
saludo.c
#include <stdio.h>
main( )
{
printf("Hola mundo \n");
}
dir ? c:/fuentes
 
 
 
 
 
 
Sesin UNIX
$ls
saludo.c
$make saludo.c cc saludo.c -o saludo
saludo
$saludo
Hola mundo
1. Conectividad en red
2. Software: protocolo TCP/IP
3. Utilidades de conexin (ftp, telnet)
Terminales virtuales: puede haber hasta 12 usuarios en un slo terminal, conmutando con 
ALT+tecla de funcin.
Ordenes de gestin de archivo (copia, borrado, enlace,...): cp, rm, ln, ls, cd, mkdir, rmdir, 
cat, more, find.
 
2. Multitarea
Tarea en memoria:
  
S.PILA.KERNEL
S.PILA
S.DATOS
S.CODIGO
Una tarea es un programa cargado en memoria al que se le asignan segmentos informativos 
para su contenido:
- segmento de pila
- segmento de datos
- segmento de cdigo
- segmento de pila KERNEL (gestor de tareas del sistema operativo)
Las tareas tienen una identificacin (PID y PPID) de tipo entero de 0 a 216. Establece un rbol 
de dependencias de proceso.
PID: n que identifica al proceso.
PPID: n que identifica al proceso padre.
Este esquema establece un rbol de dependenciasnumricas.
Se determina un proceso inicial, PID0, nombre INIT. El proceso INIT se encarga de la 
inicializacin y el arranque.
Getty verifica los protocolos de comunicacin con los terminales.
 
 
 
 
 
 
 
Esquema:
 
 
 
 
 
 
 
 
 
 
login enva un proceso de conexin por cada terminal, que verifica la conexin de un terico 
usuario al sistema.
Despus de la conexin tenemos como ltimo proceso un intrprete de rdenes (shell, 
equivalente al COMMAND.COM de MS-DOS), que ser el padre de todos los procesos que se 
generen en un terminal.
El concepto de multitarea establece una serie de rangos. Hablamos as de procesos padres, 
hijos y hurfanos. Se establece la relacin tarea-familia.
Proceso hurfano: finaliza el proceso antes que el hijo. En este caso se le asigna como padre 
shell.
La identificacin numrica de todos los procesos permite el envo de seales ($kill -9 432).
Se permite la ejecucin interactiva o diferida de procesos:
$orden?+ ? modo interactivo
$orden& ?+ ? modo diferido
El modo diferido presenta el PID (entre corchetes) del proceso que se ejecuta. Se le asigna 
tiempo de CPU en funcin de los requisitos. Se ejecuta en segundo plano (background).
La existencia de estos dos modos de ejecucin de procesos nos conduce a:
Planificacin (batch, crontab, at, notmp)
Podemos planificar temporalmente la ejecucin de nuestras tareas.
EJ: ejecutar un programa todos los das a la misma hora, manteniendo la ejecucin aunque 
finalicemos la sesin UNIX.
Esta planificacin permite definir contextos de prioridad (nice, sleep, wait) que permiten 
sincronizar y planificar los procesos.
La versin 4 incorpora la planificacin en tiempo real.
3 Sistema de seguridad
Se encarga de gestionar la entrada de usuarios al sistema.
a) Existen 2 archivos ASCII con este fin:
/etc/passwd
/etc/group
Estos ficheros contienen los usuarios que el administrador de sistemas ha dado de alta.
 
 
 
passwd /etc/passwd
id_usuario : clave : n usuario : n grupo : comentarios : dir : shell
      
LOGIN (14 caract) PASSWORD ID NUMERICA GRUPO PERTE. COM.ADM.SISTEMA $HOME INTERPRETE
 
group /etc/group
nombre_grupo : clave : id_grupo : usuarios
   
ID ALFANUMERICA OPCIONAL ID NUMERICA LOGIN DE TODOS
LOS USUARIOS
PERTE. AL GRUPO
 
 
b) Concepto de usuario efectivo en la aplicacin
Tenemos como usuarios muchos programas, que modifican el sistema. Cada programa slo 
puede ser usado por el usuario que lo posee. Para ello, el usuario, al ejecutar un programa se 
convertir en ese momento en el administrador del sistema, por lo que podr variar lo que 
quiera y alterar la instalacin.
c) Concepto de grupo efectivo en la ejecucin
Cualquier archivo creado pertenecer a un usuario y a un grupo.
ARCHIVO ? UID ? GID
Esto se graba en un inodo, generndose una estructura de permisos de lectura, escritura y 
ejecucin.
Variables del sistema ? umask 666
usuario rwx
Archivo => inodo grupo rwx
otros rwx
d) Integridad del sistema
Est a cargo de rdenes, se identifica como fsck (equivalecte a CHKDSK). Verifica la 
consistencia de la estructura del superbloque con la lista de inodos.
La integridad del sistema desaparece si apagamos de golpe el ordenador, por lo que se 
ejecuta fsck al volver a encender.
fsck ? /tmp
/lost+found
Se almacenan las inconsistencias del sistema.
Virus en UNIX:
En MS-DOS se permite la existencia de primitivas que mantengan un prrafo de cdigo en 
memoria, por ejemplo KEEP.
Un vector de interrupcin que se habilita 18 veces por segundo. Se vara cambindolo por el 
cdigo del virus. Se produce pseudomultiprogramacin.
En UNIX es ms fcil localizar los programas en ejecucin, por lo que se dificulta la entrada 
de virus.
Una posibilidad en UNIX es el denominado 'Caballo de Troya' o 'Troyano'
 
--- su ---
stty -echo
echo "Password: \c"
read x
echo " "
stty echo
echo $1 $2 > temp $ $
sleep 1
echo Clave errnea
rm su
Programa su: Switch User
Sirve para cambiar de usuario. Nosotros simulamos el programa su para encontrar el password 
del administrador.
Con un parmetro para el login creamos un fichero temporal tempxxx, donde xxx es el PID del 
proceso echo.
Hacemos creer al administrador que se ha equivocado al introducir el password y despus 
borramos el su. El administrador ejecuta esta vez el su verdadero sin haberse percatado de lo 
ocurrido.
4 Sistema jerrquico de archivo
A veces, dependiendo del nivel en que nos movamos, podemos ver el sistema de archivo como 
una secuencia de bloques lgicos, cada uno de los cuales tiene un tamao fijo (mltiple de 
512 bytes).
Estructura lgica Estructura fsica

+/usr [boot][superbloque][ ][ ][ ... ][ ][ ][ ][ ][ ... ][ ][ ] 
+/bin \ LISTA DE INODOS /\ BLOQUES DATOS /
+/etc
+/tmp
+/spool 
Esta secuencia de bloques nodo se apoya en una estructura fundamental: el inodo.
inodo
[dispositivo ] dispositivo donde se alberga el inodo
[n inodo ] n de inodo que hace (ndice dentro de la lista de inodos)
[modo ] informacin sobre el tipo de archivo y accesibilidad
[n enlaces ] n de enlaces simblicos que comparte el archivo
[UID ] id del usuario propietario del archivo
[GID ] id del grupo propietario del archivo
[dispositivo ] campo especial para dispositivos
[tamao ] tamao en octetos
[fecha ltimo acceso ] lectura
[fecha ltima notificacin ] escritura
[fecha cambio administrativo] estadstica
El inodo identifica un archivo.
 
 
 
 
 
 
 
 
 
CAMPO INODO
+---------------+

+---------------+
TIPO ARCHIVO    USUARIO GRUPO OTROS (ACCESIBILIDAD AL ARCHIVO) 100 r - lectura, 010 w - escritura, 001 x - ejecucin
  +- BIT DE PERMANENCIA: MANTIENE EL ARCHIVO EN MEMORIA
 +-- GRUPO EFECTIVO EN EJECUCION
+--- USUARIO EFECTIVO EN EJECUCION
TIPO DE ARCHIVO
1000 ORDINARIO
0100 DIRECTORIO
0010 DISPOSITIVO ORIENTADO A CARACTER (TERMINAL)
1100 DISPOSITIVO ORIENTADO A BLOQUE (DISCO DURO)
0001 FIFO (SINCRONIZACION)
1010 ENLACE (NO EXISTE PERO ES REFERENCIABLE)
Existen otros 10 campos de direcciones a bloques de datos. En ellos se almacena el contenido 
de los datos, son de indexacin directa.
Podemos tener otros campos:
Indirecto simple: contiene la direccin a otro bloque de datos que a su vez contiene 
direcciones a bloques de datos.
+---
+--- +--? [ ]
+-----? +-- . . .
+--- +--
+--- +--? [ ]
Indirecto doble (con dos niveles de indexacin), indirecto triple (con tres niveles de 
indexacin).
Estructuras de datos en UNIX
/usr/include
stat.h
filsys.h
...
Son las fuentes de programacin en C. Podemos ver aqu los campos que referencian a un 
inodo.
struct stat {
dev_t st_dev;
ino_t st_ino;
short st_mode;
short st_nlink;
short st_uid;
short st_gid;
dev_t st_rdev;
off_t st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};
 
 
 
 
 
Directorios standard en UNIX versin 3
/bin
/usr/bin
Contienen los ficheros de rdenes para uso pblico.
PATH : $HOME /bin : /bin : /usr/bin
/tmp
/usr/tmp
Son directorios temporales. A veces funcionan como sistemas de archivo independientes. 
Tienen la funcin de ser almacenamiento temporal para procesos.
/lib
/usr/lib
Gestin o creacin de libreras para programas de desarrollo de utilidades. Un gestor 
incorporado en UNIX es ar.
/usr
Implementa la estructura arborescente de usuarios. De l cuelgan los directorios accesibles 
por los usuarios.
/usr
+ /man Docs del manual on-line.
+ /acct Contabilidad de acceso al sistema.
+ /include Definicin de estructuras de datos del S.O.
+ /games Juegos.
+ /spool Gestin de correo y colas de impresin.
/etc
Es un directorio de mantenimiento y administracin. Contiene guiones shell y ficheros que 
controlan y administran el sistema.
/dev
Contiene todos los ficheros que tienen caractersticas de dispositivo.
/mnt
Directorio de sistemas de archivo montados. Es la asociacin de un dispositivo con un 
directorio lgico. Se asocia normalmente al raz.
ARRANQUE DE UN SISTEMA UNIX
? boot ? init ? getty ? login ? sh
? ? ?
inittab gettydefs /passwd
/group
Proceso boot
Establece la ejecucin de distintos procesos, siempre asociados a ficheros que sirven de 
diseadores.
 
 
Proceso init
Controla el nivel de ejecucin del sistema. Es el padre de todos los procesos. Normalmente es 
el proceso 0. Se encarga de ejecutar todas las acciones asociadas al fichero inittab. El fichero 
inittab se ubica en el directorio /etc y tiene el siguiente formato:
id : estado : accin : proceso
EJ:
v1 : 23 : respawn : /etc/getty/dev/vt01 9600
ls : 3 : initdefault
El primer campo es una etiqueta que individualiza cada lnea. 
El segundo campo corresponde a niveles de ejecucin. Normalmente de forma estndar van 
de 0 a 4. Estos niveles estn asociados a la primitiva del sistema init o /telinit. Si pongo en el 
prompt #init 3, se ejecutarn las acciones que tengan un 3 en el segundo campo.
El tercer campo corresponde a la accin que, a su vez, se divide en acciones.
Admite:
- off
- once
- wait
- respawn
- boot
- initdefault
Indican el modo de ejecucin del proceso que les sigue.
- off: Indica a init que detenga el proceso asociado al cuarto campo.
- once: Indica a init que debe ejecutar la orden del cuarto campo sin esperar a que termine.
- wait: sirve para que init ejecute el proceso del campo cuarto esperando a que termine.
- respawn: produce en init lanzar el proceso del campo cuarto. Si no existe, no espera a que 
termine, si existe, no hace nada.
- boot: La accin slo se ejecutar al arrancar el sistema. init ejecutar las lneas en las que 
aparezca la accin boot siempre que arranque.
- initdefault: es el estado por defecto en el que va a arrancar el sistema.
Campo cuarto: es el campo proceso. Normalmente es una orden shell que se ejecutar si la 
entrada estado coincide con el nivel de ejecucin.
EJ: Se pretende configurar un sistema para que sea usado por alumnos de TIF, ESCUELA y 
FACULTAD. Habr 5 terminales para cada tipo.
v1 : 234 : respawn : /etc/getty /dev/vt01 9600
v2 : 234 : respawn : /etc/getty /dev/vt02 9600
v3 : 234 : respawn : /etc/getty /dev/vt03 9600
v4 : 234 : respawn : /etc/getty /dev/vt04 9600
v5 : 234 : respawn : /etc/getty /dev/vt05 9600
v6 : 34 : respawn : /etc/getty /dev/vt06 9600
v7 : 34 : respawn : /etc/getty /dev/vt07 9600
v8 : 34 : respawn : /etc/getty /dev/vt08 9600
v9 : 34 : respawn : /etc/getty /dev/vt09 9600
v10 : 34 : respawn : /etc/getty /dev/vt10 9600
v11 : 4 : respawn : /etc/getty /dev/vt011 9600
v12 : 4 : respawn : /etc/getty /dev/vt012 9600
v13 : 4 : respawn : /etc/getty /dev/vt013 9600
v14 : 4 : respawn : /etc/getty /dev/vt014 9600
v15 : 4 : respawn : /etc/getty /dev/vt015 9600
#init 2 : Habilita los 5 primeros terminales enviando logins.
#init 3 : Habilita los 10 primeros terminales.
#init 4 : Habilita los 15 terminales.
Otros usos de inittab:
CERRAR Y APAGAR EL SISTEMA
- shutdown
- hatsys
- init 0. Se incluye un proceso de nivel 0 que tenga como accin un shutdown.
POSIBILIDAD DE ENTRAR EN MODO DE MANTENIMIENTO
Para entrar en modo monousuario se usa el nivel 1, con init 1.
bcheckrc (fsck)
init rc (sistema de impresin, inicializa soft de LAN, monta el sistema de archivo, ejecuta 
cron)
getty
init
1. Lee el nivel de ejecucin por defecto (initdefault)
2. Ejecuta los niveles que tengan la accin boot y bootwait
3. Ejecuta todas las rdenes asociadas al nivel por defecto
- bcheckrc: rden equivalente a CHKDSK
- rc: sistema de impresin: gestin de colas de impresin,
rea local: trasporte de datos,
sistema de archivo: asociacin de un directorio lgico con un dispositivo,
cron: permite planificar y ejecutar procesos a largo plazo (procesos en modo diferido).
- getty: se ejecuta a partir de init y desde inittab. Va al fichero gettydefs, en /etc, donde se 
encuentra toda la descripcin de protocolos de los terminales.
Presenta en pantalla un archivo identificado por /etc/issue, que sirve de login.
En el 5 campo de gettydefs existe una cadena que hace de login de conexin (login: ). Est 
bajo la opcin respawn y espera un tiempo a que el usuario escriba su login. Si es escrito 
ejecuta un proceso.
Ejecucin login:
init ? getty ? login
getty ejecuta login y busca el n de usuario en el fichero passwd:
- si existe el usuario solicita el password.
- el fichero /etc/btmp contiene los intentos de conexin fallidos.
- el fichero /etc/utmp contiene los usuarios conectados en el da actual. Cuando ejecutamos 
la orden who, este archivo es consultado.
- el fichero /etc/wtmp contiene las conexiones establecidas en un tiempo determinado por el 
administrador.
Para conocer la estructura de estos archivios tenemos que a cada identificacin de archivo le 
corresponder un archivo de librera:
/etc/utmp ? /usr/include/utmp.h
Despus se ejecuta el primer guin shell:
init ? getty ? login ? sh
/bin/sh es el shell del intrprete de rdenes.
Aparece el directorio de trabajo origen. El fichero .profile es un fichero bsicamente de 
configuracin de terminal y trabajo. En el se definen las avriables de entorno, caractersticas 
de terminal, programas asociados (editores), etc.
En funcin del shell incluido en el fichero passwd, podr ejecutar distintos shells (sh, csh, 
ksh, rsh).
- rsh: Restringido (ventanas).
- ksh, csh: Orientados a al programacin.
- sh: Shell bsico.
 
 
 
 
 
 
 
 
 
 
 
GENERACION DE ARCHIVOS. IDENTIFICACION DE UN ARCHIVO UNIX
En UNIX el identificador de un archivo permite una mxima extensin de 14 caracteres 
alafanumricos, donde maysculas y minsculas son singnificativas. Los signos de puntuacin 
no son vlidos, salvo '.' y '_'. Permite el uso de comodines: '*' y '?'. Al igual que MS-DOS, UNIX 
incorpora los corchetes, para establecer caracteres alternantes.
EJ: 
ls capitulo[123]?+ (Captulos 1, 2 y 3)
ls capitulo[1-5]?+ (Rango del 1 al 5)
Orden ls
Referencia al inodo. Es equivalente al comando DIR de MS-DOS.
Formato:
ls -l Formato largo, presenta toda la informacin completa del inodo.
ls -l archivo?+
-rw-rw-rw- 1 archivo grupo 64 11:20 Sep 16
El primer carcter define el tipo de archivo. Puede ser:
-: ordinario
d: directorio
b: dispositivo de bloque
c: dispositivo orientado a carcter
p: fichero fifo (pipe)
l: enlace simblico
Los 9 caracteres siguientes corresponden a la accesibilidad del archivo y van egrupados de 3 
en 3:
Grupo 1: usuario
Grupo 2: grupo
Grupo 3: otros
Puede ser:
r: lectura
w: escritura
x: permiso de ejecucin
-: denegado
El campo 11 indica el n de enlaces. Si es un directorio informa del n de archivos que 
contiene.
El campo 12 indica el usuario propietario, el 13 el grupo propietario, el 14 el tamao del 
archivo en bytes (n de octetos) y el 15 la fecha de ltima modificacin.
 
 
 
 
 
 
 
 
 
A continuacin vemos en el cuadro cmo afecta a ficheros ordinarios y a directorios los 
permisos de accesibilidad, que permitirn ejecutar unas rdenes concretas sobre ellos:
  
Operaciones 
permitidas
r
w
x
archivo ordinario
more 
cat (type)
cp (copy)
vi (edit) 
cp
exec
directorio
ls
rm 
mv
cp
cd
 
# chmod +x prog ?+
Habilita el permiso de ejecucin sobre el archivo prog.
Defiinicin de la accesbilidad
Para establecer el permiso y acceso a archivos. Existe la primitiva chmod y tiene 2 formatos, 
simblico y octal:
Notacin simblica de chmod:
  
u
+
r
g
-
w
o
-/=
w/x
a
=
x
u: usuario, g: grupo, o: otros, a: todos.
+: aadir permiso, -: suprimir permiso, =: asignar permiso.
r: permiso de lectura, w: permiso de escritura, x: permiso de ejecucin.
Sintaxis simblica de chmod:
EJ:
$ ls -l f1
-rw-r--r-- 1 user3 clase 37 Jul 24 11:06 f1
$ chmod g=rw, o= f1
$ ls -l f1
-rw-rw---- 1 user3 clase 37 Jul 24 11:06 f1
$ ls -l f2
-rw-rw-rw- 1 user3 clase 48 Jul 24 11:08 f2
$ chmod u+x, g=rx, o=rw f2
$ ls -l f2
-rwxr-x--- 1 user3 clase 48 Jul 24 11:08 f2
Notacin octal de chmod
lectura: 4, escritura: 2, ejecucin: 1.
EJ:
modo usuario grupo otros
rwxr-xr-x rwx r-x r-x
4+2+1 4+0+1 4+0+1
7 5 5
$ chmod 755 fichero
Por defecto, para directorios se establece una accesibilidad de 777 (todos los permisos 
activados).
Para archivos se asigna 666 (lectura y escritura para u, g y o).
Existe una variable de entorno (umask) que eprmite definir los accesos por defecto.
EJ: Qu debo hacer con la variable de entorno umask para que los archivos que genere 
aparezcan con los permisos r, w y x para usuario y grupo y con --- para otros, al crear 
directorios?
umask es una variable incluida en el fichero .profile.
Ordenes a tener en cuenta:
mkdir, rmdir, ls, cd, pwd, cat, rm, mv, cp, ln, more.
find
Permite localizar o buscar archivos a travs de la estructura del sistema de archivos. La 
bsqueda es condicional. Se pueden especificar mltiples condiciones de bsqueda.
Formato de find:
$ find directorio opciones
directorio es el origen de las bsquedas. La bsqueda se realiza recursivamente. Buscar 
desde el directorio indicado en todos los subdirectorios.
opciones:
- print: muestra por pantalla los archivos con sus trayectoria completa
$ find /usr -print
- perm: acompaa a una notacin en formato octal. Busca desde un directorio determinado 
todos los archivos que tienen el acceso indicado en octal.
$ find /usr -perm 777
$ find /usr -perm 666 -print
Busca todos los archivos activos en r, w y x para u, g y o y los presenta.
- user: busca todos los archivos que pertenecen a un usuario en concreto.
$ find /usr -user pepe
$ find /usr -user pepe -print
 
 
 
 
 
 
 
- link n: busca todos los archivos que tengan n enlaces
$ find / -link 5 -print
-link +n (ms de n enlaces)
-link -n (menos de n enlaces)
- size n: busca archivos con n bloques de datos. Cada bloque de datos son 512 bytes. Tambin 
permite -size +n y -size -n.
- atime n: busca todos los archivos a los que se ha accedido en n das.
- type: tiene los parmetros clsicos del tipo de archivo.
$ find / -type opcion
opcin puede ser:
- b: archivos de bloque
- c: archivos orientados a carcter
- d: directorios
- p: archivos ordinarios
- f: fifo
permite diferentes opciones con OR y AND.
- OK xxx: ejecuta interactivamente la orden shell asociada con cada archivo buscado por find.
- exec xxx: ejecuta incondicionalmente la orden shell asociada.
- name archivo: localiza determinados archivos del sistema.
$ find / -name filsys.h
localiza filsys.h mostrando la trayectoria completa.
$ find / -name "*.c"
localiza todos los archivos que terminan con la extensin '.c'
EJ: Las prcticas de un grupo de alumnos de ubican en:
/usr/alumnos/1642527
+ /prog.c
+ /prog.for
+ /prog.pas
Se desea disear un directorio que parta del raz as:
/
+ /fuentes
+ /c
+ /for
+ /pas
Hay que mover todos los fuentes en C de todos los alumnos a /fuentes/c, los de FORTRAN a 
/fuentes/for y los de PASCAL a /fuentes/pas.
Se comprobar si existen los directorios antes de crearlos.
Se comprobar si existen 2 ficheros de igual contenido con distinto nombre y se copiar slo 1 
de ellos.
Si 2 archivos tienen distinto contenido y el mismo nombre se renombrar uno de ellos.
Todos los archivos se cambiarn a rwxrwxrwx.
Copiaremos uno de los directorios a un disco de alta densidad MS-DOS.
 
EJ: Hay que hacer un programa que presente, para un directorio determinado, una tabla del 
siguiente modo:
$ estadistica /
ficheros ordinarios 4323
directorios 64
fifo 14
dispositivos de bloque 50
dispositivos carcter 35
enlaces 14
PROGRAMACION SHELL
El primer punto importante es la 
GESTION DE ARGUMENTOS
$ utilidad fich1 fich2 fich3
$0 $1 $2 $3
El nmero mximo de argumentos es 10. Desde $0 hasta $9. A partir de estos argumentos 
podremos hacer la gestin estadstica de archivos.
EJ: 
$ cat > ejer01 (equivale a copy con ejer01 de MS-DOS)
echo Est ejecutndose el programa: $0
echo El valor del argumento 1 es: $1
echo El valor del argumento 2 es: $2
.
.
.
^d (equivale a ^z de MS-DOS)
$ chmod +x ejer01?+
$ ejer01 fich1 fich2 ?+
o tambin
$ sh ejer01 fich1 fich2 ?+
Podemos incorporar tambin un editor similar a edlin, vi. Traeremos los ejercicios editados 
en MS-DOS y los convertiremos a UNIX:
$ mkdir guiones
$ cd guiones
$ doscp -m a:ejer01 ejer01
doscp
Sintaxis: 
doscp origen destino ? Copia de MS-DOS a UNIX
dosdir unidad ? Contenido de la unidad en formato MS-DOS
doscat archivo ? Visualiza el contenido de un archivo MS-DOS
dosls unidad ? Contenido de la unidad en formato UNIX
dosmkdir ? Crea directorios para unidades MS-DOS
GESTION DE ARGUMENTOS
$ utilidad fich1 fich2
$0 $1 $2 ... $n
Lenguaje C: Lenguaje PASCAL:
main (arc, argv){ ParamCount;
int argc; ParamStr(n);
char*argv[ ]
}
argc=n argumentos
argv= cadenas separadas
En UNIX-Shell:
fich1: parmetro
"fich1 fich2": un slo parmetro
$# contador de parmetros
$* referencia a todos los argumentos que invocamos
$$ (PIP) Identificacin del proceso en ejecucin
$! cdigo de salida (exit code) de la ltima orden ejecutada en segundo plano (background)
$? cdigo de salida de la ltima orden ejecutada en primer plano (foreground)
Modos de ejecucin de un proceso
$ prog ?+ (INTERACTIVO)
$ prog& ?+ (DIFERIDO)
Cdigo de retorno
Lenguaje PASCAL: MS-DOS:
{i-} ERRORLEVEL
Reset (fich1);
If (ioresult <> 0) UNIX:
then
begin $?
writeln('Error de archivo'); (Siempre en procesos interactivos)
halt(1);
end;
{i+}
Variables Shell
$0, ..., $9, $#, $$, $!, $?
Desplazamiento de argumentos
$ utilidad fich1 fich2 fich3 fich4
$0 $1 $2 $3 $4
La primitiva shift desplaza los argumentos:
$ shift
$ utilidad fich2 fich3 fich4
$0 $1 $2 $3
Shell tambin ofrece una copia de variables de entorno, inicializadas en la ejecucin del 
fichero .profile.
MS-DOS ? c:\>set?+
UNIX ? $ set?+
EJ: En lenguaje PASCAL:
var
valor: string;
begin
...
valor:=getenv("PATH");
writeln('path=',valor);
end.
Tipos de variables de entorno en la programacin shell de UNIX.
Variables asociadas al control del terminal:
$TERM Tipologa del terminal, para edicin.
$COLUMNS N de columnas.
$LINES N de lneas.
Variables asociadas a la gestin de directorio:
$HOME Directorio de trabajo origen.
$PATH Trayectoria de bsqueda de ejecucin.
$CPATH Trayectoria de directorios sobre los que se accede (cd libros, busca libros dentro de 
todos los directorios indicados en CPATH)
Variables asociadas al login:
$LOGNAME Login con el que se accede al sistema.
Variables asociadas a la gestin de correo electrnico:
$MAILPATH Trayectorias de nuestro sistema de correo.
$MAIL Trayectorias de nuestro sistema de correo.
$MAILCHECK N de segundos de test de correo para verificar si hemos recibido.
Variables asociadas al archivo histrico:
$HISTFILE Indica la trayectoria donde se ubica el archivo histrico.
$HISTSIZE N mximo de rdenes permitidas en $HISTFILE.
Variables asociadas al editor:
$EDITOR Editor por defecto.
Variables asociadas al entorno shell:
$SHELL Tipo de shell.
 
 
 
 
 
 
 
Variables asociadas al prompt del sistema:
$PS1 Smbolo de peticin de orden.
$PS2 Smbolo de peticin de orden secundario.
Variables asociadas a la medicin del tiempo:
$TZ Time zone, referencia la zona horaria de nuestro sistema.
Otras:
$IFS Separador de campos {:,++, ?+}, controla las delimitaciones de estructuras de archivos 
en UNIX.
Otras variables de entorno en ksh (KShell)
$ERRNO cdigo numrico de error generado por el proceso.
$PPID identificador del proceso padre del que est en ejecucin.
$PWD directorio de trabajo
$SECONDS segundos que llevamos conectados a la sesin.
$RANDOM generador de valores enteros corto (16 bits) aleatorios.
init ? sh ? prog
Estoy en sh ? padre: init
Estoy en prog ? padre: sh
Variables convencionales o tipos de datos
Las variables de entorno se codifican en maysculas. Las variables convencionales se 
codifican en minsculas. El guin Shell no tiene definiciones de tipos. UNIX surgi al mismo 
tiempo que el lenguaje de programacin PASCAL. Todas las avriables son locales al shell que 
las produce:
$ x=Hola?+
$ sh?+
$ echo $x?+
...
^d (es como un EXIT de MS-DOS, nos salimos de la subsesin)
$ echo $x
Hola
$
Para hacer shells globales se requiere incluir la clasula de exportacin:
export HOME_PATH
Estas variables estn globalizadas a todas las subsesiones.
Tratamiento de variables
variable=valor (Asignacin)
Contenido y direccin
x=Hola
x: direccin
$x: contenido de x
El contenido de la variable es arbitrable por asignacin interna o por la ejecucin de procesos 
que establezcan una asignacin de contenido a la variable.
n=10
n='ls -l lio'
read n (establece un valor para n desde consola)
midir='pwd'
cd $midir
EJ(72):
setcolor yellow
IFS='
'
for linea in 'cat /etc/passwd'
do
login='echo $linea | cut -f1 -d":"'
if [ $LOGNAME = $login ]
then
uid='echo $linea | cut -f3 -s":"'
gid='echo $linea | cut -f4 -d":"'
break;
fi
done
nombre_gid='grep $LOGNAME /etc/group | cut -f1 -d":"'
echo uid=$uid\($LOGNAME\) gid=$gid\($nombre_gid\)
setcolor -n
exit 0
Presenta la informacin del usuario.
id?+
uid=433 (Usuario) - gid=43 (Grupo)
- Asigna a la variable lnea cada lnea de passwd mediante un for.
- Almacena en la variable login lo obtenido en lnea, cortado a partir de ':'.
- Almacena en uid el nombre del usuario.
- Almacena en gid el nombre del grupo.
El contenido asignado a una variable es siempre alfanumrico. Para evaluar expresiones desde 
un guin shell se recurre a la herramienta expr:
n=`expr 34+2`
n=`expr $n+1` {un contador}
(Las comillas '`' no son comillas, sino indican que se ejecuta un proceso.)
Parmetros de sustitucin
${variable:-contenido}
${variable:=contenido}
EJ:
$ echo $DIR
$ echo ${DIR:-temp}
temp
 
echo ${DIR:=temp}
temp
echo $DIR
temp
${variable:-contenido}
Establece un valor por omisin. Si la variable no est declarada o es nula le asigna un 
contanido.
echo $DIR
$echo ${DIR:-temp}
temp
${variable:=contenido}
Asignacin clsica.
echo ${DIR:=temp}
temp
echo $DIR
temp
ksh, csh: mantienen estructuras compuestas de datos (ARRAYS). El resto de shells slo 
admiten variables simples.
Entrada/Salida (E/S)
echo
read
Entrada:
read: Asigna el contenido de la entrada estndar a las variables que tiene como argumento de 
forma posicional y a partir de separadores definidos (TAB,++, ?+).
read a b c d
? Esto es una prueba
a?Esto, b?es, c?una, d?prueba.
N Argumentos > N Variables: El resto de la asignacin lo recibe la ltima variable. Se define 
como asignacin externa bloqueante por posicin.
N Variables > N Argumentos: La ltima variable recibe el resto de los argumentos.
Salida:
echo: Es una orden bsica de salida por consola, de carcter secuencial que incorpora 
secuencias de escape.
echo $HOME
echo Hola que tal
echo presenta siempre argumentos en la salida
echo "Hola" "que" "tal"
Secuencias de ESCAPE
\c: mantiene el cursor en la misma lnea del mensaje
\b: retrocede un carcter
\n: salto de lnea
\t: se produce un salto de tebulacin (8 espacios)
Si incluimos secuencias de escape hemos de introducir el texto entre comillas dobles.
 
echo "nombre: \c"
read nombre
nombre: _
echo "\n\n\n Hola $nombre \n\n"
Hola Pepe
En lenguaje C existe algo similar:
printf(Hola \n)
EJ(37):
for NOMBRE in 'ls'
do
CONTIENE='wc -l $NOMBRE'
echo "nombre: $NOMBRE"
echo "contiene: $CONTIENE lneas"
done
Presenta nombres de archivos y n de lneas de cada uno.
- NOMBRE va tomando como valores cada lnea de ls (archivos)
- CONTIENE cuenta las lneas de cada archivo (-l: lneas)
- Escribe el nombre del archivo y su nmero de lneas
Las rdenes de lectura y escritura se pueden redirigir
fichero:
c1 c2 c3
cat fichero | while read c1 c2 c3
do
echo $c1
echo $c2
echo $c3
done
read asigna desde una lnea cvalores o argumentos a variables.
Siempre que read lee y asigna retorna como codigo de salida 0.
Si read lee y no consigue asignar devuelve 1 (EOF).
echo $variable >> fichero, >> sirve de APPEND. Redirecciona aadiendo.
EJ(11):
IFS=":"
sed "s/$IFS$IFS/$IFS$IFS/g" < /etc/passwd | \
while read LOGIN PASSWORD UID GID GCOS DIR SHELL
do
if [ -z "$SHELL" ]
then
SHELL=/bin/sh
fi
echo"Nombre: $LOGIN, UID: $UID, GID: $GID, GCOS: $GCOS, Directorio: $DIR, 
Shell:$SHELL"
done
exit 0
Pasa el fichero PASSWD al bucle while.
ESTRUCTURAS DE CONTROL
Expresiones condicionales
Existen 2 variables que referencian los dos contenidos booleanos posibles:
true (0)
false (1)
Programa C:
exit (0) ? Salida correcta, exit (1) ? Salida con cdigo de error
Una expresin condicional siempre va a determinar el cdigo de retorno de la ejecucin de un 
programa.
echo "Introduce directorio de bsqueda: \c"
read directorio
if find $directorio -print
then
echo "Tratamiento correcto \07"
else
echo "\07\07\07 Tratamiento incorrecto \n"
fi
\07 es el cdigo ASCII en octal de BELL.
TEST
Es un evaluador de expresiones para estructuras de control.
if test $# -eq 0
then
echo "Uso: prog fich \n"
exit 1
fi
o tambin
if [ $# -eq 0 ]
then
echo "Uso: prog fich \n"
exit 1
fi
Devolver true o false en funcin de la expresin.
Ambito de test
- evaluador de tipo de archivo
- evaluador de cadenas
- evaluador de enteros
 
 
 
 
 
 
 
TEST como evaluador de tipo de archivo
Sintaxis:
test opcion archivo
Opciones:
TEST devolver true si el archivo es:
-b: especial de bloque
-c: especial de carcter
-d: directorio
-f: ordinario
-p: tubera nominada
-r: con permiso de lectura
-w: con permiso de escritura
-x: ejecutable por el usuario
-s: de longitud distinta de 0
EJ(36): Presentar en pantalla los directorios que contiene el directorio de trabajo.
for VAR in `ls`
do
if test -d $VAR
then
echo $VAR
fi
done
Es un bucle for que evalua el nombre de las entradas de directorio. Test evalua el contenido 
de la variable y en caso de que sea un directorio lo presenta en pantalla.
EJ(33): Llvese a un directorio "borrados" todos los archivos del directorio de trabajo 
ordinarios que comiencen por 'a' y elimnense del actual.
mkdir borrados
for VAR in `ls a*`
do
if test -f $VAR
then
cp ./$VAR ./borrados
rm $VAR
fi
done
Si se ejcuta el guin shell ms de una vez producir un error, ya que la primera vez se cre el 
directorio 'borrados'. Para resolver el problema de existencia de un directorio aplicamos el 
siguiente algoritmo:
if cd borrados
then
cd ..
else
mkdir borrados
fi
El ejercicio asigna cada archivo del directorio a la variable y los copia.
 
TEST como evaluador de cadenas
Sintaxis:
test opcin cadena
Opciones:
-z: devuelve verdadero si es una cadena nula.
-n: devuelve verdadero si no es una cadena nula.
test cadena1 = cadena2 ? devuelve verdadero si cadena1=cadena2
test cadena1 != cadena2 ? devuelve verdadero si cadena1<>cadena2
test cadena ? devuelve verdadero si cadena no es una cadena nula
TEST como evaluador de enteros
Sintaxis:
test n1 comparador n2
Comparadores:
Devuelve verdadero si se cumple
-eq: igual
-ne: distinto
-gt: mayor que
-ge: mayor o igual
-lt: menor que
-le: menor o igual
Adems de estos tres tipos de gestin, test hace un tratamiento booleano residual:
!expr (equivale a la negacin, NOT, devuelve true si expr es falso)
expr1 -a expr2 (comparacin AND, devuelve true si expr1=true y expr2=true)
expr1 -o expr2 (comparacin OR, devuelve true si expr1=true o expr2=true)
Aparte de TEST existen otros modificadores de control. Es posible establecer la ejecucin 
prograsiva de rdenes, atendiendo a diferentes criterios:
$ ord1 && ord2
Si ord1 se ejecuta correctamente entonces ord2 se ejcutar.
$ ord1 || ord2
Aunque ord1 no se ejecute ord2 si se ejecutar.
 
 
 
 
 
 
 
 
 
 
 
ESTRUCTURAS DE CONTROL PROPIAMENTE DICHAS
if
if condicion
then
acciones
else
acciones
fi
EJ:
if true 
then 
echo Hola 
fi
Desde el prompt podemos hacer:
$ if true ?+
> then ?+
> echo Hola ?+
> else ?+
> echo Adis ?+
> fi
La programacin shell de UNIX permite la implementacin de ifs anidados:
if false
then
echo Hola
elif true
echo Adis
fi
DIR=`pwd`
if [ $DIR = $HOME ]
then
echo Estoy en mi directorio
fi
$ false $ true
$ echo $? ?+ $ echo $? ?+
1 0
$? es el cdigo de retorno de la ltima ejecucin.
false y true son dos ficheros que retornan un cdigo:
fichero false
exit 1
fichero true
exit 0
 
 
Dentro de las sentencias de control existen unos modificadores que son:
- exit
- break
if [ $# -eq 0 ]
then
exit 6
fi
exit: provoca una terminacin del proceso en ejecucin y un retorno de un cdigo al proceso 
padre (shell). exit se codifica en un entero corto (16 bits).
Cdigo exit. Hay retorno de 2 valores distintos:
  
CODIGO SEAL
CODIGO EXIT
?--8 bits--? ?-8 bits-?
[A] 153 Antes de finalizar el proceso A se ejecuta KILL -9 153.
? En lugar de enviar 0 se envia 9, el cdigo seal, que es el 
exit 0 octeto ms significativo.
break: es una ruptura de control de bucle
while true
do
echo "Nmero: \c"
read numero
if test -n numero
then
break
else
...
fi
done
Si se entra en break se sale del while.
for
for variable in lista
do
acciones
done
for var in 1 2 3 4 5
do
echo $var
done
Una de las aplicaciones ms utilizadas del bucle for es la ejecucin de procesos.
for var in `find / -name "*.c" -print`
do
echo $var
done
Presenta las trayectorias de los archivos encontrados.
Excepciones:
for a in *
do
echo $a
done
Lista el contenido del directorio
for a in $*
do
echo $a
done
Presenta cada uno de los argumentos
for a in $
do
echo $a
done
Gestiona los argumentos de la lnea de rdenes
Como ejemplo de la gestin de for tenemos el siguiente ejercicio:
EJ(50): Programa que gestione subdirectorios para programas fuente de C, PASCAL y 
FORTRAN.
if test ! -d prog_c
then
mkdir prog_c
fi
if test ! -d prog_for
then
mkdir prog_for
fi
if test ! -d prog_pas
then
mkdir prog_pas
fi
for var in `ls`
do
case $VAR in
*.c) directorio=./prog_c;;
*.f) directorio= ./prog_for;;
*.p) directorio=./prog_pas;;
*)continue;;
esac
encontrado=no
for l in `ls $directorio`
do
if cmp $VAR $directorio/$l > /dev/null
then
encontrado=si
break
fi
done
 
 
 
if [ $encontrado=no ]
then
if test -a $directorio/$VAR
then
cp $VAR $directorio/$$_$VAR
else
cp $VAR $directorio
fi
fi
done
exit 0
En caso de que existan los directorios no sern creados.
case (Estructura selectiva mltiple)
case $var in
et1) acciones;;
et2) acciones;;
et3) acciones;;
esac
$var puede ser un tipo complejo (cadena) o simple (entero).
Las etiquetas no deben repetirse.
Cada etiqueta debe siempre terminar con ;; (ruptura de estructura de control)
Las etiquetas admiten comodines.
case $var in
et1) acciones;;
et2) acciones;;
*) gestin_de_errores;;
esac
El ejemplo 50 visto anteriormente utiliza *) continue;; para no gestionar errores.
while (Bucle pretest)
Evalua una condicin. Si es cierta ejecuta las sentencias.
while condicion
do
acciones
done
until (Bucle postest)
Se ejecutan las acciones hasta que la condicin sea cierta.
until condicion
do
acciones
done
 
 
 
 
 
 
 
Archivos FIFO
Sincronizacin de procesos:
1. Creacin: Usaremos mknod. Crea un nodo que se corresponde con un archivo especial.
Para crearlo:
$ cd /etc
$ mknod $HOME/fifo p
$ ls -l
pfw-rw-rw-
Caractersticas de los archivos FIFO:
- Tienen longitud 0
- Sincronizan procesos estableciendo bloqueo en apertura y en lectura/escritura
Si despus de crear un archivo FIFO hacemos:
$ ls -lia > fifo
A B
ls ? [fifo] ? cat $ cat fifo
Productor Consumidor
El archivo FIFO que es abierto para escritura por un proceso, necesita que otro proceso lo 
abra para lectura. El terminal queda bloqueado hasta que se ejecute la orden en modo 
diferido.
Para no establecer un bloqueo recurrimos a lo siguiente:
$ ls -lia > fifo&
[543]
$
$ cat fifo?+
(Se abre FIFO para lectura) se bloquea en apertura y se desbloquea en lectura.
$ cat fifo no se podr ejecutar mientras fifo no tenga informacin.
EJ:
$ cd /etc
$ mknod $HOME/fifo p
$ cd $HOME
$ ls -lia > fifo
$ ls -lia > fifo& (Productor)
[154]
$ ps -ef | grep 154
$ cat fifo (Consumidor) {Aunque cambiemos el orden de productor y consumidor, este siempre acaba el ltimo)
Escribo el contenido de fifo en pantalla. Se abre para lectura y se bloquea hasta que el 
proceso productor le suministre informacin.
fifo slo almacena informacin en los 10 bloques de datos de indexacin directa.
Un proceso productor que genere mucha informacin a un archivo fifo puede llegar a ocupar 
los 10 bloques de datos de indexacin directa. En este caso el proceso productor se bloquear 
en escritura hasta que un proceso consumidor le libere de informacin.
 
 
 
Editor vi
Ordenes bsicas:
vi fichero
i: insercin
[ESC]: modo edicin/comando
A: aadir
x: borrar carcter
dd: borrar lnea
:wq!: grabar y salir
r: reemplazar carcter
R: reemplazar cadena
MODULOS
La programacin shell no permite casi el diseo modular aunque es posible implementarlo. La 
sintaxis de funcin es:
identificador ( ) {
orden(es)
}
No se admiten pasos de variables por valor ni referencia.
En KShell las funciones van precedidas por la palabra reservada function antes de la 
estructura anterior.
EJ: Crear un guin shell para la gestin de un archivo con nombres y nmeros de telfono, 
que permita dar altas, bajas, modificaciones y consultas.
altas( ) {
echo "Nombre: \c"
read nombre
echo "Telfono: \c"
read telefono
echo "$nombre : $telefono" >> datos.dat
}
consulta( ) {
echo "Nombre: \c"
read nombre
for linea in `cat datos.dat`
do
n=`echo $linea | cut -f1 -d ":"`
if test $nombre = $u
then
echo "Nombre: $nombre"
telefono=`echo $linea | cut -f2 -d ":"`
echo "Telfono: $telefono"
break
fi
done
}
 
 
 
 
# La funcin de consulta se puede resumir tambin del siguiente modo:
consulta( ) {
echo "Nombre: \c"
read nombre
cat datos.dat | grep $nombre
}
borrar( ) {
echo "Nombre: \c"
read nombre
encontrado=false
for i in `cat datos.dat`
do
name=`echo $i | cut -f1 -d ":"`
if test $name != $nombre
then
echo $i >> temp$$
else
encontrado=true
fi
done
if test | $encontrado
then
echo "\07 No existe \n\n"
rm temp$$
else
rm datos.dat
mv temp$$ datos.dat
fi
}
# Men principal
while true 
do
clear
echo "1 Altas"
echo "2 Bajas"
echo "3 Consultas"
echo "4 Salir"
echo "Opcin: \c"
read opcion
case $opcion in
1) altas;;
2) bajas;;
3) consulta;;
4) exit 0;;
*) echo Error;;
esac
done
 
 
 
 
 
 
 
 
Ejercicios propuestos:
EJ: Implementar la gestin de 2 archivos relacionados:
ARCHIVO 1 ARCHIVO 2
n expediente nombre alumno n habitacin n telfono
-------------------- ----------------------- ------------------- ----------------
-------------------- ----------------------- ------------------- ----------------
-------------------- ----------------------- ? ------------------- ----------------
-------------------- ----------------------- ------------------- ----------------
-------------------- ----------------------- ------------------- ----------------
Altas, bajas, modificaciones y consultas. No se admiten claves repetidas.
EJ: Hacer una funcin recursiva (funcin factorial).
 
Archivos de tipo directorio
ls
En la estructura de directorio hay dos tipos:
- La implementada por UNIX SYSTEM V
- La implementada por UNIX 4.3 BSD
La gestin de directorios responde en cada una a diferentes notaciones.
Estructuras de directorio en UNIX
SYSTEM V
struct direct {
ino_t d_inode;
char d_name [DIRSIZ];
};
Un directorio contiene un bloque de datos con los nombres de archivo e inodos.
  
67
.
70
..
435
fich1
423
fich2
602
fich3
ls recorre el directorio y cuando encuentra el nmero de inodo se dirige a la lista de inodos y 
obtiene la informacin de un fichero determinado.
SYSTEM V permite identificar un archivo con un mximo de 14 caracteres.
La estructura del directorio se alberga en dir.h.
 
 
 
 
 
4.3 BSD ('Berkley')
struct dirent {
ino_t d_ino;
short d_reclen;
short d_namelen;
char d_name[_MAXNAMLEN+1];
};
Berkley permite construir identificadores de archivo de longitud variable.
El registro contiene:
- n de inodo
- longitud de registro (reclen es el offset y el desplazamiento)
- n de caracteres
- identificador del archivo
Tambin se crearon primitivas de funciones de gestin para este tipo de archivos, las cuales 
no existan en SYSTEM V.
En dirent.h est la estructura dirent.
Se implementan las siguientes primitivas:
opendir
rewinddir
readdir
closedir
seekdir
con la posibilidad de usarlas desde C para gestionar la estructura de directorios en 4.3 BSD.
A nivel de usuario no es posible saber qu sistema se usa, pero a la hora de programar es 
fundamental diferenciarlo.
Ejercicios propuestos:
EJ:
/
+ /DOS
+/BORLANDC
+/BIN
+/INCLUDE
Disear la orden TREE de DOS con el sistema de archivo de directorio. Dependiendo del nivel 
en el que nos encontremos habrmos de tabular o retroceder.
 
 
 
 
 
 
 
 
 
 
 
 
 
ARCHIVOS DE DISPOSITIVO
- Orientados a carcter (terminales, unidades de cinta)
- Orientados a bloque (soportes magnticos, discos duros)
Estudiaremos ste ltimo.
Archivos de dispositivo orientados a bloque
Trabajan con el concepto de bloque lgico. Las tcnicas de indexacin estn ceidas a la 
unidad (512 bytes, normalmente). Usarn un buffer cach (rea intermedia de E/S). Los 
archivos de dispositivo estn ubicados en el directorio /dev:
$ ls -al /dev/hd*
brw - - - - - - - 2 sysinfo sysinfo 1, 0 Mar 14 1989 /dev/hd00
sysinfo en usuario y grupo indican que es propiedad del sistema.
1, 0: Son el n mayor y n menor que funcionan como ndices numricos referenciando a una 
tabla interna de Kernel que contiene las direcciones de memoria donde se localiza el driver 
de gestin de E/S de dispositivos.
Identificacin de los dispositivos de bloque
- Identificacin bsica de 2  3 caracteres.
- Identificacin numrica (n disco, particin, cilindros, pistas, sectores/pista) referenciando 
a un valor cuantitativo de la densidad de informacin admitida por el dispositivo.
Asociacin del sistema de archivos a un dispositivo de bloque
En los archivos:
/etc/checklist (ASCII)
/etc/mnttab (BINARIO)
Con la orden mount.
$ mount
/ /dev/fsk/0s1 4785 block 4327 i-node
mnttab y checklist son archivos que asociarn el sistema de archivos con dispositivos de 
bloque.
Con la orden mount aparece:
- id directorio
- id dispositivo de bloque
Estructura informativa de un dispositivo de bloque
[boot][superbloque][lista_de_inodos][datos][swap]
512
Superbloque: su informacin reside en un archivo ubicado en el directorio:
/usr/include/sys/filsys.h (En SYSTEM V)
/usr/include/sys/fs.h (En HP UNIX)
 
 
filsys es un registro que nos dice cul es la estructura exacta del superbloque. Contiene el n 
de inodos y bloques de datos del sistema de archivo. Tiene un campo con la ltima fecha de 
actualizacin de superbloque realizada por Kernel (que es el nico que puede modificarlo).
sync y update son dos procesos que sincronizan y actualizan el suoperbloque con la lista de 
inodos.
Adems existen otros campos:
- n de bloques libres
- n de inodos
- Campos de bloqueo (sincronizacin de Lectura/Escritura para Kernel)
- Campo indicador de cierre incorrecto de la sesin anterior
- Campo de referencia al modo de acceso al sistema de archivo (Lectura o Lectura/Escritura)
- n mgico, es el n de la versin de UNIX en uso. Es un entero largo. Sirve para saber el 
tamao de bloque del sistema de archivo (512, 1024, 2048)
- Nombre del sistema de archivo y versin del S.O.
El superbloque almacena toda la informacin relacionada con el sistema de archivo. Para 
situarnos en el superbloque:
lseek (archivo, 512, 0) desde C en filsys.h
Lista de inodos
Almacenamiento en el dispositivo de bloque. En el archivo /usr/include/sys/ino.h aparece la 
estructura del inodo. Se almacena:
- 40 octetos de indexacin (cada informacin en 3 octetos).
En struct d_inode tenemos la esencia bsica de almacenamiento en un dispositivo de bloque.
GESTION DE CORREO
El subsistema de correo de UNIX proporciona varias rdenes de gestin:
MAIL, MAILX
WALL
WRITE
NEWS
El subsistema de correo se divide en:
- Gestin de archivo (MAIL, MAILX)
- Gestin de terminal (WALL, WRITE, rdenes para enviar desde un terminal a otro tambin 
conectado)
Tambin se pueden enviar mensajes de forma diferida, sin que est conectado el receptor. 
El subsistema de correo dispone de una estructura de directorios propia:
/usr/spool/mail/$LOGNAME
/usr/spool/mail/pepe ser el archivo con todo el correo del usuario pepe.
MAIL: es un programa que gestiona archivos de correo.
WALL: rden de gestin de correo orientado a terminal. Permite enviar un mensaje a todos 
los usuarios conectados. La lista de usuarios est en utmp y WALL supervisa dicha lista para 
averiguar que usuarios estn conectados. Enva un mensaje que acaba con ^d y que ser 
supervisado por el administrador. El tipo de correo que se enviar desde WALL ser general, 
por ejemplo aviso de que se cerrar el sistema. No es posible proteger nuestro terminal 
contra correo producido por WALL.
WRITE: Permite la comunicacin con otro usuario conectado. Por ejemplo: WRITE uft21 tty02
TALK: divide el terminal en 2 reas, una de emisin y otra de recepcin. Tan slo difiere de 
WRITE en la presentacin. La filosofa es la misma, se trata de gestionar un archivo 
secuencial.
MESG: Pemite activar o desactivar la recepcin de mensajes. MESG N desactiva, MESG Y 
activa.
Con chmod go-w tty03 desactivaramos el acceso al terminal tty03, causando el mismo 
efecto que tecleando MESG N en el terminal tty03.
SISTEMAS DE CORREO ORIENTADOS A ARCHIVO
/etc/motd es un archivo que corresponde a las noticias diarias que cualquier usuario de la red 
que se conecte debe conocer. Este archivo es supervisado por cada .profile de conexin de 
cada usuario.
NEWS presenta las noticias del sistema que se encuentran disponibles. Esta utilidad visualiza 
el contenido de /usr/news, varios ficheros con formato ASCII, que se presentarn en funcin 
de su asignacin. En el fichero .profile existirn sentencias del tipo:
if [ -f /usr/news ]
then
news -n
fi
Visualizar los nombres de los archivos sin modtrar su contenido. Slo presenta las noticias 
actuales, no las ya pasadas de fecha. Hay un archivo que siempre referencia a la ltima fecha 
de consulta de news. Este es un fichero oculto, .news_time y contiene la ltima fecha de 
consulta de las news.
Ej. Disear un programa que presente y gestione noticias en el directorio /usr/news, 
controlando la fecha de ltima consulta.
Pasos a seguir:
1) Presentar nombres de fichero
2) Presentar contenido de los ficheros
Segn Kernighan:
# versin 1.0 news
for i in `ls -t /usr/news/* ./.news_time`
do
case $i in
*/.news_time) break ;;
*) echo news: $i ;;
esac
done
touch .news_time
touch es una utilidad suministrada con UNIX que crea un archivo con la fecha actual.
# versin 2.0 news
IFS='
'
for i in `ls -t /usr/news/* $HOME/.news_time 2 > /dev/null'
do
case $i in
*'not found') ;;
*/.news_time) break ;;
*) echo news: $i ;;
esac
done
touch .news_time
# versin 3.0 news
IFS='
'
for i in `ls -t /usr/news/* $HOME/.news_time 2 > /dev/null'
do
case $i in
*'not found') ;;
*/.news_time) break ;;
*) echo news: $i 
cat $i ;;
esac
done
touch .news_time
MAIL/MAILX
MAIL permite enviar y gestionar correo recibido. Incluye la gestin de control remoto (a otro 
sistema UNIX conectado). El envo de correo responde bsicamente a los siguientes criterios:
$ mail usuario(s) ?+
A partir de aqu se escribe un fichero y con ^d finalizamos. El archivo es enviado.
Tambin permite la redireccin:
$ mail andres < memoria ?+
o el uso de tuberas:
$ ls | mail andres ?+
El usuario andres recibe el resultado de ls en su terminal.
Gestin de correo recibido:
mail permite verificar si existe correo con el parmetro e:
if mail -e 
then
echo Tiene correo
fi
mail -e devuelve 0 si hay correo nuevo o 1 si no hay.
$ mail ?+
Devuelve un listado de los mensajes recibidos:
- emisor (cabecera)
- fecha de emisin
- tamao del mensaje
 
 
 
 
 
 
 
 
Ordenes para la gestin del correo:
$ mail ?+
#_
+, ?+, ?, n salta al siguiente mensaje
d, dp marca para borrar el mensaje recin ledo y salta al siguiente
dn marca para borrar el mensaje n, sin saltar al siguiente
dq marca para borrar el mensaje actual y sale de mail
h presenta una ventana de cabeceras, incluyendo el mensaje en curso
ha presenta la cabecera de todos los mensajes
hn presenta la cabecera de un mensaje determinado
hd presenta la cabecera de los mensajes marcados para borrar
num salta al mensaje num
p presenta el mensaje actual
q, ^d guarda en el archivo buzn los mensajes que no estn marcados para borrar y sale
r [usuario(s)] responde a la persona que envi el mensaje en curso y permite enviar copias a 
otros
usuarios, si se especifican. Este mensaje (reply) es marcado para borrar
s [fichero] vuelca el mensaje en curso a un archivo y lo marca para borrar
u [num] recupera un mensaje marcado para borrar de nmero num
w [fichero] vuelca el mensaje en curso a un archivo, omitiendo la cabecera y lo marca para 
borrar
x termina la ejecucin de mail sin salvar los cambios
y hace lo mismo que s
! orden permite ejecutar una orden de UNIX
? presenta la ayuda de mail
Correo no enviable:
Si el usuario no existe:
a) se interrumpir la creacin del mensaje, presentando un error 
b) el correo ser devuelto y almacenado en un archivo de identificador dead.letter
Envo de correo a usuarios remotos:
Todo sistema UNIX con UUCP obedece a:
Verificacin de los sistemas conectados:
$ uname -n, presenta el nombre de cada sistema UNIX de la red. Obtine la lista de sistemas 
activos para comunicacin mediante UUCP.
Para saber si un sistema est conectado a la red UUCP:
$ uname | grep nombre, presenta la informacin del sistema indicado si ste est conectado 
a la red.
Habr que establecer una trayectoria de comunicacin para enviar a ese sistema:
$ mail nombre ! subnombre ?+
Permite de este modo establecer comunicacin con un sistema en concreto y a partir de ah 
con un usuario de dicho sistema.
 
 
 
 
 
 
 
MAILX abarca la misma filosofa incorporando muchas ms posibilidades de gestin y detalle 
en la descripcin de los mensajes (tamao, n de palabras, caracteres, buzn origen, ayuda 
extendida,...) y un fichero de configuracin que permite incorporar cualquier editor de 
mensajes (MAIL slo permite ed).
Estructura de MAILX:
$ mailx ?+
orden [lista de mensajes] [argumentos]
- orden similar a MAIL
headers (h)
help (?)
mail (m)
reply (r)
save (s)
undelete (u)
visual (v)
write (w)
delete
dp
#
!
=
Se acerca a una gestin de correo relacional.
- lista de mensajes
n n de mensaje
? mensaje actual
^ ltimo mensaje
$ primer mensaje
n-m
usuario
- argumentos
Los argumentos se correspondern con la posibilidad que ofrezca cada rden:
- fichero(s)
- usuario(s)
Ej. Gestionar un array desde un guin shell:
a) Almacenar aleatoriamente valores numricos en dicho array sin repeticiones.
b) Ordenar el array.
c) Presentar en pantalla cada valor numrico con un color diferente.
 
 
 
 
 
 
 
 
 
 
GESTION DE IMPRESION
El subsistema de gestin de impresin en UNIX est compuesto por:
- Gestor de impresin (lpsched)
- Sistema de archivo de impresin
El gestor es un proceso que se ejecuta en modo diferido o background de forma contnua, 
para controlar la cola de impresin.
En MS-DOS existe el programa print, un programa residente que permanece activo en 
background. En UNIX el gestor de impresin se mantiene activo durante toda la sesin. Se 
encarga de:
- gestionar la cola de impresin
- gestionar los recursos y dispositivos de impresin
Es un proceso demonio que no est asociado a ningn terminal (tty).
Para saber si el gestor de impresin est activo usaremos la orden
$ ps -ef
que presenta el estado de los procesos en ejecucin.
A partir de ps obtendremos las carectersticas de cada proceso que se est ejecutando. En el 
caso de lpsched:
UID PID PPID tty command
lp 69 1 ? lpsched
- Identificacin de usuario del proceso (UID): 
En el fichero /etc/passwd hay una entrada para usuario, la entrada lp, que es la entrada de 
usuario para todos los procesos relacionados con la gestin de impresin.
- N de proceso (PID): 
Es un valor asignado por Kernel. Init se encarga de establecer la ejecucin de los demonios 
del gestor de impresin.
init ? getty ? login
+? rc
El valor que se le asigne ser siempre un n muy bajo, ya que procede del proceso init, que es 
el proceso de valor 1.
- N del proceso padre (PPID):
Siempre es 1, que indica que el proceso padre de lpsched es init.
- tty:
? indica que no est asociado a ningn terminal. Este proceso no morir cuando un usuario 
cierre una sesin en su terminal.
Otro forma de saber si lpsched est activo es ejecutando la orden
$ lpstat -r
as sabremos si lpsched se est, o no, ejecutando.
Cuando tengamos que dar de alta una impresora, modificar una cola de impresin o efectuar 
cualquier actualizacin estructural de impresin tendremos que desconectar previamente el 
gestor de impresin.
 
 
 
UNIX implementa una estructura de directorios con informacin sobre el gestor de impresin:
(1) /usr/bin
lp
lpstat
lpinfo
lpsetup
enable
disable
accept
reject
son las rdenes de uso pblico.
(2) /usr/lib
lpsched
lpschut
lpadmin
lpmove
contiene rdenes exclusivas y especficas para el uso de la administracin (alta de 
impresoras, activacin y desactivacin de trabajos, etc.).
(3) /usr/spool/lp
FIFO
SCHEDLOCK
log
oldlog
seqfile
default
contiene los ficheros de configuracin del subsistema de impresin y ficheros temporales a los 
trabajos que se estn imprimiendo.
FIFO: es un archivo de comunicacin y sincronizacin entre la orden lp y lpsched (gestor de 
impresin).
SCHEDLOCK: es un archivo de bloqueo, utilizado por el gestor de impresin para evitar la 
mltiple autoejecucin. Impide que el gestor de impresin se ejecute ms de una vez.
lod y oldlog: contienen registros de los trabajos que han sido impresos y de los que se estn 
imprimiendo.
seqfile: contiene el valor numrico de identificacin de la peticin actual de impresin, de 
modo que lpsched sabe cuntos archivos esperan para impresin.
default: contiene la identificacin de la impresora por defecto.
/usr/spool/lp/model
Es un directorio de modelos que contiene las impresoras que hay en el mercado por marca, 
modelo y tipo de conexin (serie o paralelo). Cada modelo es un guin shell que relacionar 
la orden de impresin de usuario (lp) con el dispositivo fsico que representa la impresora. 
Sincronizar y representar la informacin para determinado dispositivo fsico.
/usr/spool/lp/requests
Contiene subdirectorios, uno por cada impresora establecida, donde se ubicarn los trabajos 
que le pertenezcan a cada impresora.
INSTALACION DE UNA IMPRESORA
Tipo de impresora: Las impresoras actuales permiten ambos tipos de conexin (serie y 
paralelo). Para establecer el protocolo de comunicacin se usar un sistema hardware 
(jumpers) o software (si el perifrico lo permite).
Interface de conexin: Es la tarjeta con los puertos asignados. Seguiremos la siguiente tabla 
para identificar el puerto con el dispositivo:
  
LPT1
/dev/lp 
/dev/lp1
  
PARALELO
LPT2
/dev/lp2
PARALELO
LPT3
/dev/lp3
PARALELO
LPT4
/dev/lp4
PARALELO
COM1
/dev/tty00
SERIE
COM2
/dev/tty01
SERIE
COM3
/dev/tty02
SERIE
Pasos a seguir:
a) Comprobar la conexin:
$ cat prueba > /dev/lp
semejante a copy prueba prn: de MS-DOS.
b) Comprobar el tipo de impresora:
b.1) definir el modelo de impresora
b.2) usar un modelo estndar si no est disponible el nuestro
b.3) en caso de fallar los dos pasos anteriores crear un guin shell
En UNIX habr una cover-page por cada impresin que hagamos. En el guin shell podemos ver 
su estructura.
c) Desactivar el gestor de impresin:
Ser necesario entrar en el sistema como root. Usaremos /usr/lib/lpschut para desactitvar el 
gestor de impresin o tambin podemos optar por enviar una seal con kill -9  -15.
d) Dar de alta la impresora:
/usr/lib/lpadmin -p laser -v /dev/lp -i /usr/spool/lp/model/hpjet
Con los argumentos identificamos la impresora a instalar:
-p laser: asigna laser como identificacin de la impresora a efectos de tratamiento
-v /dev/lp: es el puerto de dispositivo hacia donde se dirige la impresin
-i /...: indica el modelo de insercin para establecer el protocolo
e) Habilitar el gestor de impresin:
/usr/lib/lpsched. A partir de este momento ya podremos imprimir.
 
f) Habilitar la impresora:
Lo haremos mediante la orden enable que se ubica en el directorio /usr/bin. Ejemplo:
enable identificador ? enable laser
g) Activar la impresora:
De este modo ser capaz de recibir trabajos. Se har mediante la orden accept del directorio 
/usr/bin. Ejemplo:
accept identificador ? accept laser
IMPRESION
Existe una orden para solicitar un permiso de impresin: lp.
Sintaxis:
lp [opciones] [fichero(s)]
Si omitimos los parmetros imprimir la entrada estndar.
Opciones:
-d: permite especificar una impresora en particular (-d identificador).
-m: notifica al usuario la impresin mediante el envo de un mensaje por correo electrnico 
una vez finalizada la impresin del archivo.
-ncopias: establece el nmero de copias a imprimir.
-tttulo: permite presentar un ttulo para el informe a imprimir.
-w: muestra un mensaje al finalizar el trabajo de impresin.
Cmo evitar la impresin de la cover-page
En el archivo /etc/default/lpd se almacena la variable BANNERS. Si la ponemos a 0 no 
imprimir la cover-page.
Estado de impresin
La orden para conocer el estado de impresin es lpstat.
lpstat presenta informacin sobre las peticiones de impresin y sobre las impresoras.
Sintaxis:
lpstat [opciones] [identificacin_de_peticiones]
Opciones:
-a: muestra en pantalla cules de los dispositivos listados aceptan o no peticiones de 
impresin.
-d: muestra en pantalla el nombre de la impresora por defecto.
-r: presenta el estado del controlador de impresin (lpcheck).
-t: presenta toda la informacin acerca del estado de las impresoras.
Control de impresin
Si se detectan anomalas en una impresora tendremos que desactivar el gestor de impresin 
para suspender los trabajos en espera. Usaremos /usr/lib/lpschut y cancel identificativo para 
cancelar la impresora en cuestin. 
Si queremos definir el error que ha producido la anomala para que todos los usuarios 
conozcan el porqu de la desactivacin del dispositivo usaremos la orden reject. Por ejemplo: 
/usr/lib/reject -r 'laser sin papel' identificador. 
Tendremos que mover todos los trabajos de dicha impresora hacia otro dispositivo si 
queremos seguir imprimiendo con /usr/lib/lpmove identificador nuevo_identificador.
Una vez solucionado el error habilitaremos el gestor.
Cmo establecer una impresora por defecto
Usaremos /usr/lib/lpadmin -d identificador
 
2. PROCESOS
El sistema operativo UNIX distingue programas y procesos.
Programa: secuencia lgica de instrucciones codificadas en un lenguaje determinado, que se 
ejecutan cargndose en memoria. Un programa puede contener 1  varios procesos.
Ficheros ejecutables en UNIX:
cc {compilacin} cc fuente.c
? ?
ld {enlace (linking)} a.out
?
a.out {ficheo ejecutable}
Formato de los ficheros ejecutables en UNIX (a.out):
a.out.h es un archivo de librera que contiene las estructuras de datos que componen un 
fichero ejecutable.
man a.out?+ nos devuelve la informacin proporcionada por el manual on-line que explica lo 
que es un ejecutable.
Areas de un fichero ejecutable:
1. Header: encabezamiento, estructura de datos que proporciona, mediante un nmero, la 
direccin donde se carga el proceso. Tambin indica los tamaos que conforman un archivo 
ejecutable; el segmento de datos, segmento de cdigo y tabla de smbolos.
2. Segmento de datos inicializados: variables globales y variables estticas. Almacena todas 
las variables a un valor definido antes de la ejecucin, en este rea (BSS).
3. Segmento de cdigo: compuesta por todas las instrucciones del algoritmo en cdigo 
mquina.
4. Tabla de smbolos: identificadores externos que utiliza el programa.
 
Ficheros ejecutables interpretados:
Ficheros que interpreta y ejecuta el shell, siendo previamente analizados lexicogrficamente 
(similar a un intrprete de rdenes como QuickBasic). Un ejemplo son los guiones-shell 
(ASCII). 
Cuando un guin shell o un fichero ejecutable es cargado en memoria, se convierte en 
procesos.
Para generar procesos dentro de ficheros ejecutables se utiliza:
fork ( ): genera 2 procesos que se ejecutan concurrentemente.
Ej:
#include <stdio.h>
main ( )
{
int pid;
pid=fork( );
if (pid>0)
printf ("Soy el proceso padre (%d) \n", getpid( ));
else
printf ("Soy el proceso hijo (%d) \n", getpid( ));
}
Cuando se generan 2 procesos, ambos tienen las mismas instrucciones y se ejecutan 
concurrentemente.
fork dar valor 0 al proceso hijo y el pid del proceso hijo al proceso padre (un valor entero 
positivo).
A partir de fork el contador de programa ejecuta las instrucciones en 2 copias exactas.
Informacin que hereda el proceso hijo del proceso padre:
fork: genera la creacin de un nuevo proceso.
El proceso hijo hereda:
- variables de entorno
- argumentos que recibe el programa
- sistema de mscara (umask) o de proteccin de accesos
- directorios de trabajo y raz
- gestin de seales e interrupciones (kill y trap)
- valor de la prioridad (padre e hijo se ejecutan con la misma (nice))
- identificacin del terminal
- identificacin de grupo del proceso
- segmentos de cdigo y datos
Cuando un programa es cargado en memoria, en UNIX, se copian las reas del ejecutable, 
construyendo:
Segemento de datos BSS
------------
Segmento de cdigo TEXT
------------
Segmento de pila STACK
------------
Area dinmica de datos HEAP
El segmento de pila est compuesto por 2 reas:
Area de usuario: requerida para las funciones de usuario.
Area de kernel: guarda una pila por cada proceso, donde se almacenar el contexto del 
proceso en ejecucin, antes de cada llamada (multiproceso).
El area dinmica de datos gestiona los datos de modo dinmico y no esttico 
(heap=montculo).
 
Ej:
guion
orden1 > archivo1& ? equivale a un fork ( );
orden2 > archivo2& ? equivale a un fork ( );
Sincronizacin de procesos a partir de fork ( );
fork ( );
 
A B
 
orden1 > archivo1&
orden2 > archivo2&
wait
sort archivo1 archivo2
wait es una sentencia de sincronizacin. Desempea una funcin de espera hasta que 
terminen los procesos hijos asociados. Esta sentencia suspende la ejecucin de sentencias y 
espera hasta que el/los proceso/s hijo/s terminen. Entonces el proceso padre contina su 
ejecucin.
Estados de un proceso:
EJECUCION USUARIO
llamada retorno
al sistema 
retorno de interrupcin
EJECUCION
dormir KERNEL orden de ejecucin
dada por el planificador
DORMIDO LISTO PARA
despertar EJECUCION
 
Estados:
1 EJECUCION USUARIO: el programa ejecuta las instrucciones de un algoritmo codificado por 
un usuario.
2 EJECUCION KERNEL O SUPERVISOR: el programa hace una llamada al sistema; gestin de 
archivos (open, read, write, ...), gestin de procesos (fork ( ), exec), etc.
3 LISTO PARA EJECUCION: el proceso no se ejecuta, pero est listo para ser ejecutado. Por 
ejemplo, cuando un proceso necesita memoria y la paginacin establecida no le puede servir 
memoria suficiente, cuando se libere memoria, el planificador lo pasar a ejecucin.
4 DORMIDO: estado que est determinado por operaciones de E/S. Por ejemplo, una 
operacin de lectura, hasta que no llegue una seal que libere al proceso de la E/S, el 
proceso no saldr de este estado.
 
 
 
 
Tipos de proceso:
Pueden haber sido generados mediante 2 herramientas:
- fork ( )
- exec
fork ( ) duplica el contexto del proceso (segmentos de datos y cdigo).
exec realiza un solapamiento del segmento de cdigo.
Ej:
guion
exec date
echo "Esto nunca llegar a ejecutarse"
Este guin shell ejecuta date y solapa el segmento de cdigo de date sobre el proceso 
principal, que es el guin shell. Aparecer la fecha, pero la lnea de echo nunca aparecer, ya 
que habr sido sobreescrita por el segmento de cdigo de date.
Ej: Hacer dos guiones shell, uno principal y otro secundario subordinado:
Salida:
iiiih! padre
ooooh! hijo
Estado de los procesos en memoria (ps):
La orden ps presenta informacin sobre los procesos activos en memoria.
$ ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME COMD
10 5 4392 17118 3211 0 30 20 1c40368 149 10d924 22:00:00 term/41 0:01 vi
Campos:
F: referencia indicadores o flags que establecen las caractersticas del proceso. Los flags 
hexadecimales ms frecuentes son:
00: proceso terminado
01: proceso del sistema (getty, init, planificador de tareas)
02: proceso en traza y depuracin
08: proceso en memoria principal
10: proceso bloqueado
S: indica el estado del proceso. Puede ser:
O: proceso en ejecucin
S: proceso dormido
R: proceso en cola de ejecucin
I: proceso inactivo en creacin
Z: proceso zombi
T: proceso detenido en modo de traza
X: proceso en espera de liberacin de memoria
UID: indica el n de identificacin de usuario propietario del proceso activo en memoria en 
ejecucin
PID: indica el n de identificacin del proceso (asignado por Kernel)
PPID: indica el n de identificacin del proceso padre
C: asociado a la planificacin del gestor de procesos. Se refiere a las CPUs y FPUs presentes 
en el sistema
PRI: valor de la prioridad de ejecucin del proceso. A mayor valor le corresponder peor 
prioridad
NI: valor nice de prioridad. Se establece para calcular la prioridad (PRI). Es un valor entero, 
por defecto se asigna 20 al proceso
ADDR: direccin fsica de memoria donde se almacena el proceso. Si el proceso est volcado 
en memoria externa la direccin toma el valor de 0
SZ: tamao en pginas del proceso en memoria
WCHAN: direccin de espera de un evento. Es una direccin de memoria donde se establece 
la gestin de una seal
STIME: hora de inicio de ejecucin, proporcionada en el formato hh:mm:ss
TTY: terminal asociado al proceso. Si es un proceso demonio, no asociado a terminal, vale ?
TIME: tiempo de ejecucin acumulado hasta el momento
COMD: orden asociada al proceso
Opciones:
ps -ef proporciona informacin completa
Ej:
ps -ef | grep pepe
Presenta las relaciones asociadas al patrn de bsqueda (pepe) en formato largo.
Ej: Realizar un guin shell que nos permita presentar las dependencias de los procesos.
? 148
? 149
? 183
? 260
? 264
? 268
Se intentar simular recursividad. Este guin shell ejecutar una funcin denominada 
proceso:
proceso ( )
{
IFS='
'
for i in `ps -ef | tail +2`
do
if [ $2 -lt 14 ]
then
IFS=' '
ppid='echo $i | cut -f3 -d" "'
if [ $ppid = $1 ]
then
hijo='echo $o | cut -f2 -d" "'
tabular=$2
until [ $tabular = 0 ]
do
echo " \c"
tabular='expr $tabular -1`
done
echo "--? $hijo"
tabular=`expr $2 +2`
proceso $hijo $tabular&
wait
fi
fi
done
}
# programa principal
proceso 1 0
exit 0
Ejercicios propuestos:
Ej: Guin shell que se ejecute cada 5 minutos y que calcule el n de pginas de los 
procesos que estn activos en memoria. Si este n excede un valor constante 
determinado, eliminar los procesos de menor prioridad (aquellos con menor valor en el 
campo 'PRI' de ps).
Ej: Codifquese un gun shell que elimine los procesos de aquellos usuarios cuya clave de 
acceso et caducada.
Comunicacin entre procesos
Niveles de sincronizacin:
FIFO (tuberas):
Ej: ls | sort
Proceso a: ls
Proceso b: sprt
La tubera (|) sincroniza ambos procesos. El proceso b no se ejecuta mientras a no haya 
terminado. Este mtodo se denomina como tubera sin nominar.
Tuberas nominadas:
Ej: mknod fifo p?+
Genera un archivo de nombre fifo que sincronizar procesos.
$ ls -l > fifo&
$ cat fifo
ls es el proceso productor que enva la informacin generada al archivo fifo que es una 
tubera nominada. cat desbloquea el proceso anterior, generando la informacin, es el 
proceso consumidor.
Coproceso es la gestin de una tubera bidireccional. Kshell permite la implementacin de 
coprocesos.
 
 
 
SEALES:
Una seal es un evento prodeucido por el Kernel o por un proceso de usuario. Su estructura 
bsica de datos es un valor de tipo entero y su funcionalidad est determinada por la 
comunicacin entre procesos. Es semejante al tratamiento de interrupciones en MS-DOS.
Existen varios tipos de seales. UNIX SYSTEM V incorpora 19 seales bsicas. A partir de estas 
los diferentes distribuidores aaden nuevas seales. XENIX y BERKLEY incorporan alrededor de 
30 seales.
El archivo SIGNAL.H recoge todos los valores de cada seal. Podemos visualizarlo con KILL -L.
Clasificacin de las seales:
SEALES RELACIONADAS CON LA TERMINACION DE PROCESOS
15 SIGTER Fuerza la terminacin de un proceso. Puede ser ignorada.
9 SIGKILL Establece el fin de un proceso y no puede ser ignorada.
SEALES RELACIONADAS CON EXCEPCIONES PRODUCIDAS POR UN PROCESO
8 SIGFPE
4 SIGILL
Terminan el proceso y establecen una copia en disco del proceso como "core".
Por ejemplo, cuando un programa quiere acceder a una direccin de memoria que no le 
corresponde o cuando se hace un clculo matemtico que requiere coprocesador. Si no hay un 
coprocesador presente en el sistema obtenemos errores en coma flotante.
SEALES RELACIONADAS CON LLAMADAS AL SISTEMA
12 SIGSYS Cuando hay demasiados argumentos en una llamada al sistema.
SEALES ASIGNADAS POR EL PROCESO DE UN USUARIO
Son las mismas, pero se envan con KILL -n.
SEALES RELACIONADAS CON LA INTERACCION DEL TERMINAL
2 SIGINT Equivale a pulsar ^C.
SEALES RELACIONADAS CON LA TRAZA DE INSTRUCCIONES DE UN PROCESO
5 SIGTRAP
SEALES ASOCIADAS A LA GESTION DE USUARIO
16 SIGUSR1
17 SIGUSR2
Podrn usarse para disear aplicaciones que requieran la sincronizacin de procesos.
 
 
 
 
 
 
 
 
Ordenes de UNIX para enviar y recibir seales:
EMITIR RECIBIR
kill trap (Standard)
kill
Enva una seal con los parmetros disponibles de sincronizacin.
Formato:
kill -seal pid(s)
Si pid>0 enva la seal al proceso definido.
Si pid=0 enva la seal a todos los procesos, a excepcin de los procesos 0 y 1 pertenecientes 
al mismo grupo que el proceso emisor.
Ej: Se tiene el fichero salir:
echo adios
kill -9 0
Visualiza adios y sale al login. Equivale a usar logout, ^d, exit, ...
Si pid=-1 se enva la seal a todos los procesos, a excepcin de los procesos 0 y 1, de los 
cuales el propietario real es el propietario efectivo del emisor.
Ej:
root El administrador disea una aplicacin
?
aplicacin El propietario real y el propietatio efectivo coinciden. Ambos son el administrador. 
La aplicacin puede ser usada por todos los usuarios del ? sistema.
chmod +s aplicacin Activa el bit de usuario efectivo en ejecucin.
?
pepe Pepe ejecuta la ejecucin.
Usuario real: Pepe
Usuario efectivo: root
trap
Es un receptor de seales.
Ej:
trap 'echo adios; exit 0' 2
while true
do
echo hola
done
Este es el prototipo de la recepcin de seales. Este programa presenta indefinidamente hola 
hasta pulsar ^C, momento en el cual se activar la captura de seal y se ejecutar 'echo 
adios; exit 0'
La captura de una seal puede terminar en:
1 ACCION POR DEFECTO
2 IGNORAR LA SEAL
3 FUNCION ASOCIADA
ACCION POR DEFECTO
Se establece conforme a los siguientes criterios:
1) Fin de proceso
2) Generacin de un archivo de volcado de memoria (core)
3) Ignorar la seal
4) Asociada a la suspensin del proceso. Al recbir una seal un proceso suspende su ejecucin 
y vuelca su contenido a disco en espera de que otra seal reanude su ejecucin.
En la versin 4 de UNIX:
SIGSTOP Suspende la ejecucin (demora)
SIGCONT Reanuda la ejcucin cargando el proceso a memoria.
IGNORAR LA SEAL
No har absolutamente nada al recibir la seal. Seales como la 9 no podrn ser ignoradas.
Ej:
trap ' ' 2
while true 
do
echo "Esto es una pena"
done
Aunque enviemos una seal de interrumpir al proceso este no se ver afectado y seguir 
visualizando la lnea de echo. Si se enva por segunda vez un ^C entonces si ser 
interrumpido, ya que las seales necesitan realimentarse, porque su valor es booleano.
Ej:
trap ' ' 2
while true
do
echo Hola
trap ' ' 2
done
De este modo no se podr interrumpir con varias pulsaciones de ^C porque la recepcin de la 
seal se est realimentando dentro del bucle. Se asemeja a BREAK=OFF de MS-DOS.
FUNCION ASOCIADA
Funcin de usuario o guin-shell.
Ej:
adios trap 'ksh adios; exit 0' 2
while true
echo adios do
exit 0 echo hola
done
Ejecuta una orden externa al recibir una seal. 
 
 
 
Tambin puede ser un mdulo:
Ej:
trap 'adios; exit 0' 2
adios( )
{
echo adios
}
#Programa principal
while true
do
echo hola
done
Ej: Crear un usuario que permita echar abajo el sistema si se interrumpe la ejecucin del 
archivo .profile.
PLANIFICACION DE PROCESOS
SYSTEM V contiene una serie de rdenes para planificar pocesos en el tiempo:
nohup permite que le proceso contine ejecutndose despus de que el usuario se haya 
desconectado del sistema. Impide que una seal de fin de sesin interrumpa la ejecucin de 
la orden.
Formato:
nohup orden arg(s)&
Ej:
trap ' ' 1
orden fichero&
batch ejecuta tareas cuando la carga de CPU los permita. Es inmune a la seal de fin de 
sesin.
$ batch ?+
orden(es)?+ $ batch < fichero ?+
^d
at ejecuta procesos determinados por una fecha de ejecucin.
$ at hora fecha ?+
orden(es)?+ $ at hora fecha < fichero ?+
^d
Opciones:
-L: presenta la lista de planificacin de procesos pendientes
-r: permite borrar trabajos planificados
hora: 0-23, mes. da, ao
Ej:
at 0:00 3 Aug 22, 1995 pepe
 
 
 
 
cron es un proceso demonio que se carga en el proceso init y ejecuta archivos identificados 
como crontab. Este proceso visualizar y gestionar este tipo de archivos verificando el tipo 
de rdenes que contienen y, si son adecuadas a la fecha del momento, las ejecutar. Los 
archivos crontab son ficheros de texto con 6 campos, 6 cadenas separadas por blancos (o el 
IFS predeterminado).
Campos:
1. Minutos 0-59
2. Horas 0-23
3. Da del mes 1-31
4. Mes del ao 1-12
5. Dia de la semana 0-6, siendo 0 Domingo, 1 Lunes, ...
6. Orden a ejecutar
Ej: Archivo crontab:
30 2 1 * * echo Paga el alquiler!
0 1 24 12 * echo Maana es Navidad.
0 1 * * 1 /usr/pepe/aplicacion
Permite usar *  , para no indicar el valor de un campo.

