Problemas de programación

en UNIX / Linux
Javier Gutiérrez
[email protected]
 Introducción
Este libro pretende ser un compendio de los problemas de programación de
sistemas UNIX / LINUX que se suelen estudiar en las prácticas de la asignatura
Sistemas Operativos.
Se ha intentado en todo momento que este libro sea una referencia útil y
práctica. Por ello, se ha incluido al principio de cada capítulo un resumen con los
conceptos teóricos necesarios para resolver los ejercicios. Además, muchos ejercicios
cuentan con notas aclaratorias que ayudan a su comprensión. Junto con este libro,
también se ofrece un archivo comprimido con todo el código fuente de las soluciones.
Actualmente, este libro aún está en desarrollo. Periódicamente se incluyen
nuevos ejercicios, se completan los capítulos e, incluso, se añaden capítulos nuevos. A
continuación se muestra una tabla de versiones para que todos los lectores puedan saber
si poseen la versión más actualizada y cuales son los cambios entre las distintas
versiones.

Versión Fecha Comentarios

0.1 16/09/2006 Primera versión de libre distribución. Incluye
los ejercicios y soluciones de los capítulos 1,
3, 4, 5 y 6 y dos apéndices.
Índice.
 Capítulo 1.

Ejercicios de comandos.

4
1.1. Resumen de conceptos.
Para una versión posterior.

1.2. Enunciados.

1.1. Análisis de ficheros log.

Para llevar un control exahustivo de todas las conexiones de un servidor

corporativo cada conexión queda registrada en un fichero log (o fichero de traza). A
continuación, muestra el formato y un ejemplo. Cada fichero log recibe un nombre
según el formato indicado en la figura 1 y almacena todas las conexiones registradas en
un único día. Todos los ficheros log se almacenan en un directorio cuya ruta completa
guarda la variable de entorno LOGS

Formato del contenido:

IP: a.b.c.d P:p T:t

Siendo IP la dirección de la máquina que realiza la conexión, a, b, c y d

números entre 0 y 255, p el número del puerto que recibe la conexión y t los
segundos que dura la conexión.

Formato del nombre:

Fichero-log.año.mes.dia

Siendo año un número de 4 cifras, mes un número de 2 cifras y día un número de

dos cifras que indican la fecha en que se recibieron las conexiones que guarda
el fichero.

Ejemplo de fichero log:

IP: 125.130.2.5 P:25 T:84

IP: 125.130.2.5 P:80 T:124
IP: 125.130.1.7 P:21 T:12
IP: 224.25.81.183 P:135 T:0

Resuelva los apartados a y b suponiendo que se encuentra en su directorio de

trabajo.

a) Cuente el número total de conexiones realizadas (utilice el comando wc).

b) Genere un nuevo archivo llamado analisis.dat que contenga todas las
conexiones recibidas por el puerto 25 durante el mes de abril (04) de 2005.
c) Cuente el número de cohesiones realizadas desde la máquina de la subred
125.130.
d) Muestre por la consola todas las conexiones realizadas a través de los puestos
por debajo del puerto 90.

5
1.2. Espacio de disco.

A partir de la información del comando df -ka que se muestra a continuación,

escriba en una línea un comando o conjunto de comandos conectados mediante tuberías
para realizar las siguientes operaciones:

> df -ka
Filesystem kbytes used avail capacity Mounted on
/dev/md/dsk/d2 4129290 191573 3896425 5% /
/dev/md/dsk/d5 4129290 1129374 2958624 28% /usr
/proc 0 0 0 0% /proc
fd 0 0 0 0% /dev/fd
mnttab 0 0 0 0% /etc/mnttab
/dev/md/dsk/d8 4129290 1360464 2727534 34% /var
swap 5541176 24 5541152 1% /var/run
swap 5542488 1336 5541152 1% /tmp
/dev/md/dsk/d11 18491215 3223353 15082950 18% /opt
/dev/dsk/c0t9d0s7 35007716 5337270 29320369 16% /export/home
/dev/dsk/c0t10d0s7 35007716 15579221 19078418 45%
/export/home/alumnos
-hosts 0 0 0 0% /net
-xfn 0 0 0 0% /xfn
murillo:vold(pid287) 0 0 0 0% /vol
>_

a) Obtener un listado de los sistemas de ficheros sin capacidad (capacity = 0%).

b) Obtener un listado de los sistemas con una capacidad igual o superior al 40%.
c) Obtener el número de sistemas de ficheros (Filesystems) montados a partir
de /export/

1.3. Tipos de ficheros.

A partir de la información almacenada en el archivo “fichero”, cuyo contenido

se muestra a continuación, escriba en una línea un comando o conjunto de comandos
conectados mediante tuberías para realizar las siguientes operaciones:

murillo:/export/home/prof/lensis> file * > ficheros

murillo:/export/home/prof/lensis> cat ficheros
ficheros: empty file
hola: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, not stripped
holaMundo.c: c program text
holaMundo.e: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, not stripped
holaMundo.o: ELF 32-bit MSB relocatable SPARC Version 1
identidad: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, not stripped
identidad.c: c program text
identidad.c~: c program text
imprime.c: c program text
list: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, not stripped
listArgs: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, not stripped
listArgs.c: c program text
listArgs.c~: c program text
pot_fac: directory

6
 a) Contar el número de directorios que aparece en el archivo “ficheros”.
b) Contar el número de archivos ejecutables que aparecen en el archivo “ficheros”.

1.4. Listado de procesos.

A partir de la información del comando ps que se muestra a continuación, escriba

en una línea un comando o conjunto de comandos conectados mediante tuberías para
realizar las siguientes operaciones:

murillo:/export/home/prof/lensis> ps -a
PID TTY TIME CMD
529 pts/3 0:02 dtsessio
512 pts/3 0:00 ksh
528 pts/3 0:00 ttsessio
1615 pts/5 3:59 nwadmin
21477 pts/22 0:00 tcsh
7204 pts/3 0:01 dtfile
7203 pts/3 0:00 sh
7206 pts/3 0:00 dtfile
22717 pts/18 0:01 tcsh
21476 pts/22 0:00 ksh
23630 pts/40 0:00 ps
22716 pts/18 0:00 ksh
21576 pts/22 0:05 emacs
7160 pts/7 0:00 ksh

a) Obtener un listado de todos los procesos en ejecución en la terminal o puesto

3 y 5.
b) Contar el número de procesos en ejecución en la terminal o puesto 3.
c) Contar el número de intérpretes de comandos (programa ksh) que está
ejecutando el sistema. Este apartado no tiene nada que ver con la figura 1.

1.5. Búsqueda de patrones

A continuación se proponen varios enunciados para resolver mediante el

comando grep con los patrones adecuados.
a) Muestre el nombre de todos los archivos de la carpeta practicas del apartado
anterior que utilicen llamadas al sistema para trabajar con semáforos (utilice
la opción –l del comando grep para obtener el nombre de los ficheros en
lugar de las líneas que cumplan el patrón).
b) Escriba una instrucción grep que obtenga los mismos resultados que la
siguiente sentencia: "grep -v '^[^a]' fichero". La sentencia grep que escriba
debe tener un patrón diferente del patrón usado en la sentencia grep anterior.
c) Contar el número de archivos de código fuente C (.c) del directorio donde
me encuentro.

7
 d) Cuente el número de copias de seguridad (hechas por el editor Emacs) de
archivos con código C que aparecen en el directorio ficheros. Las copias de
seguridad de Emacs tienen el mismo nombre que el archivo original
terminado con el carácter ‘~’.

1.6. Variables de entorno.

A continuación se proponen varios apartados para ser resueltos utilizando variables

de entorno.
a) El servidor web Apache coloca en una variable de entorno APACHE_PID el
pid del proceso en ejecución y deseamos enviarle una señal para terminar su
ejecución de manera abrupta.
b) Asigne el valor de la variable PATH a una variable de entorno con nombre
RUTA.

1.7. Gestión de ficheros.

A continuación se proponen varios apartados para ser resueltos utilizando los

comandos para gestionar ficheros y directorios.
a) Suponiendo que en su directorio de trabajo (el directorio donde se encuentra)
existen 4 ficheros llamados f01, f02, f03 y f04, escriba un único comando
para copiar los tres primeros a una carpeta ficheros que cuelga de su
directorio HOME.
b) Copie todos los archivos existentes/ubicados dentro la carpeta ejemplos, que
cuelga de la carpeta temporal, a la carpeta practicas que cuelga de su
directorio de trabajo (o cuenta).
c) Copie el archivo profile-ejemplo situado en el directorio tmp que cuelga del
directorio raíz, a su directorio home con el nombre .profile. Escriba el
comando utilizando rutas absolutas.
d) Borre un fichero con nombre core situado en su directorio home.
e) Mueva todos los archivos de código fuente C del directorio donde me
encuentro a un subdirectorio llamado src que cuelga del directorio donde me
encuentro.

1.8. Permisos de ficheros.

Resuelva los siguientes apartados mediante el comando chmod otorgando o

quitando los permisos adecuados.
a) Un fichero prueba tiene los siguientes permisos rw-r-----. Escriba un
comando que produzca el mismo efecto que el comando chmod a+x prueba.
b) Otorgue únicamente permisos de ejecución al programa prueba para el
usuario propietario y su grupo (los demás permisos déjelos como
estuviesen).

8
1.9. Gestión de recursos IPC.

A continuación se proponen varios apartados para ser resueltos utilizando los

comandos de gestión de recursos IPC (semáforos, colas de mensajes y memoria
compartida).
a) Escriba un comando para obtener un listado de todas las colas de mensaje
que actualmente están en uso en el sistema.
b) Obtenga un listado de todos los recursos IPC que tiene activos el usuario que
ejecuta el comando.
c) Cuente el número de recursos IPC activos de tipo semáforo cuyo dueño es el
usuario que ejecuta el comando.
d) Elimine el recurso IPC de tipo semáforo cuyo ID está almacenado en la
variable de entorno ID_SEM.
e) Obtenga las colas de mensajes existentes en el sistema. Como es previsible
que existan muchos recursos de este tipo, debe mostrarse la salida de tal
manera que se pueda visualizar en pantalla correctamente.
f) Elimine un grupo de semáforos cuyo identificador es el 4127.

1.10. Envío de señales.

Envíe una señal de finalización al proceso que ejecuta el programa emacs (PID
4242), suponiendo que tiene los permisos adecuados. La señal podría ignorarse y el
proceso podría continuar en ejecución. . Tenga en cuenta que se desea ejecutar dicho
comando en un shell korn.

9
1.3 Soluciones

1.1. Contar entradas de directorio.

Apartado a.
wc –l $LOGS/fichero-log.*

Apartado b.
grep ‘P:25’ $LOGS/fichero-log.2005.04.* > analisis.dat

Apartado c.
¿?

Apartado d.
¿?

1.2. Espacio de disco.

Apartado a.
df -ka | grep ' 0%'

Apartado b.
Df -ka | grep '[456789].%'

Apartado c.
Df -ka | grep '/export' | wc -l

1.3. Tipos de ficheros.

Apartado a.
grep ':.*directory$' ficheros | wc -l

Apartado b.
grep ', dynamically linked,' ficheros | wc -l

1.4. Listado de procesos.

10
Apartado a.
ps -a | grep 'pts/[35]'

Apartado b.
ps -a | grep -w 'pts/3' | wc -l

Apartado c.
ps –A | grep –w 'ksh$' | wc -l

1.5. Búsqueda de patrones

Apartado a.
grep –l ‘sem\.h’ $HOME/practicas/*

Apartado b.
grep ‘^a’ fichero

Apartado c.
ls | grep ".c$" | wc -l

Apartado d.
grep '\.c~:' ./ficheros | wc -l

1.6. Variables de entorno.

Apartado a.
kill -9 $APACHE_PID

Apartado b.
export RUTA=$PATH

1.7. Gestión de ficheros.

Apartado a.
cp f01 f02 f03 $HOME/ficheros

Apartado b.

11
 cp /tmp/ejemplos/* $HOME/practicas

Apartado c.
cp /tmp/profile-ejemplo $HOME/.profile

Apartado d.
rm $HOME/core

Apartado e.
mv *.c ./src

1.8. Permisos de ficheros.

Apartado a.
chmod 751 prueba

Apartado b.
chmod ug+x prueba

1.9. Gestión de recursos IPC.

Apartado a.
ipcs –q

Apartado b.
ipcs | grep -w $USER

Apartado c.
ipcs –s | grep -w $USER | wc –l

Apartado d.
ipcrm –s $ID_SEM

Apartado e.
ipcs –q | more

Apartado f.
ipcrm -s 4127

12
1.10. Envío de señales.

Apartado a.

Como es un shell Korn, no ponemos SIG delante del nombre de las señales. Si fuera un
shell Bash (el que suele por defecto en Linux, por ejemplo), sí las pondríamos.
kill –15 (o –TERM o –s TERM) 4242

13
 Capítulo 3.

Ejercicios de ficheros y
directorios.

14
3.1. Resumen de conceptos.

Para una versión posterior.

3.2. Enunciados.

3.1. Contar entradas de directorio.

Escriba un programa que cuente todas las entradas del directorio dónde se
ejecuta (incluido directorios y entradas ocultas). Si el programa funciona correctamente,
el resultado debe ser el mismo que el de los comandos: ls –a | wc –l.
Es posible desarrollar muchas variantes de este ejercicio. Por ejemplo puede
ampliar el programa para que en ve de tomar el directorio dónde se ejecuta, se pueda
indicar un directorio por línea de comandos. También puede hacer variantes para contar
sólo los directorios o contar sólo las entradas ocultas.

3.2. Contar entradas desglosadas.

Este ejercicio es una variante del ejercicio anterior. Ahora, el programa debe
contar los directorios y los archivos regulares y mostrar el total de cada uno.
Compruebe como el resultado del programa puede ser distinto al resultado
obtenido por los comandos: ls –a | wc –l . ¿Por qué sucede esto?. Plantéese como
ejercicio opcional, mejorar este programa para que también cuente otros tipos de
entradas de directorio que no sean ni archivos regulares ni directorios?.
En el apartado de soluciones, encontrará una variante de este programa que,
además de la cuenta desglosada, también cuenta cuantas entradas pertenecen al mismo
usuario que ejecuta el programa y cuantas pertenecen a otros usuarios.

3.3. ¿Es un directorio?.

Escriba un programa que reciba por la línea de comandos la ruta de una entrada
de un directorio. El programa mostrará por pantalla un mensaje indicando si dicha
entrada es un directorio o no.
Una variante de este ejercicio es ampliar las opciones de este programa. Por
ejemplo, puede extender el programa para que indique si la entrada es un directorio, un
archivo regular, un enlace, etc.

3.4. Hola mundo.

15
 Escriba un programa que muestre por la consola el mensaje típico mensaje
“Hola mundo”. No utilice printf. Como este es el capítulo de archivos, utilice las
funciones de entrada y salida y descriptores de archivos para hacerlo.

3.5. Ciclo infinito.

Vamos a continuar trabajando con la entrada y salida estándares mediante

descriptores de archivos. Escriba ahora un programa que pida una entrada por teclado.
El programa deberá mostrar a continuación el mensaje introducido.
Procure que no aparezcan caracteres extraños al final del mensaje. Si aparecen,
es un síntoma de que el programa no es correcto.
Como ya imaginará, utilice exclusivamente los descriptores de archivo para leer
y escribir los mensajes.

3.6. Función copia.

En este ejercicio vamos a escribir una función copia con el siguiente prototipo.

int copia (int origen, inte destino)

¿Cuál puede ser el motivo de que esta función devuelva un valor entero?.
Como su nombre indica, esta función copiará todo el contenido del archivo
referenciado por el descriptor de archivo origen en el archivo referenciado por el
descriptor de archivo destino.
Escriba un programa que realice la copia de un fichero. Para comprobar si la
copia se ha efectuado correctamente, puede utilizar el comando para comparar archivos
cmp.

16
3.3 Soluciones

3.1. Contar entradas de directorio.

En este ejercicio podemos ver la estructura estándar para recorrer el contenido de un

directorio que usaremos en los ejercicios posteriores.

#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

// Aquí se declaran las variables globales

// y los prototipos de las funciones

int main();

int main() {

int cuenta=0;
DIR * dir;
char directorio[255];
struct dirent* entrada;

if (getcwd(directorio, 255)== NULL) {

perror("Error obteniendo dir. actual: ");
return -1;
}

dir = opendir(directorio);
if (dir == NULL) {
perror("Error abriendo directorio: ");
return -1;
}

entrada = readdir(dir);
while(entrada != NULL) {
cuenta++;
//free(entrada);
entrada = readdir(dir);
}

printf("Entradas: %i\n", cuenta);

if (closedir(dir) == -1) {
perror("Error cerrando directorio: ");
return -1;
}

return 0;
}

17
3.2. Contar entradas desglosadas.

#include <dirent.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

int main();

int main() {

int c_reg=0, c_dir=0;

DIR * dir;
char directorio[255];
char* nombre;
struct dirent* entrada;
struct stat info;

if (getcwd(directorio, 255)== NULL) {

perror("Error obteniendo dir. actual: ");
return -1;
}

dir = opendir(directorio);
if (dir == NULL) {
perror("Error abriendo directorio: ");
return -1;
}

entrada = readdir(dir);
while(entrada != NULL) {
nombre = entrada->d_name;
if (stat(nombre, &info) == -1) {
perror("Error leyendo información.");
}

if (S_ISDIR(info.st_mode))
c_dir++;
if (S_ISREG(info.st_mode))
c_reg++;

entrada = readdir(dir);
}

printf("Directorios: %i\n", c_dir);

printf("Regulares: %i\n", c_reg);

if (closedir(dir) == -1) {
perror("Error cerrando directorio: ");
return -1;
}

18
 return 0;
}

Variante.

#include <dirent.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

int main()
{
int regulares, directorios, otros;
int mios, ajenos;
char directorio[256];
DIR *bd;
struct dirent *entrada;
struct stat finfo;

regulares = directorios = otros = 0;

mios = ajenos = 0;

if ( getcwd(directorio, 256) == NULL)

{
perror("Error obteniendo el directorio actual.\n");
return -1;
}

bd = opendir(directorio);
if (bd == NULL)
{
perror("Error obteniendo el bloque del directorio.\n");
return -1;
}

entrada = readdir(bd);
while( entrada != NULL)
{
if ( stat(entrada->d_name, &finfo)==-1 )
{
perror("Error obteniendo información.\n");
return -1;
}

if ( S_ISDIR(finfo.st_mode) )
directorios++;
else if ( S_ISREG(finfo.st_mode) )
regulares++;
else
otros++;

if ( getuid() == finfo.st_uid )
mios++;
else
ajenos++;

19
 entrada = readdir(bd);
}

closedir(bd);

printf("\nDir: %i\nReg: %i\n: %i\n", directorios, regulares, otros);

printf("Mios: %i\nAjenos: %i\n", mios, ajenos);

return 0;
}

3.3. ¿Es un directorio?.

Una versión más potente de este programa la puede encontrar en el comando file.

Solución para una nueva versión.

3.4. Hola mundo.

Este ejercicio es realmente sencillo, solo es necesario una línea de código. Sin
embargo, es muy valioso repasar los fundamentos. Todo proceso tiene en su tabla de
descriptores de archivo tres descriptores abiertos y listos para ser usados. Estos
descriptores referencia a la entrada estándar (descriptor 0), salida estándar (descriptor
1) y salida estándar de errores (descriptor 2). Por lo tanto sólo tenemos que escribir en
el descriptos 1 para enviar información a la consola.

#include <stdio.h>
#include <stdlib.h>
#define TAM_BUF 255

int main(int argc, char *argv[])

{
char buf[TAM_BUF];

strcpy(buf, "Soy tocon.\n");

write(1, buf, /*strlen(buf)*/10);

printf("Hello, world!\n");

return 0;
}

3.5. Ciclo infinito.

20
Lo más importante de este programa es caer en la cuenta de que no debe mostrarse por
pantalla todo el contenido del buffer. Sólo deben mostrarse el mismo número de bytes
que se han leído.
Aunque no es relevante para este ejercicio, es importante saber que read no devuelve
una cadena de texto, es decir, el buffer no termina en ‘\0’. Para que el buffer sea una
cadena de texto correcta, se debe añadir el carácter ‘\0’ al final de los bytes leidos.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[])

{
char buf[TAM_BUF];
int readed;

readed = read(0, buf, TAM_BUF);

while(readed > 0)
{
write(1, buf, readed);
readed = read(0, buf, TAM_BUF);
}

return 0;
}

3.6. Función copia.

El motivo por el que esta función devuelve un valor entero es para indicar si todo fue
bien o si hubo algún error, al igual que la mayoría de funciones de las bibliotecas de C.

Archivo copia.h
#ifndef __copia__
#define __copia__

int copia(int, int);

#endif

Archivo copia.c
#include <unistd.h>
#include "copia.h"

int copia(int fd_origen, int fd_destino)

{
const int SIZE = 256;
char buffer[SIZE];
int readed;

21
 while ( (readed=read(fd_origen, buffer, SIZE)) > 0) {
if ( write(fd_destino, buffer, readed) == -1 )
return -1;
}

return 0;
}

Archivo de prueba.
#include <unistd.h>
#include <sys/file.h>
#include "copia.h"

int main(int argc, char *argv[])

{
int fd_origen, fd_destino;

if (argc != 3) {
printf("\nUso: pruebaCopia <origen> <destino> \n");
return 0;
}

fd_origen = open(argv[1], O_RDONLY);

fd_destino = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 00600);

if ( (fd_origen == -1 ) || (fd_destino==-1)) {
perror("\nError en la apertura de ficheros\n");
return -1;
}

if ( copia(fd_origen, fd_destino) != 0 ) {
perror("Fallo en la copia\n");
return -1;
}

close(fd_origen);
close(fd_destino);
printf("Copia correcta. \n");
return 0;
}

22
 Capítulo 4.

Ejercicios de Procesos.

23
4.1. Resumen de conceptos.

Para una versión posterior.

4.2. Enunciados.

4.0. Los números.

Tenemos el sencillo programa que se muestra a continuación, el cuál muestra por

pantalla las cadenas uno, dos y tres en ese mismo orden.

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void) {
// fork();
printf("Uno\n");
// fork();
printf("Dos\n");
// fork();
printf("Tres\n");
return 0;
}

¿Cuál sería el resultado de este programa si quitamos cada uno de los comentarios de la
llamada a fork. Es decir, que aparecerá por la consola y en qué orden (si es que se puede
predecir)?. ¿Y si quitamos los comentarios de todas las llamadas a fork a la vez?.

4.1. ¿Cuántos mensajes aparecen?.

El objetivo de este primer ejercicio no es escribir ningún programa, sino

familiarizarse con el funcionamiento de la llamad al sistema fork. Esta llamada va a ser
muy utilizada en siguientes ejercicios y capítulos, por lo que vale la pena entenderla.
Observe detenidamente el siguiente código. Intente entender lo que hace sin
necesidad de ejecutarlo.

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void) {

int c;
pid_t pid;

24
 printf("Comienzo.:\n");
for (c = 0; c < 3 ; c++ )
{
pid = fork();
}
printf("Proceso\n");
return 0;
}

A la vista del código anterior y, sin ejecutarlo, responda: ¿Cuántas líneas con la
palabra “Proceso” aparecen al final de la ejecución de este programa?. El número de
líneas es el número de procesos que han estado en ejecución.
Ejecute el programa y compruebe si su respuesta es correcta, Modifique el valor
del bucle for y compruebe los nuevos resultados.

4.2. El valor de los números.

Vamos a tomar una variante del programa anterior. Ahora, además de un

mensaje, vamos a añadir una variable y, al final del programa vamos a mostrar su valor.
El nuevo código del programa se muestra a continuación.

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void) {

int c;
int p=0;
pid_t pid;

for (c = 0; c < 3 ; c++ )

{
pid = fork();
}
p++;
printf("Proceso %d\n", p);

return 0;
}

Ya vimos en el ejercicio anterior, cuantas líneas aparecen por consola al finalizar

la ejecución de este programa. Ahora la pregunta que nos planeamos es: ¿qué valores se
muestran por consola?. ¿Todas las líneas tendrán el mismo valor o algunas líneas
tendrán valores distintos?. ¿Cuál es el valor (o valores) que aparece?.
Ejecute el programa y compruebe si su respuesta es correcta, Modifique el valor
del bucle for y el lugar dónde se incrementa la variable p y compruebe los nuevos
resultados.

4.3. Padres e hijos.

25
 Escriba un programa que lance tres nuevos procesos hijos. Estos procesos
mostrarán su identificador de proceso (PID) y el identificador de proceso de su padre
(PPID) y, después, terminarán.
El proceso padre debe esperar a que los procesos hijos terminen antes de
finalizar. ¿Qué pasaría si el proceso padre no esperara a los hijos?. Pruebe esto varias
veces, aumentando el número de hijos y compruebe los resultados.
Asegúrese que todos los PID y PPID mostrados son correctos y que, a diferencia
de los ejercicios anteriores, ningún proceso hijo llama a fork ni crea nuevos hijos.

4.4. Padres, hijos y nietos.

Este ejercicio es una variante del ejercicio anterior. Ahora, cada uno de los tres
procesos hijos va a lanzar tres nuevos procesos. Estos procesos (que llamaremos
procesos nietos), también mostrarán su PID y su PPID. Recuerde que, ahora, los
procesos hijos deben esperar a que los procesos nietos hayan terminado antes de llamar
a exit y finalizar.
Al igual que en el ejercicio anterior, compruebe que todos los PID y PPID son
correctos y que no se lanzan nuevos procesos inesperados.

4.5. Redirección de mensajes de error.

En este ejercicio vamos a introducir el mecanismo básico para redirigir la

entrada o salida de un programa desde el mismo programa.
Escriba un programa que, desde su código, redirija todos los mensajes de error al
fichero errores.txt. Simule algunos errores y compruebe como, efectivamente, no
aparecen por la consola sino que se almacenan en dicho archivo.

4.6. Ejecución y redirección de comandos.

Vamos a seguir profundizando en la redirección de entradas de la tabla de

descriptores de archivo. Ahora, vamos a escribir un programa que realice lo mismo que
el comando ls -a > ls.txt.
Sin embargo, no lo vamos a hacer utilizando las funciones que vimos en el
capítulo anterior. En su lugar, escribiremos un programa que ejecute el comando ls –a
mediante alguna de las funciones de la familia exec y redirija su salida al fichero ls.txt
tal y como hemos hecho en el ejercicio anterior (utilizando la función dup o dup2).
Este ejercicio presenta varias cuestiones muy interesantes que nos servirán para
ejercicios posteriores. Por ejemplo, ¿cuál de las funciones pertenecientes a la familia
exec es la más adecuada en este caso?. ¿Cómo se puede redirigir la salida del comando
ls al archivo?. ¿Por qué no ejecutamos directamente el comando ls –a > ls.txt con una
función exec y nos ahorramos la redirección con las funciones dup (pruebe a ejecutar
esta variante)?.

4.7. El momento del adiós.

26
 En este ejercicio vamos a poner a prueba la función atexit. Para ello se propone
escribir un sencillo programa que muestre un mensaje de despedida cuando dicho
programa termine, independientemente del lugar dónde termine el programa.
Una vez que lo tenga escrito, inserte funciones exit aleatoriamente y compruebe
que, termine donde termine el programa, se muestra el mensaje de despedida.

4.8. Tuberías.

En este ejercicio vamos a introducir las tuberías anónimas, las cuales nos
servirán para comunicar dos procesos con un ascendente común (es decir, que tienen un
proceso ancestro común el cuál creó la tubería).
Se propone escribir un sencillo programa en el que un proceso cree una tubería y
después, lance un proceso hijo. El proceso padre enviará por la tubería una cadena de
texto. El hijo recibirá dicha cadena de texto y la mostrará por pantalla.

27
4.3 Soluciones

4.1. Contar entradas de directorio.

Recuerde que, cada proceso hijo comienza su ejecución siempre después de fork y
ejecuta el mismo código que su proceso padre, con el mismo valor para la variable
contadora del bucle for.
En la primera vuelta del bucle, el proceso padre llama a fork y se crea un proceso hio.
En este momento tenemos dos procesos.
En la segunda vuelta del bucle, tanto el proceso padre como el hijo llaman de nuevo a
fork y se crean dos nuevos procesos. En este momento tenemos cuatro procesos.
En la tercera vuelta del bucle, el padre y los hijos hacen lo mismo, es decir, ejecutan
fork. Se crean cuatro nuevos procesos. En este momento tenemos ocho nuevos
procesos.
Como el bucle ya no da más vueltas, o se llama más a fork y, cada uno de los ocho
procesos muestra su mensaje por la consola.

4.2. El valor de los números

Cada proceso, padres e hijos, tiene su propia copia de todas las variables. Estas copias
son independientes de las demás variables de los demás procesos. Por ese motivo, los
ocho procesos tendrán una variable p con valor 0 y, al final de la ejecución, se muestra
ocho veces el valor 1.

4.3. Padres e hijos

Este ejercicio es muy sencillo, sin embargo muestra el esquema que usaremos siempre
que lancemos nuevos procesos hijos con fork. Los hijos realizarán su tarea y
terminarán con una llamada a exit. El padre hará su tarea y esperará a sus hijos con
llamadas a wait hasta que todos los hijos hayan terminado.

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <sys/types.h>

int main(void) {

int i;
int status;
pid_t pid;

printf("Padre con ID %i\n", (int)getpid());

for (i=0; i < 3; i++)
{
if (fork() ==0) {

28
 printf("Hijo %i con padre %i\n",(i+1), (int)getppid() );
exit(0);
}
}

printf("Padre espera a hijos.\n");

pid = wait(&status);
while ( (pid != -1) || ( (pid==-1) && (errno == EINTR) ) ) {
printf("Hijo %i terminado.\n", (int)pid);
pid = wait(&status);
}

printf("Todos los hijos terminados.\n");

return 0;
}

4.4. Padres, hijos y nietos.

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <sys/types.h>

int main(void) {

int i;
int status;
pid_t pid;

printf("Padre con ID %i\n", (int)getpid());

for (i=0; i < 3; i++)
{
if (fork() ==0) {
printf("Hijo %i con padre %i\n", getpid(), getppid() );
if (fork() ==0) {
printf("Nieto %i con padre %i\n", getpid(),getppid() );
exit(0);
}
pid = wait(&status);
while ( (pid != -1) || ( (pid==-1) && (errno == EINTR) ) ) {
printf("Niero %i terminado.\n", (int)pid);
pid = wait(&status);
}

exit(0);
}
}

printf("Padre espera a hijos.\n");

pid = wait(&status);
while ( (pid != -1) || ( (pid==-1) && (errno == EINTR) ) ) {
printf("Hijo %i terminado.\n", (int)pid);
pid = wait(&status);

29
 }

printf("Todos los hijos terminados.\n");

return 0;
}

4.5. Redirección de mensajes de error.

Lo primero que tenemos que hacer es crear el archivo errores.txt con permisos de
escritura. Como ya vimos en el boletín anterior, todos los mensajes de error se envían
al descriptor de archivo 3, que, por defecto se envía a la salida estándar que es la
consola. Lo único que hay que hacer es cambiar esto para que todo lo que se encía al
descriptor de archivo 3 termine en el archivo errores.txt. Esto lo vamos a hacer con la
función dup o dup2.

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/types.h>

int main()
{
int fp;
int fpdup;

fp = open("errores.txt", O_WRONLY | O_CREAT | O_TRUNC, 00600);

if (fp == -1)
{
perror("Error abriendo fichero.\n");
return -1;
};

fpdup=dup2(fp, 2);
printf("%i / %i\n", fp, fpdup);

close(fp);

perror("Error simulado.\n");

return 0;
}

4.6. Ejecución y redirección de comandos.

Observe que, después de la ejecución de la función execlp sólo se ejecuta el código si

hubo un error en la función execlp por ese motivo, hemos de redireccionar la salida del
comando ls antes de ejecutarlo.

#include <fcntl.h>
#include <stdio.h>

30
#include <unistd.h>
#include <wait.h>
#include <sys/types.h>

int main() {

int fd;
pid_t pid;
int status;

fd = open("ls.txt", O_WRONLY | O_CREAT | O_TRUNC, 0600);

if (fd == -1) {
perror("Error creando archivo ");
return -1;
}

pid = fork();
if (pid == -1) {
perror("Error creando proceso ");
close(fd);
return -1;
}

if (pid == 0) {
status = dup2(fd, STDOUT_FILENO);
close(fd);
if (status == -1) {
perror("Error duplicando descriptores ");
exit(EXIT_FAILURE);
}
status = execlp("ls", "ls", "-l", NULL);
perror("Error ejecutando ls.");
exit(EXIT_FAILURE);
}

close(fd);
while ( wait(&status) != pid) ;

return 0;
}

4.7. El momento del adiós.

#include <unistd.h>

void msg_adios();

int main()
{
int status;

status=atexit(msg_adios);
if (status == -1) {
perror("Error instalando el manejador - ");
exit(-1);
}

31
 printf("Me termino.\n");
exit(0);
}

//-------------------------------------------------

void msg_adios() {
printf("Adios. \n");
}

4.8. Tuberías.

#include <unistd.h>
#include <sys/types.h>

int main()
{
int tub[2];
char msg[256];
pid_t pid;
int status;

pipe(tub);
pid = fork();

if (pid !=0) {
// El padre
close(tub[0]);
write(tub[1], "Soy padre.\n", 12);
wait(&status);
return 0;
}
else {
// El hijo
close(tub[1]);
read(tub[0], msg, 256);
printf("Hijo > %s / %ld\n", msg, getpid());
exit(0);
}

32
 Capítulo 5.

Ejercicios de señales.

33
5.1. Resumen de conceptos.

Para una versión posterior.

5.2. Enunciados.

5.1. Contar señales.

Escriba un programa que cuente las señales USR1 y USR2 que recibe. Cuando
este programa reciba la señal TERM, mostrará el número de señales USR1 y USR2
recibidas y terminará.
Una variante de este ejercicio, si ha utilizado un manejador distinto para cada
señal, es escribir una nueva versión utilizando una única función como manejador para
ambas señales.

5.2. Monitor de procesos PMon.

Se desea implementar un programa de monitorización automática de procesos

cuyo funcionamiento se describe a continuación:
1. El programa recibirá por línea de comandos el número de segundos
(llamados S a partir de ahora) que esperará antes de comprobar el estado de
los procesos y los identificdores de los procesos a monitorizar (al menos 1,
máximo 10).
2. El programa creará un archivo llamado pmon.log (o lo truncará si ya
existiera) donde guardará los datos de la montorización.
3. Pasados S segundos, el sistema escribirá en el archivo la fecha y hora actual
y si los procesos sigen aún en activo o terminaron. Si un proceso terminó
deja de monitorizarse (vea las filas 4, 5 y 6 del ejemplo).
4. El punto 3 se repite hasta que el programa reciba la señal de terminación
(SIGTERM), momento en el que cierra el archivo y termina su ejecución.
A continuación se muestra un ejemplo detallado del funcionamiento de este
programa por si le fuera de utilidad.

$ps
PID TTY TIME CMD 1. Vamos a monitorizar los procesos que ejecutan
1723 ttyp0 00:00:00 bash
1779 ttyp0 00:00:08 emacs
Emacs y KWrite (dos editores de texto). En este
4217 ttyp0 00:00:01 kwrite ejemplo, los PID de ambos procesos son 1779 y
4259 ttyp0 00:00:00 ps 4217 y se han resaltado en negrita.
$
$ pmon 2. Ejecutamos el programa de monitorización para
Uso: pmon <seg> <pro1> ... <pro10>
que compruebe si dichos procesos extán activos
$ pmon 12 1779 4217 & cada 12 segundos.
$ Ejecutamos el programa en segundo plano.
$ps
PID TTY TIME CMD 3. Si vemos de nuevo los procesos del sistema,

34
 1723 ttyp0 00:00:00 bash observamos que también está activo el programa
1779 ttyp0 00:00:08 emacs de monitorización (PID 4373).
4217 ttyp0 00:00:01 kwrite
4373 ttyp0 00:00:00 pmon
4459 ttyp0 00:00:00 ps
$
$ kill 4217
[2]- Terminado kwrite 4. A las 11:50:06 del día 3 de diciembre de 2005,
$ps enviamos una señal de terminación al proceso que
PID TTY TIME CMD ejecuta el editor KWrite y este termina
1723 ttyp0 00:00:00 bash normalmente (comando kill).
1779 ttyp0 00:00:08 emacs Si volvemos a obtener los procesos, vemos que
4373 ttyp0 00:00:00 pmon sigen activos el proceso que ejecuta Emacs y
4779 ttyp0 00:00:00 ps
nuestro monitor, pero ya no está el 4217.
$
$ kill 4373 5. A las 11:50:40 del día 3 de diciembre de 2005,
[2]- Terminado pmon enviamos una señal de terminación al proceso que
$ ejecuta nuestro monitor y este termina
normalmente.
$ cat pmon.log
Sat Dec 3 11:49:38 2005
Proceso 1779 aún activo.
Proceso 4647 aún activo.
Sat Dec 3 11:49:50 2005 6. Después vemos el contenido del archivo
Proceso 1779 aún activo. pmon.log.
Proceso 4647 aún activo. Observe que cada entrada entrada se anota 12
Sat Dec 3 11:50:02 2005 segundos después de la entrada anterior porque en
Proceso 1779 aún activo.
Proceso 4647 aún activo.
el paso 2 le indicamos 12 segundos a pmon.
Sat Dec 3 11:50:14 2005 Observe que, a las 11:50:14, nuestro programa
Proceso 1779 aún activo. detecta qué el proceso 4217 (el kwrite) ya ha
Proceso 4647 terminado. terminado.
Sat Dec 3 11:50:26 2005 Observe también como en las entradas posteriores
Proceso 1779 aún activo. ese proceso ya no aparece.
Sat Dec 3 11:50:38 2005
Proceso 1779 aún activo.
Fin de la monitorización.
$

Ayuda:
- Recuerde que puede conocer si un PID existe o no enviándole la señal 0
mediante la función Hill..
- Por simplicidad suponga que el máximo número de procesos a monitorizar será
10.
- Para obtener la fecha y la hora del sistema utilice las siguientes funciones:

time_t time(time_t *t)

Esta función devuelve la cantidad de segundos transcurridos desde el 1 de
enero de 1970. Si su argumento no es nulo, almacena el mismo valor en la
variable t.

char *ctime (const time *t)

Esta función convierte la cantidad de segundos que devuelve la función
anterior en una cadena de texto con la fecha y la hora (tal y como aparece en
el ejemplo).

5.3. Máquina de estados para el control de un servicio

35
 En este ejercicio proponemos escribir una sencilla máquina de estados controlada
por señales para controlar un servicio genérico. El funcionamiento de dicho programa se
describe a continuación:
1. Cuando el programa se inicia, inicializa el servicio (función
iniciar_servicio) y queda a la espera de recibir una señal USR1. Si, en este
punto recibe cualquier otra señal, el programa realiza el comportamiento por
defecto de dicha señal.
2. Cuando recibe dicha señal comienza a prestar el servicio continuamente (una
llamada continua a la función prestar_servicio).
3. Si el programa recibe un CTRL+C (recuerde, señal INT), el servicio se
interrumpe hasta que recibe una señal USR2. Cuando recibe una señal USR se
vuelve al punto 2.
4. Cuando el programa recibe un TERM, termina el servicio (función
terminar_servicio) y el programa terminará.
Utilice las siguientes funciones auxiliares para simular el servicio:
void iniciar_servicio();
void prestar_servicio();
void terminar_servicio();

5.4. La subasta

Se desea implementar un sistema automático y multiproceso de subastas. Las

subastas serán a ciegas, esto significa que los postores deberán hacer sus ofertas sin
conocer cuál es la máxima oferta que se ha presentado.
Los elementos del sistema automático de subastas son: un proceso gestor que
escucha las ofertas de los postores y declara un ganador, varios procesos postores que
realizan ofertas al gestor y un proceso lanzador que se encarga de crear el proceso
gestor y varios procesos postores.
Por comodidad puede suponer que todas las pujas y ofertas se expresan mediante
números enteros.
A continuación, en los siguientes apartados, se propone la codificación de cada
uno de los elementos del sistema de subastas. Se aconseja leer todos los apartados antes
de comenzar su resolución.

Apartado a.

Escriba el código del proceso gestor de la subasta. El funcionamiento del gestor

se describe a continuación:
1. El proceso gestor escuchará, mediante una tubería, las ofertas de los
distintos postores.
2. Si el proceso gestor recibe una oferta superior a la más alta, descarta la
más alta y guarda la nueva oferta.
3. Si el proceso gestor recibe una oferta igual o inferior a la más alta, avisa
al proceso postor para que mejore su oferta (mediante la señal
SIGUSR1). Ojo, puesto que es una subasta a ciegas, el gestor solo
informa de que la puja es muy baja, pero no dice cual es la puja actual.
4. Si pasan 5 seg. Sin que el proceso gestor reciba una oferta que supere a la
última más alta, el proceso gestor declara terminada la subasta e informa
al proceso postor que hizo la oferta más alta (mediante la señal
SIGUSR2).

36
 Tenga en cuenta que la subasta no comienza a partir de una cantidad concreta,
por lo que la primera oferta que reciba el gestor será la oferta más alta.
Escriba el código en un archivo “gestor.c” y genere un ejecutable llamado
“gestor”. Esto no tiene relevancia en este apartado pero es necesario para el apartado d.

Apartado b.

Escriba el código de un proceso postor de apuesta única. El funcionamiento del

postor se describe a continuación:
1. El proceso postor enviará su oferta al gestor a través de una tubería y
esperará a recibir una contestación. La cantidad de la oferta puede ser un
número fijo, un número aleatorio, el PID del proceso, la hora del sistema,
etc.
2. Si el proceso postor es informado de que debe mejorar su apuesta (recibe
señal SIGUSR1), el proceso postor se retira de la puja (termina).
3. Si el proceso postor es informado de que ganó la subasta, muestra un
mensaje por pantalla y termina.
Se aconseja leer el siguiente apartado antes de solucionar este.
Suponga que el código del proceso postor de apuesta única se almacena en un
archivo “postor_1.c” y se compila en un archivo “postor_1”. Esto no tiene relevancia en
este apartado pero es necesario para el apartado d.

Apartado c.

Escriba el código de un proceso postor de apuesta múltiple. El funcionamiento

del postor se describe a continuación:
1. El proceso postor enviará su oferta al gestor a través de una tubería y
esperará a recibir una contestación. La cantidad de la oferta puede ser un
número fijo, un número aleatorio, el PID del proceso, la hora del sistema,
etc.
2. Si el proceso postor es informado de que debe mejorar su oferta (recibe señal
SIGUSR1), el proceso postor le suma una cantidad a su oferta y la vuelve a
enviar. La cantidad añadida puede ser un número fijo, un número aleatorio,
el PID del proceso, la hora del sistema, etc.
3. Si el proceso postor es informado de que ganó la subasta, muestra un
mensaje por pantalla y termina.
Suponga que el código del proceso postor de apuesta única se almacena en un
archivo “postor_2.c” y se compila en un archivo “postor_2”. Esto no tiene relevancia en
este apartado pero es necesario para el apartado d.

Apartado d.

Escriba el código de un proceso lanzador de subastas. El funcionamiento del

lanzador se describe a continuación:
1. El proceso lanzador creará toda la infraestructura necesaria para que el gestor
pueda recibir las pujas de los postores.
2. El proceso lanzador creará un hijo y lo reemplazará por el proceso gestor
(utilizando una función de la familia exec).

37
 3. Después, el proceso lanzador creará un hijo y lo reemplazará por el proceso
postor de apuesta múltiple (utilizando también exec).
4. Después, el proceso lanzador creará 5 hijos y, a cada uno, lo reemplazará por
el proceso postor de apuesta única (utilizando también exec).
Si todo funciona correctamente, será el proceso postor de apuesta multiple el que
termine ganando la subasta.

5.5. Padre impaciente

Escriba un programa que cree un programa hijo y espere 4 segundos. Si después

de ese tiempo el hijo aún no ha terminado, el programa lo mata enviándole una señal.
Antes de resolver este ejercicio intente resolver la siguiente pregunta, ¿sería
posible saber si un proceso hijo ha terminado enviando una señal 0 mediante kill (como
hemos hecho en el ejercicio 2)?. Piense que, aunque el proceso haya terminado, si el
proceso padre sigue activo y no ha llamado a wait o a waitpid el proceso hijo sigue
existiendo en el sistema.

5.6. Contador vivo

Escriba un programa que haga uso de las alarmas para mostrar el valor de un
contador cada 2 segundos. El contador se incrementará en uno cada vez que se muestre
su valor.
Por ejemplo, si este programa estuviera en ejecución durante 11 segundos, su
resultado sería el que se muestra a continuación.
$ ./vivo
Contador: 0
Contador: 1
Contador: 2
Contador: 3
Contador: 4
^C
$_

5.7. El banco

Una entidad bancaria almacena todas las operaciones de transferencias de fondos

de una cuenta a otra en un único fichero maestro. Las operaciones de transferencia se
reciben de varios ordenadores locales con capacidad de procesamiento autónomo.
Como pasa siempre en la vida real, el sistema no es perfecto y hay veces que los
ordenadores locales no pueden acceder al fichero maestro: fallos en la red, alta carga de
trabajo, mantenimiento del servidor, etc. Para la entidad es impensable que se detengan
las transacciones o que se pierda información de alguna de ellas. La solución adoptada
consiste en aprovechar las capacidades de procesamiento de los ordenadores locales.
Así, si un ordenador local no puede acceder al fichero maestro, almacenará la
transacción en un fichero local. Por las noches, un proceso recolector sondea los
ordenadores locales y añade al fichero maestro todas las operaciones pendientes.

38
 En este ejercicio vamos a implementar el código del proceso local cuya misión enviar al
recolector todas las operaciones almacenadas en su máquina. Su funcionamiento se describe a
continuación:
1. El proceso local esperará hasta recibir la señal USR1.
2. Después, el proceso local leerá el archivo de operaciones (llamado ‘operaciones’). Éste es un
archivo binario que contiene una estructura de tipo s_operacion por cada operación
almacenada en el ordenador local. Cada operación la enviará a la salida estándar y leerá otra
operación del proceso recolector. Si el identificador de la operación leída es distinto del
identificador de la operación que acaba de enviar mostrará un mensaje de error de
verificación.
3. Cuando el proceso local haya enviado todas las operaciones, terminará la transmisión
enviando una nueva operación con identificador.

Utilice la estructura se muestra a continuación.

struct s_operacion {
int id_operacion;
char cuenta_origen[15];
char cuenta_destino[15];
double cantidad;
};

39
5.3. Soluciones

5.1. Contar señales.

Necesitamos utilizar variables contadoras globales para poder acceder a su valor

desde los distintos manejadores.
Es importante que se de cuenta de que, para terminar el programa, hemos llamado a la
función exit en el manejador de la señal TERM. Si no lo hubiéramos hecho, el
programa no terminaría a pesar de recibir la llamada de terminación.

#include <signal.h>
#include <unistd.h>

void manejadorUSR1(int sig);

void manejadorUSR2(int sig);
void manejadorTERM(int sig);

int cuenta1 = 0, cuenta2 = 0;

int main()
{

if ( signal(SIGUSR1, manejadorUSR1) == SIG_ERR) {

perror("Error instalando manejadorUSR1 - ");
return -1;
}

if ( signal(SIGUSR2, manejadorUSR2) == SIG_ERR) {

perror("Error instalando manejadorUSR2 - ");
return -1;
}

if ( signal(SIGTERM, manejadorTERM) == SIG_ERR) {

perror("Error instalando manejadorTERM - ");
return -1;
}

while(1)
sleep(5);

return 0;
}

//-------------------------
void manejadorUSR1(int sig) {

if ( signal(SIGUSR1, manejadorUSR1) == SIG_ERR) {

perror("Error instalamdno manejadorUSR1 - ");
exit(0);
}

cuenta1++;
}

//-------------------------
void manejadorUSR2(int sig) {

40
 if ( signal(SIGUSR2, manejadorUSR2) == SIG_ERR) {
perror("Error instalamdno manejadorUSR2 - ");
exit(0);
}

cuenta2++;
}

//---------------------------
void manejadorTERM(int sig) {

printf("Señales USR1 recibidas: %i \n", cuenta1);

printf("Señales USR2 recibidas: %i \n", cuenta2);
exit(0);
}

Variante utilizando un único manejador para las dos señales.

#include <signal.h>
#include <unistd.h>

void manejadorUSR(int sig);

void manejadorTERM(int sig);

int cuenta1 = 0, cuenta2 = 0;

int main()
{

if ( signal(SIGUSR1, manejadorUSR) == SIG_ERR) {

perror("Error instalando manejadorUSR1 - ");
return -1;
}

if ( signal(SIGUSR2, manejadorUSR) == SIG_ERR) {

perror("Error instalando manejadorUSR2 - ");
return -1;
}

if ( signal(SIGTERM, manejadorTERM) == SIG_ERR) {

perror("Error instalando manejadorTERM - ");
return -1;
}

while(1)
sleep(5);

return 0;
}

//-------------------------
void manejadorUSR(int sig) {

if ( signal(SIGUSR1, manejadorUSR) == SIG_ERR) {

perror("Error instalamdno manejadorUSR1 - ");
exit(0);
}

41
 if ( signal(SIGUSR2, manejadorUSR) == SIG_ERR) {
perror("Error instalamdno manejadorUSR2 - ");
exit(0);
}

if (sig == SIGUSR1)
cuenta1++;
else
cuenta2++;

//---------------------------
void manejadorTERM(int sig) {

printf("Señales USR1 recibidas: %i \n", cuenta1);

printf("Señales USR2 recibidas: %i \n", cuenta2);
exit(0);
}

5.2. Monitor de procesos PMon.

#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>

int fd;
char mensaje[255];

void man_quit(int);

int main(int argc, char ** argv) {

pid_t procesos[10];
int num_procesos;
unsigned int segundos;
int i;
int r;
time_t hora;
ssize_t leidos;

if (argc < 3) {
printf("Uso: pmon <seg.> <proceso1> .... <proceso10>\n");
return -1;
}

if ( signal(SIGTERM, man_quit) == SIG_ERR) {

perror("Error instalando manejador");
return -1;
}

42
 fd = open("pmon.log", O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd == -1) {
perror("Error creando archivo de log ");
return -1;
}

segundos = (unsigned int)atoi(argv[1]);

num_procesos = argc -2;

for (i=0; i < num_procesos; i++) {

procesos[i] = (pid_t)atoi(argv[i+2]);
printf("Proceso a monitorizar: %i\n", (int)procesos[i]);
}

while(1) {
sleep(segundos);

time(&hora);
strcpy(mensaje, ctime(&hora));
write(fd, mensaje, strlen(mensaje));

for (i=0; i < num_procesos; i++) {

if (procesos[i] != -1) {
printf("Monitorizando a: %i \n", (int)procesos[i]);

r = kill(procesos[i], 0);
if (r == -1) {
snprintf(mensaje, 255, "Proceso %i terminado.\n",
(int)procesos[i]);
procesos[i] = -1;
} else {
snprintf(mensaje, 255, "Proceso %i aŽún activo. \n",
(int)procesos[i]);
}

printf("%s", mensaje);
leidos = write(fd, mensaje, strlen(mensaje));
if (leidos == -1)
perror("Error escribiendo en archivo de log. ");
}

}
}

// Aquí no llega nunca

return 0;
}

//--------------------------------------
void man_quit(int sig) {

strcpy(mensaje, "Fin de la monitorizaciŽón.\n");

write(fd, mensaje, strlen(mensaje));

printf("%s", mensaje);

close(fd);

// Aquí no se puede poner return

43
 exit(0);
}

5.3. Máquina de estados para el control de un servicio

La idea principal de este programa, es ir instalando los manejadores a medida que

vamos cambiando de estados, en lugar de instalarlos todos al principio del programa.
También utilizamos una variable global para controlar cuando hay que prestar el
servicio y cuando no.
Esta solución incluye una implementación trivial de las funciones auxiliares.

#include <unistd.h>
#include <stdio.h>
#include <signal.h>

/** Funciones auxiliares **/

void iniciar_servicio();
void prestar_servicio();
void terminar_servicio();

/** Funciones de tratamiento de señales **/

void man_usr1(int s);
void man_usr2(int s);
void man_int(int s);
void man_term(int s);

/** Variable global **/

int servicio_activo;

int main() {

iniciar_servicio();

// Instalamos los manejadores de la señal

if (signal(SIGUSR1, man_usr1) == SIG_ERR) {
perror("Error instalando señal USR1.");
return -1;
}

pause();

// Inicializamos el servicio e instalamos los demás manejadores

servicio_activo = 1;

if (signal(SIGUSR2, man_usr2) == SIG_ERR) {

perror("Error instalando USR2.");
return -1;
}
if (signal(SIGINT, man_int) == SIG_ERR) {
perror("eRROR INSTALANDO int.");
return -1;
}
if (signal(SIGTERM, man_term)== SIG_ERR) {
perror("Error instalando TERM.");
return -1;

44
 }

while( 1 ) {
if (servicio_activo) {
prestar_servicio();
sleep(4);
}
else
pause();
}

return 0;

//--------------

void man_usr1(int s) {
// Esta no hace nada
}

void man_usr2(int s) {
if (signal(SIGUSR2, man_usr2) == SIG_ERR) {
perror("Error instalando USR2.");
return ;
}
servicio_activo = 1;
}

void man_int(int s) {
if (signal(SIGINT, man_int) == SIG_ERR) {
perror("Error instalando INT.");
return ;
}
servicio_activo = 0;
}

void man_term(int s) {
terminar_servicio();
exit(0);
}

//---- Funciones auxiliares -------------------

void iniciar_servicio() {
printf("Servicio iniciado.\n");
}
void prestar_servicio(){
printf("Servicio prestado.\n");
}
void terminar_servicio(){
printf("Servicio terminado.\n");
}

5.4. La subasta

Apartado a.

45
Es importante caer en la cuenta de que el gestor no es el responsable de crear la
tubería, sino que escuchará de una tubería ya creada. Por ese motivo, el gestor escucha
por su entrada estándar.
Será responsabilidad del programa de apartado d crear la tubería y rediriguirla a la
entrada estándar del programa gestor.
También es importante darse cuenta que este programa tiene que responder a quien le
envíe una oferta con una señal. Para poder enviar una señal a un proceso necesitamos
conocer su PID. ¿Cómo podemos saber el PID del proceso que nos ha enviado una
oferta?. La solución más sencilla es que sea el propio proceso que hace la oferta quien
nos informe de su PID. Por eso hemos creado una estructura con dos campos, uno para
la cantidad de la oferta y otro para el PID del proceso que la envía.

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#define TUB_IN 0

struct s_puja {
pid_t id;
int cantidad;
};

struct s_puja puja, max_puja;

void sig_alrm(int sig);

int main() {
ssize_t leidos;
max_puja.cantidad = -1;

if (signal(SIGALRM, sig_alrm) == SIG_ERR) {

perror("Error instalando manejador.");
return -1;
}

while(1) {
leidos = read(TUB_IN, &puja, sizeof(struct s_puja) );
if (leidos == -1)
perror("Error leyendo de tubería. ");

printf("Puja %i con candidad %i\n", (int)puja.id, puja.cantidad);

if (puja.cantidad > max_puja.cantidad) {
printf("En cabeza\n");
if (max_puja.cantidad != -1) {
printf( "Avisando a %i para que mejore \n", (int)max_puja.id);
if ( kill(max_puja.id, SIGUSR1) == -1 )
perror("Error enviando señal al mejor pujador. ");
}
max_puja = puja;
alarm(5);
}
// Si no mejora la puja le avisamos
else {
printf("Apuesta baja de %i. Le avisamos\n", (int)puja.id);
if (kill(puja.id, SIGUSR1) == -1 )

46
 perror("Error avisando a pujador para que mejore. ");
}
}
}

//----------------------------
void sig_alrm (int sig) {
printf("Ganador: %i, %i\n", (int)max_puja.id, max_puja.cantidad);
if ( kill(max_puja.id, SIGUSR2) == -1)
perror("Error avisando al ganador. ");
exit(0);
}

Apartado b.

Como este proceso va a escribir en una tubería que crea otro proceso, escribimos en la
salida estándar. Al igual que en el caso anterior. Será responsabilidad del
Aquí también usaremos la estructura definida en el apartado anterior

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

#define TUB_OUT 1

struct s_puja {
pid_t id;
int cantidad;
};

void sig_usr1(int sig);

void sig_usr2(int sig);

int main() {
ssize_t escritos;
struct s_puja puja;

if ( (signal(SIGUSR1, sig_usr1) == SIG_ERR) ||

(signal(SIGUSR2, sig_usr2) == SIG_ERR) ) {
perror("Error instalando manejador. ");
return -1;
}

puja.id = getpid();
puja.cantidad = (int)getpid();

escritos = write(TUB_OUT, &puja, sizeof(struct s_puja));

if (escritos == -1) {
perror("Error escribiendo en la tubería.");
return -1;
}

while (1) pause();

47
 // Este return no se ejecutará nunca
// return 0;
}

//---------------------
void sig_usr1(int sig) {
fprintf(stderr, "%i se retira de la puja.\n", (int)getpid() );
exit(0);
}

//---------------------
void sig_usr2(int sig) {
fprintf(stderr, "%i. He ganado....", (int)getpid());
exit(0);
}

Apartado c.

Este programa es muy similar al anterior. La principal diferencia es reorganizar el

código para que la puja esté dentro de un bucle.

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#define TUB_OUT 1

struct s_puja {
pid_t id;
int cantidad;
} puja;

void sig_usr1(int sig);

void sig_usr2(int sig);
void pujar();

int main() {

if ( (signal(SIGUSR1, sig_usr1) == SIG_ERR) ||

(signal(SIGUSR2, sig_usr2) == SIG_ERR) ) {
perror("Error instalando manejador. ");
return -1;
}
puja.id = getpid();
puja.cantidad = (int)getpid();

while(1) {
pujar();
pause();
}
//return;
}

//-------------------------
void pujar() {
ssize_t escritos;

48
 escritos = write(TUB_OUT, &puja, sizeof(struct s_puja));
if (escritos == -1)
perror("Error escribiendo en la tubería.");
}

//------------------------
void sig_usr1(int sig) {
if (signal(SIGUSR1, sig_usr1) == SIG_ERR) {
perror("Error instalando manejador. ");
return ;
}
fprintf(stderr, "%i incrementa su puja en 4.\n", (int)getpid() );
puja.cantidad += 4;
return;
}

//-------------------------
void sig_usr2(int sig) {
fprintf(stderr, "%i. He ganado \n", (int)getpid() );
exit(0);
}

Apartado d.

Este programa es largo pero muy sencillo. De hecho esto es un ejercicio de repaso del
capítulo anterior ya que no hay que usar nada relativo a señales.
Este programa sí es el responsable de crear la tubería. Lo más importante es acordarse
de redirigir la entrada y la salida de la tubería a la entrada estándar y la salida
estándar.

#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <sys/types.h>
#define APOSTANTES 5

int main() {
pid_t pid;
int i;
int tub[2];

if (pipe(tub) == -1) {
perror("Error creando tubería. ");
return -1;
}

printf("Creando gestor de subasta. \n");

pid = fork();
if (pid == -1) {
perror("Error creando proceso gestor. ");
return -1;
}

if (pid == 0) {
if ( (dup2(tub[0], STDIN_FILENO)) == -1) {

49
 perror("Error duplicando descriptor de entrada. ");
exit(0);
}
execl("./gestor", "./gestor", NULL);
perror("Error ejecutando el gestor.");
return -1;
}

// Creando postor ganador

pid = fork();
if (pid == -1)
perror("Error creando postor ganador. ");

if (pid == 0) {
if (dup2(tub[1], STDOUT_FILENO) == -1) {
perror("Error duplicando descriptor de salida.");
exit(0);
}
execl("./pujador_2", "./pujadore_2", NULL);
perror("Error ejecutando el programa postor_2.");
}

// Creando el resto de postores

for (i = 0; i < APOSTANTES; i++) {
pid = fork();
if (pid == -1)
perror("Error creando postor. ");

if (pid == 0) {
if ( dup2(tub[1], STDOUT_FILENO) == -1) {
perror("Error duplicando descriptor de salida.");
exit(0);
}
execl("./pujador_1", "./pujador_1", NULL);
perror("Error ejecutando el programa avion.");
}

pid = wait(NULL);
while ( (pid != -1) ||
( pid == -1 && errno == EINTR) )
pid = wait(NULL);

close(tub[0]);
close(tub[1]);

return 0;
}

5.5. Padre impaciente

El problema más interesante de este ejercicio, que complementa lo aprendido en el

capítulo anterior, es como saber si un hijo está activo o no. En esta solución utilizamos
la función waitpid con una constante para que el proceso no se detenga a esperarlo.

50
Si el proceso ya terminó, recogemos su valor de finalización y el proceso hijo termina
definitivamente. Si no le mandamos una señal para que termine (por ejemplo la señal
TERM), y recogemos su valor de finalización.

#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <sys/types.h>

int main()
{
pid_t pid, pid_hijo;
int status;
int sleep_padre = 2;
int sleep_hijo = 1;

if ( (pid_hijo=fork()) == -1) {
perror("Error en el fork - ");
return -1;
}

if (pid_hijo == 0) {
sleep(sleep_hijo);
printf("Termina hijo.\n");
exit(0);
}

sleep(sleep_padre);
pid = waitpid(pid_hijo, &status, WNOHANG);

printf("pid = %ld / pid_hijo = %ld / status = %i\n", pid, pid_hijo,

status);

if (kill(pid_hijo,0)==0) {
printf("Hijo aún en activo. Lo termino\n");
kill(pid_hijo, SIGTERM);
waitpid(pid_hijo, NULL, 0);
}
printf("Termina padre.\n");

return 0;
}

Debería responder también la pregunta que se plantea en el enunciado.

5.6. Contador vivo

#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void sig_alarm(int);

int num_alarm = 0;

51
int main()
{
if ( signal(SIGALRM, sig_alarm) == SIG_ERR) {
perror("Error instalando manejador - ");
return -1;
}

alarm(2);

while(1) {
printf("Alarma %i\n", num_alarm);
pause();
}

// Se ejecutará alguna vez esta línea ??

printf("Se acabó.\n");

return 0;
}

//---------------------------

void sig_alarm(int sig) {

if ( signal(SIGALRM, sig_alarm) == SIG_ERR) {

perror("Error instalando manejador - ");
}

alarm(2);
num_alarm++;
}

5.7. El banco

#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

struct s_operacion {
int id_operacion;
char cuenta_origen[15];
char cuenta_destino[15];
double cantidad;
};

int action = 0;

void manUSR1(int sig);

int main() {

52
 int r;
int fd;
ssize_t leidos, leidos_tub;
struct s_operacion operacion, op_copia, op_fin;
op_fin.id_operacion = -1;
const int TAM_OP = sizeof(struct s_operacion);

// Da igual poner un bucle infinito o no.

while(1) {

if ( signal(SIGUSR1, manUSR1) == SIG_ERR) {

perror("Error intalando el manejador.");
return -1;
}

// Espera USR1
while(action == 0) {
pause();
}

// Abre el archivo de operaciones

fd = open("operaciones", O_RDONLY);
if (fd == -1) {
perror("Error abriendo fichero de operaciones.");
return -1;
}

do {
// lee una operación
leidos = read(fd, &operacion, TAM_OP);
if ( (leidos > 0)) {
// La envía por la tubería
write(STDOUT_FILENO, &operacion, TAM_OP);

// Espera la confirmación
leidos_tub = read(STDIN_FILENO, &op_copia, TAM_OP);
if (leidos_tub > 0) {
if (operacion.id_operacion != op_copia.id_operacion) {
fprintf(stderr, "Error, operaciones distintas\n");
}
} else {
// Escribir mensaje error leyendo confirmación
perror("Error leyendo confirmación.");
}
}
if ( leidos == -1) {
perror("Error leyendo de fichero de operaciones.");
break;
}
} while (leidos != 0 );

// Enviamos el fin de transmisión

write(STDOUT_FILENO, &op_fin, TAM_OP);
close(fd);
action = 0;
}
return 0;
}

//----------------------------
void manUSR1(int sig) {

53
 action = 1;
}

54
 Capítulo 6.

Ejercicios de semáforos.

55
6.1. Resumen de conceptos.

Para una versión posterior.

6.2. Enunciados.

6.1. Gestor de semáforos por consola I

Se propone como ejercicio escribir un sencillo programa que permita manipular

semáforos mediante la consola. El funcionamiento del programa se muestra a
continuación.
1. En primer lugar el programa pedirá por teclado el número de semáforos a
crear.
2. Después creará un grupo con tantos semáforos como se han introducido.
3. A continuación el programa pedirá un semáforo y un valor. El programa
sumará al semáforo indicado el valor introducido por teclado.
Si se desea bajar un semáforo, no hay más que escribir un número negativo en el
punto 3. A continuación se muestran varias capturas del programa propuesto en la
solución en funcionamiento.

Poner las capturas.

Este programa le puede ayudar a entender mejor el mecanismo de los semáforos.

Abra varias terminales y ejecute este programa. Realice distintas pruebas viendo como
se bloquean y desbloquean las terminales al incrementar y decrementar los semáforos.
No utilice la constante IPC_PRIVATE para crear el grupo de semáforos o el
programa no funcionará adecuadamente. ¿Sería capaz de explicar cuál sería el problema
si utilizáramos la constante IPC_PRIVATE?.

6.2. Gestor de semáforos por consola II

En este ejercicio se propone escribir un programa que, al igual que el anterior,

permita hacer operaciones con semáforos. Sin embargo este programa no va a ser
interactivo, sino que indicaremos la operación en la línea de comandos.
Las opciones que debe soportar el programa se describen a continuación.

$ ./scon
Uso: ./scon [-c -r -l -d]
-c Crea el grupo de semáforos y lo inicializa
-r Reinicia el grupo de semáforos.
-l Muestra los valores de los semáforos
-r Borra el grupo de semáforos.

$ _

56
 El grupo de semáforos que crea la mopción –c tendrá 3 semáforos. Los valores
iniciales de dichos semáforos serán de 0, 3 y 0 respectivamente.
Si se invoca una operación pero el grupo de semáforos no ha sido creado, se
muestra un mensaje de error y la ejecución del programa termina.
A continuación tiene algunos ejemplos por si los encuentra útiles.

$ ./scon -r
Error recuperando grupo - : No such file or directory
$ ./scon -c
$ ./scon -l
Semaforo: 0 Valor 0 |Semáforo: 1 Valor 0 |Semáforo: 2 Valor 0 |
$ ./scon -c
Error creando grupo - : File exists
$ ./scon -d
$

En este ejercicio, al igual que el anterior, tampoco puede usar la constante

IPC_PRIVATE ya que, por el mismo motivo, el programa no funcionaría
correctamente. Intente obtener la clave del grupo de semáforos a partir del archivo
/etc/passwd con la ayuda de la función ftok. ¿Sabría explicar por qué este archivo es un
buen candidato para utilizarlo en el cálculo de la clave del grupo de semáforos?.

6.3. Te toca / me toca.

Escriba un programa que muestre por pantalla los números del 1 al 6 en el orden
correcto (es decir: 1, 2, 3, 4, 5, 6). Para hacerlo, se deben crear dos procesos, el primero
mostrará los números impares (1, 3, 5) y el segundo mostrará los números pares (2, 4,
6).
Lógicamente, para que el resultado sean los 6 números en orden, ambos
procesos deben estar sincronizados, es decir, cada proceso debe saber cuando tiene que
escribir el siguiente número y cuando tiene que esperar. Para ello utilice semáforos.
Antes de comenzar a resolver este ejercicio conteste a las siguientes preguntas.
¿Cuántos semáforos serán necesarios?. ¿Qué valores de inicio deben tener esos
semáforos?. ¿Cuál va a ser el valor máximo y mínimo que va a alcanzar cada
semáforo?. ¿Cuándo, y cuanto, hay que sumar o restar al semáforo?.
Una variante de este ejercicio con más dificultad es escribir un programa que
muestre en orden los números del 1 al 9. Los encargados de escribir los números van a
ser tres procesos. El primer proceso escribirá los números 1, 4 y 7. El segundo proceso
escribirá los números 2, 5 y 8. El tercer proceso escribirá los números 3, 6 y 9. Conteste
a las preguntas del párrafo anterior antes de resolver esta variante.
Como ejercicio de repaso, piense como resolver este ejercicio sin usar
semáforos, por ejemplo con tuberías o señales.

6.4. Las maletas.

57
 Después de años estudiando oposiciones y tras conseguir la certificación
correspondiente, un grupo de N_TECNICOS procesos ha conseguido plaza como
técnicos de descargas de maletas en un aeropuerto. El primer día el encargado les
explica como funciona el asunto:
“Los técnicos tenéis que coger las maletas de la bodega del avión, llevarlas hasta
el carro de las maletas, dejarla allí y volver a por más. La ley de seguridad laboral de la
descarga de maletas os obliga a que cada uno coja una sola maleta cada vez y a que, en
cualquier momento, sólo haya un único técnico tanto en la bodega del avión como en el
carro de las maletas”.
Vamos a un programa en C que simule el párrafo anterior. Pare ello empleamos
los siguientes consejos: Un técnico tarda un tiempo T_ACARREO desde que sale de la
bodega con una maleta hasta que llega al carro de las maletas. Puede considerar que
cada técnico va a sacar un número finito de maletas N_MALETAS de la bodega y
llevarla al carro.
Tenemos que definir las constantes N_TECNICOS, T_ACARREO y
N_MALETAS. Prueba con distintos valores para comprobar los resultados.
Recuerde que no es necesaria ninguna variable compartida.

6.5. La ley del silencio.

En este ejercicio tenemos N procesos estibadores que van colocando cajas en un

muelle. El muelle sólo tiene capacidad para C cajas, por lo que, cuando se alcanza ese
número, los estibadores se detienen, se activa un proceso carretilla que se lleva todas las
cajas. Cuando el proceso carretilla se ha llevado las cajas, los estibadores continúan con
su labor.
Pruebe con distintos valores de N y de C y observe como se desarrolla el proceso
de descarga de cajas.
Si ha escrito todo el código de este ejercicio en un único archivo, puede probar
la siguiente variante. Intente escriba el código del estibador y de la carretilla en archivos
de código diferentes. Escriba un tercer fichero de código que será el encargado de crear
y destruir los semáforos, crear los procesos estibadores y crear el proceso carretilla.

Ayuda:
En este ejercicio, a diferencia de los anteriores, necesitamos una variable que sea
común a varios procesos diferentes. Piense un momento el por qué la necesitamos antes
de continuar leyendo.
Efectivamente, es necesario saber cuál es el número de cajas que hay en el
muelle. Sin embargo, una variable compartida no es sencilla de hacer. Una solución,
que puede implementar como ejercicio, es utilizar un archivo. La alternativa que
proponemos en nuestra solución es utilizar memoria compartida, el cuál es otro
mecanismo IPC. Para simplificar el uso de memoria compartida e proporciona una
librería de funciones. Esta libería se propone como ejercicio y se explica con detalle en
el capítulo dedicado a memoria compartida.

6.6. Visita al museo.

El museo de la ciudad ha organizado una exposición dedicada a H. R. Giger para

conmemorar que en el 2005 se cumplen 25 años desde que obtuvo el Oscar. Un grupo

58
de VISITANTES procesos ha decidido visitarla, sin embargo la sala de espera del
museo solo tiene capacidad para ESPERA procesos, por lo que los procesos que no
puedan entrar deberán esperar en la calle hasta que haya sitio libre en la sala de espera.
Una vez en la sala de espera, un proceso podrá entrar en la sala de exposición si hay
sitio. La exposición puede ser visitada simultáneamente por EXPOSICION procesos.
Cada proceso estará VISITA segundos admirando la exposición antes de marcharse a
casa.
En este ejercicio vamos a escribir un programa en C que simule el párrafo
anterior. Por ejemplo, puede usar los siguientes valores para las constantes y
modificarlas para observar los resultados: VISITANTES=9, ESPERA=4,
EXPOSICION=4 y VISITA=2..
Observe que un proceso debe conseguir primero acceso a la sala de espera y después a
la sala de exposición. Cuando un proceso entra en la sala de exposición queda un hueco
libre para que pueda entrar en la sala de espera un proceso que está en la calle. Cuando
un proceso sale de la sala de exposición queda un hueco libre para que pueda entrar en
la sala de la exposición un proceso que está en la sala de espera. Además, todos los
procesos esperarán el tiempo que haga falta hasta visitar la exposición
En este ejercicio no es necesaria ninguna variable compartida.

6.7. El banco I.

En este ejercicio vamos a simular el funcionamiento de un banco utilizando

únicamente semáforos. El funcionamiento del banco se describe a continuación: Todos
los clientes que llegan al banco esperan en la misma cola hasta que una de las
ventanillas queda libre. Cuando una ventanilla queda libre, el primer cliente sale de
cola, es atendido en la ventanilla y se va.
Vamos a escribir un programa que simule el comportamiento anterior para
CLIENTES número de clientes, VENTANILLAS número de ventanillas y
T_ATENCIÓN tiempo en segundos que un cliente pasa en una ventanilla. Un posible
ejemplo de ejecución de la simulación se muestra a continuación. Observe que, cuando
un cliente sale de la cola, busca la ventanilla que ha quedado libre (el número al
comienzo de cada línea es cada uno de los clientes).
La mejor solución se implementa con operaciones IPC_NOWAIT, ojo, no en
todas las operaciones con semáforos, solo en algunas. Como parte del ejercicio, intente
identificar qué operaciones son IPC_NOWAIT y por qué otras alternativas de solución
(como ver el valor de un semáforo antes d eoperar con él) pueden presentar problemas.
Ventanillas: 3
Clientes: 7
Tiempo de atención a los clientes: 2 seg.
Sondeamos con operaciones NOWAIT
---------------------
0: solicitando acceso a las ventanillas.
0: buscando ventanilla libre.
0: atendido en ventanilla en 0.
1: solicitando acceso a las ventanillas.
1: buscando ventanilla libre.
1: ventanilla 0 ocupada.
1: atendido en ventanilla en 1.
2: solicitando acceso a las ventanillas.
2: buscando ventanilla libre.
2: ventanilla 0 ocupada.

59
 2: ventanilla 1 ocupada.
2: atendido en ventanilla en 2.
3: solicitando acceso a las ventanillas.
4: solicitando acceso a las ventanillas.
5: solicitando acceso a las ventanillas.
6: solicitando acceso a las ventanillas.
0: liberando ventanilla.
1: liberando ventanilla.
2: liberando ventanilla.
3: buscando ventanilla libre.
3: atendido en ventanilla en 0.
4: buscando ventanilla libre.
4: ventanilla 0 ocupada.
4: atendido en ventanilla en 1.
5: buscando ventanilla libre.
5: ventanilla 0 ocupada.
5: ventanilla 1 ocupada.
5: atendido en ventanilla en 2.
3: liberando ventanilla.
4: liberando ventanilla.
5: liberando ventanilla.
6: buscando ventanilla libre.
6: atendido en ventanilla en 0.
6: liberando ventanilla.
Fin.

Ningún cliente espera en una ventanilla concreta. Todos esperan en la misma

cola hasta que una ventanilla, da igual cual, quede libre.
No es necesario utilizar ninguna variable compartida en este ejercicio.
Varíe los valores de constantes CLIENTES, VENTANILLAS y T_ATENCION
y compuebe el comportamiento del banco y de los clientes.

6.3. Soluciones.

6.1. Gestor de semáforos por consola I

#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/types.h>

#define IPC_WAIT 0
#define CLAVE 42

union senum {
int val;
};

int main(int argc, char *argv[]) {

int numsem;

60
int semid;
int r;
// Indice del semŽáforo introducido por teclado
int semindx;
// Valor a sumar introducido por teclado
int valor;
// Operaciones con semŽáforos
struct sembuf op;
union senum extra;
int monitor = 0;

key_t clave;

// Comprobar lŽínea de comandos

numsem = 2;
if (argc != 2) {
printf("Uso: %s [<numero_semaforos>] \n", argv[0]);
printf("Uso: %s -m \n", argv[0]);
printf("Numero de semŽáforos no indicado. Valor por defecto 2.\n");
printf(" -m Monitoriza el grupo de semáforos cada 4 seg.\n\n\n");

} else {
if (strcmp("-m", argv[1]) !=0) {
numsem = atoi(argv[1]);
printf("Creando %i semaforos.\n", numsem);
}
else {
monitor = 1;
printf("Monitorizando.\n");
}
}

// Crear el grupo de semáforos

clave = ftok("./scon.c", CLAVE);
if (clave == -1) {
perror("Error calculando clave del grupo de semáforos.");
return -1;
}
// Si no existe lo crea, pero si ya existe utiliza el existente
semid = semget(clave, numsem, IPC_CREAT | S_IRUSR | S_IWUSR);
if (semid == -1) {
perror("Error creando grupo - ");
printf("Llave: %i\nSemaforos: %i\n", clave, numsem);
return -1;
}

// Comprobamos si hay que monitorizar

if (monitor == 1) {
int c;
int v;
while(1) {
sleep(4);
for (c = 0; c < numsem; c++) {
v = semctl(semid, c, GETVAL);
printf("Semaforo: %i Valor %i |", c, v);
}
printf("\n");
}
exit(0);
}

printf("Utilizando %i semáforos.\n", numsem);

printf("Semáforos incializados a 0.\n");

61
 semindx = 0;

// Realizar operaciones
do {
printf("[Indice semáforo - Negativo terminar] >> ");
scanf("%i", &semindx);
printf("[Valor a añadir - + sube / - baja] >> ");
scanf("%i", &valor);

if (semindx > -1) {

op.sem_num = semindx;
op.sem_op = valor;
op.sem_flg = IPC_WAIT;

r = semop(semid, &op, 1);

if ( r == -1)
perror("Error en la operaciŽón. ");
}
} while(semindx > -1);

printf("Destruyendo grupo de semáforos.\n");

r = semctl(semid, 0, IPC_RMID);
if (r == -1) {
perror("Error destruyedo grupo.");
} else {
printf("Grupo destruido.\n");
}

return 0;

6.2. Gestor de semáforos por consola II

#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/types.h>

#define CLAVE 42

union senum {
int val;
};

void inicializar(int);

int main(int argc, char *argv[]) {

int semid;
int r;

int monitor = 0;
int c;

key_t clave;

62
 // Comprobar lŽmnea de comandos
if (argc != 2) {
// Cambiar esto
printf("Uso: %s [-c -r -l -d] \n", argv[0]);
printf(" -c Crea el grupo de semaforos y lo inicializa \n", argv[0]);
printf(" -r Reinicia el grupo de semaforos. \n");
printf(" -l Muestra los valores de los semaforos \n");
printf(" -r Borra el grupo de semaforos. \n\n");
return -1;

// Crear la clave
clave = ftok("/etc/passwd", CLAVE);
if (clave == -1) {
perror("Error calculando clave del grupo de semaforos.");
return -1;
}

// Comprobamos el comando

if (strcmp("-c", argv[1]) ==0) {

semid = semget(clave, 3, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP);
if (semid == -1) {
perror("Error creando grupo - ");
return -1;
}

// Inicializamos los semaforos

inicializar(semid);

if (strcmp("-r", argv[1]) ==0) {

semid = semget(clave, 3, 0);
if (semid == -1) {
perror("Error recuperando grupo - ");
return -1;
}
inicializar(semid);
}

if (strcmp("-l", argv[1]) ==0) {

semid = semget(clave, 3, 0);
if (semid == -1) {
perror("Error listando grupo - ");
return -1;
}

// Mostrar los valores

for (c = 0; c < 3; c++) {
r = semctl(semid, c, GETVAL);
printf("Semaforo: %i Valor %i |", c, r);
}
printf("\n");
}

if (strcmp("-d", argv[1]) ==0) {

printf("Destruyendo grupo de semaforos.\n");
semid = semget(clave, 3, 0);
if (semid == -1) {
perror("Error recuperando el grupo para su destruccion. ");
return -1;
}

63
 r = semctl(semid, 0, IPC_RMID);
if (r == -1) {
perror("Error destruyedo grupo.");
} else {
printf("Grupo destruido.\n");
}
}

return 0;

void inicializar(int id) {

union senum extra;
int r;

extra.val = 3;
r = semctl(id, 1, SETVAL, extra);
if (r == -1)
perror("Error inicializando semaforo.");

6.3. Te toca / me toca.

union senum {
int val;
};

int main() {

pid_t pid;
int c, r;
int num;
int sem_prod, sem_cons;
struct sembuf arriba = {0,1,0};
struct sembuf abajo = {0,-1,0};
union senum arg;

sem_prod = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | S_IRUSR |

S_IWUSR);
sem_cons = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | S_IRUSR |
S_IWUSR);
if ((sem_prod == -1) || (sem_cons==-1)) {
perror("Error creando semáforos");
return -1;
}

arg.val = 1;
r = semctl(sem_prod, 0, SETVAL, arg);
if (r == -1) {
perror("Error incializando el semáforo del productor - ");
//Borrar los semáforos
return -1;
}

for (c = 0; c < 2; c++) {

pid = fork();
if (pid == -1) {
perror("Error creando procesos - ");
// Borrar semáforos.
return -1;

64
 }

if (pid == 0) {

// Impares
if (c==0) {
for (num = 1; num < 6; num+= 2) {
// Mi turno de producir
r = semop(sem_prod, &abajo, 1);
if (r == -1) {
perror("Error bajando el semáforo del productor - ");
// Eliminar semáforos
return -1;
}

printf("Numero: %i\n", num);

// El turno de consumir
r = semop(sem_cons, &arriba, 1);
if (r == -1) {
perror("Error subiendo el semáforo del consumidor - ");
// Eso
return -1;
}
}
exit(0);
}

// Pares
if (c==1) {
for (num = 2; num < 7; num+=) {
// Voy a consumir 5 números
r = semop(sem_cons, &abajo, 1);
if (r == -1) {
perror("Error bajando semáforo del consumidor - ");
return -1;
}

printf("Valor consumido: %i\n", num );

// Hora de producir
r = semop(sem_prod, &arriba, 1);
if (r == -1) {
perror("Error subiendo semáforo del productos - ");
return -1;
}
}
exit(0);
}

}
}

pid = wait(&r);

while ( (pid != -1) ||

( (pid == -1) && (errno == EINTR)) )
pid = wait(&r);

r = semctl(sem_prod, 0, IPC_RMID);
if (r==-1) {
perror("Error eliminando semáforo productor.");
}
r = semctl(sem_cons, 0, IPC_RMID);
if (r == -1) {
perror("Error eliminando semáforo consumidor. ");
}

65
 printf("Fin.\n");
return 0;
}

6.4. Las maletas.

#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/types.h>

#define N_MALETAS 4
#define N_TECNICOS 3
#define T_ACARREO 1
#define SEM_BODEGA 0
#define SEM_CARRO 1

union senum {
int val;
};

int main() {

int sem;
int r;
int c, quiensoy;
pid_t pid;
union senum arg;
struct sembuf arriba = {0, 1, 0};
struct sembuf abajo = {0, -1, 0};

sem = semget(IPC_PRIVATE, 2, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);

if (sem == -1) {
perror("Error creando semáforos.");
return -1;
}

arg.val = 1;
r = semctl(sem, SEM_BODEGA, SETVAL, arg);
if (r == -1)
perror("Error inicializando semáforo de la bodega.");

arg.val = 1;
r = semctl(sem, SEM_CARRO, SETVAL, arg);
if (r == -1)
perror("Error inicializando semáforo del carro.");

printf("Técnicos: %i / Maletas técnico: %i\n", N_TECNICOS, N_MALETAS);

for (c = 0; c <N_TECNICOS; c++) {

pid = fork();
if (pid == -1) {
perror("Error creando procesos.");
return -1;
}

if (pid == 0) {
quiensoy = c;

66
 for (c = 0; c < N_MALETAS; c++) {
printf("%i: Accediendo a bodega por maleta %i.\n", quiensoy, c);

abajo.sem_num = SEM_BODEGA;
r = semop(sem, &abajo, 1);
if (r == -1)
perror("Error bajando semáforo de la bodega.");

printf("%i: Coge la maleta %i.\n", quiensoy, c);

arriba.sem_num = SEM_BODEGA;
r = semop(sem, &arriba, 1);
if (r == -1)
perror("Error subiendo semáforo de la bodega.");

printf("%i: Sale de la bodega con la maleta %i.\n", quiensoy, c);

sleep(T_ACARREO);

printf("%i: Accediendo al carro con la maleta %i.\n", quiensoy, c);

abajo.sem_num = SEM_CARRO;
r = semop(sem, &abajo, 1);
if (r == -1)
perror("Error bajando semáforo del carro.");

printf("%i: Deja la maleta %i en el carro.\n", quiensoy, c);

arriba.sem_num = SEM_CARRO;
r = semop(sem, &arriba, 1);
if (r == -1)
perror("Error subiendo semáforo del carro.");

if (c < (N_MALETAS-1))
printf("%i: Va a por otra maleta.\n", quiensoy);
}
exit(0);
}

}
pid = wait(&r);
while ( (pid !=-1) ||
(pid == -1 && errno == EINTR) )
pid = wait(&r);

r = semctl(sem, 0, IPC_RMID);
if (r == -1)
perror("Error eliminando semáforos.");

printf("Fin.\n");
return 1;
}

6.5. La ley del silencio.

#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>

67
#include <sys/types.h>

#include "sv.h"

#define MAX_CAJAS 30
#define PROD 8

union senum {
int val;
};

int main() {

pid_t pid;
int c, r;
int num;
int sem_prod, sem_cons, sem_exc;
struct sembuf arriba = {0,1,0};
struct sembuf abajo = {0,-1,0};
struct sembuf espera_cero = {0, 0, 0};
struct sembuf abajo_prod = {0, 0, 0};
struct sembuf arriba_prod= {0, 15, 0};
union senum arg;

sv_init();
sem_prod=semget(IPC_PRIVATE,1,IPC_CREAT| IPC_EXCL | S_IRUSR | S_IWUSR);
sem_cons=semget(IPC_PRIVATE,1,IPC_CREAT| IPC_EXCL | S_IRUSR | S_IWUSR);
sem_exc=semget(IPC_PRIVATE,1,IPC_CREAT| IPC_EXCL | S_IRUSR | S_IWUSR);

if ((sem_prod==-1) || (sem_cons==-1) || (sem_exc == -1)) {

perror("Error creando semáforos");
sv_finish();
return -1;
}

arg.val = 0;
r = semctl(sem_cons, 0, SETVAL, arg);
if (r == -1) {
perror("Error incializando el semáforo del consumidor ");
//Borrar los semáforos
sv_finish();
return -1;
}

arg.val = 1;
r = semctl(sem_exc, 0, SETVAL, arg);
if (r == -1) {
perror("Error inicializando el semáfoto de exclusión mútua");
// Borrar lo semáforos
sv_finish();
return -1;
}

arg.val = 15;
r = semctl(sem_prod, 0, SETVAL, arg);
if (r == -1)
perror("Error inicializando el semáfoto de los productores.");

for (c = 0; c < 4; c++) {

pid = fork();
if (pid == -1) {
perror("Error creando procesos - ");
// Borrar semáforos.
return -1;
}

if (pid == 0) {

68
// Productores
if (c!=0) {
//if (c == 1) sleep(1);
for (num = 0; num < MAX_CAJAS; num++) {

// Mi turno de producir
r = semop(sem_prod, &abajo, 1);
if (r == -1)
perror("Error bajando sem. productor.");

// Acceso al muelle - Exclusión mútua

r = semop(sem_exc, &abajo, 1);
if (r == -1) {
perror("Error bajando exclusión mútua en productor");
}

sv_inc(1);
printf("Productor: %i. Cajas: %i de %i\n", c, sv_val(), num+1);

if (sv_val() == 15) {
printf("Productor: %i. llamando a consumidor.\n", c);
if (semctl(sem_prod, 0, GETVAL) != 0) {
printf("Productor: %i no es el último !!!. \n", c);
}

r = semop(sem_cons, &arriba, 1);

if (r == -1) {
perror("Error subiendo exclusión mútua en productor");
// Eso
return -1;
}
}

r = semop(sem_exc, &arriba, 1);

if (r == -1) {
perror("Error subiendo exclusión mútua en productor");
// Eso
return -1;
}

} // for

exit(0);
}

// Consumidor
if (c==0) {
for (num = 0; num < (MAX_CAJAS / 15)*3; num++) {

// Espera a que no haya cajas

r = semop(sem_cons, &abajo, 1);
if (r == -1) {
perror("Error bajando semáforo del consumidor - ");
return -1;
}

printf("Llamada %i/ %i Límite \n",num,((MAX_CAJAS/15)*3)-1);

r = semop(sem_exc, &abajo, 1);
if (r == -1) {
perror("Error bajando sem. de exclusión mútua en consumidor.");
}

printf("Acceso al muelle. Retirándo 15 cajas.\n");

sv_inc(-15);
printf("Cajas restantes: %i\n", sv_val());

69
 r = semop(sem_prod, &arriba_prod, 1);
if (r == -1)
perror("Error subiendo sem. productores.");

// Fin de la esclusión mútua.

r = semop(sem_exc, &arriba, 1);
if (r == -1) {
perror("Error subiendo excelusión mútua en consumidor");
return -1;
}

}
exit(0);
}

}
}

pid = wait(&r);

while ( (pid != -1) ||

( (pid == -1) && (errno == EINTR)) )
pid = wait(&r);

r = semctl(sem_exc, 0, IPC_RMID);
if (r==-1) {
perror("Error eliminando semáforo exclusion mutua.");
}

r = semctl(sem_cons, 0, IPC_RMID);
if (r == -1) {
perror("Error eliminando semáforo consumidor. ");
}

r = semctl(sem_prod, 0, IPC_RMID);

sv_finish();

printf("Fin.\n");
return 0;
}

6.6. Visita al museo.

#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/types.h>

#define VISITANTES 9
#define ESPERA 4
#define EXPOSICION 2
#define VISITA 2

int quiensoy;

union semun {

70
 int val;
};

int main() {

pid_t pid;
int sem_espera, sem_exposicion;
int r;
int i;
union semun arg;
struct sembuf arriba = {0, 1, 0};
struct sembuf abajo = {0, -1, 0};

sem_espera= semget(IPC_PRIVATE, 1, IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);

if (sem_espera == -1) {
perror("Imposible crear semaforo de la sala de espera. ");
return -1;
}

sem_exposicion=semget(IPC_PRIVATE,1,IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);
if (sem_exposicion == -1) {
perror("Imposible crear semaforo de la sala de exposicion. ");
return -1;
}

arg.val = ESPERA;
r = semctl(sem_espera, 0, SETVAL, arg);
if (r == -1) {
perror("Error inicializando semaforo de la sala de espera.");
return -1;
}

arg.val = EXPOSICION;
r = semctl(sem_exposicion, 0, SETVAL, arg);
if (r == -1) {
perror("Error inicializando semaforo de la sala de exposicion.");
return -1;
}

for (i = 0; i < VISITANTES; i++) {

pid = fork();
if (pid == -1) {
perror("Error creando hijos.");
return -1;
}

if (pid == 0) {
quiensoy = i;

printf("Proceso %i poniendose en la cola.\n", quiensoy);

r = semop(sem_espera, &abajo, 1);

if (r==-1) {
perror("Error bajando semaforo");
}

printf("Proceso %i entra en la sala de espera.\n", quiensoy);

sleep(1);

r = semop(sem_exposicion, &abajo, 1);

if (r==-1) {
perror("Error bajando semaforo");
}

r= semop(sem_espera, &arriba, 1);

71
 if (r == -1) {
perror("Error subiendo semaforo de la sala de espera.");
}

printf("Proceso %i entra en la sala de exposicion.\n", quiensoy);

sleep(2);

r= semop(sem_exposicion, &arriba, 1);

if (r == -1) {
perror("Error subiendo semaforo de la sala de espera.");
}

printf("Proceso %i termina de ver la exposicion.\n", quiensoy);

exit(0);
}
} // For

pid = wait(NULL);
while ( (pid != -1) ||
( (pid == -1) && (errno ==EINTR)))
pid = wait(NULL);

r = semctl(sem_espera, 0, IPC_RMID);
if ( r==-1) {
perror("Error al eliminar el semaforo de la sala de espera.");
}

r = semctl(sem_exposicion, 0, IPC_RMID);
if ( r==-1) {
perror("Error al eliminar el semaforo de la sala de exposicion.");
}

printf("Fin\n");

return 0;
}

6.7. El banco I.

La alternativa de comprobar el valor del semáforo antes de bajarlo no es correcta.

Supongamos que dos ventanillas, la 1 y la 2, están libres y dos procesos salen de la cola
al mismo tiempo. Si ambos procesos consultan a la vez el valor de la ventanilla 1,
ambos procesos ven que está libre. Si ambos procesos bajan a la vez en el semáforo de
la ventanilla 1, uno accede a ella y el otro queda esperando en la ventanilla, lo cuál
está mal. Esto no pasa con nuestras amigas, las operaciones IPC_NOWAIT.

#include <errno.h>
#include <unistd.h>
#include <wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/types.h>

#define VENTANILLAS 3
#define CLIENTES 7
#define T_ATENCION 2

union senum { int val; };

72
int main() {

int r, i;
int id;
pid_t pid;
int sem_pool, sem_prts;

printf("Ventanillas: %i\n", VENTANILLAS);

printf("Clientes: %i\n", CLIENTES);
printf("Tiempo de atención a los clientes: %i seg.\n", T_ATENCION);
printf("Sondeamos con operaciones NOWAIT\n");
printf("---------------------\n");

union senum arg;

struct sembuf arriba = {0, 1, 0};
struct sembuf abajo = {0, -1, 0};
struct sembuf abajo_nw = {0,-1, IPC_NOWAIT};

int semflgs = IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR;

sem_pool = semget(IPC_PRIVATE, 1, semflgs);

if (sem_pool == -1) {
perror("Error creando semáforo de la cola de espera.");
return -1;
}

sem_prts = semget(IPC_PRIVATE, VENTANILLAS, semflgs);

if (sem_prts == -1)
perror("Error creando semáforos de las ventanillas.");

arg.val = VENTANILLAS;
r = semctl(sem_pool, 0, SETVAL, arg);
if (r == -1)
perror("Error inicializando semáforo de la cola.");

arg.val = 1;
for (i =0 ; i < VENTANILLAS; i++) {
r = semctl(sem_prts, i, SETVAL, arg);
if (r == -1)
perror("Error inicializando semáforos de la simpresoras.");
}

for ( i= 0; i < CLIENTES; i++) {

pid = fork();
if (pid == -1) {
perror("Error creando proceso cliente.");
}

if (pid == 0) {
id = i;
printf("%i: solicitando acceso a las ventanillas.\n", id);

r = semop(sem_pool, &abajo, 1);

if (r == -1)
perror("Error bajando semáforo de la cola de ventanillas.");

printf("%i: buscando ventanilla libre.\n", id);

for(i = 0; i < VENTANILLAS; i++) {

abajo_nw.sem_num = i;
r = semop(sem_prts, &abajo_nw, 1);
if (r == -1)
printf("%i: ventanilla %i ocupada.\n", id, i);
else {
printf("%i: atendiendo en ventanilla en %i.\n", id, i);
sleep(T_ATENCION);
arriba.sem_num = i;
r = semop(sem_prts,&arriba, 1);

73
 if (r == -1) {
perror("Error subiendo semáforo de cola.");
}
arriba.sem_num =0;
break;
}
}

printf("%i: liberando ventanilla.\n", id);

r = semop(sem_pool, &arriba, 1);

exit(0);
}

} // For

pid = wait(&r);
while ( (pid !=-1) ||
(pid == -1 && errno ==EINTR) )
pid = wait(&r);

semctl(sem_pool, 0, IPC_RMID);
semctl(sem_prts, 0, IPC_RMID);

printf("Fin.\n");
}

74
Apéndices.

75
Apéndice A. Manejo de GDB

A lo largo de este apéndice, usaremos como ejemplo un sencillo programa cuyo

código se muestra a continuación:

#include <stdio.h>
int main() {
int v = 0;
int i;
for (i = 0; i < 5; i++) {
v += i;
}
printf("Resultado: %i\n", v);
return 0;
}

76
 Lo primero que hemos de hacer es compilar dicho programa con la opción "-g"
para que se incluya la información necesaria para la depuración. Si el programa está
guardado en un archivo

$ gcc -g -o test test.c

Una vez compilado, podemos comenzar la depuración invocando a gbd con el

nombre del archivo compilado.
$ gdb test

GNU gdb 5.3-debian

Copyright 2002 Free Software Foundation, Inc.

GDB is free software, covered by the GNU General Public

License, and you are welcome to change it and/or distribute
copies of it under certain conditions.

Type "show copying" to see the conditions.There is

absolutely no warranty for GDB. Type "show warranty" for
details.

This GDB was configured as "i386-linux"...

(gdb)

La línea "(gdb)" nos indica que el depurador está listo para empezar a procesar
nuestras órdenes. El primer comando que veremos es (l)ist. Este comando muestra el
código fuente del programa que estoy depurando.
(gdb) l

1 #include <stdio.h>

3 int main() {

5 int v = 0;

6 int i;

8 for (i = 0; i < 5; i++) {

9 v += i;

10 }

(gdb)

77
 Para ejecutar el programa, utilizamos el comando (r)un. Como aún no hemos
puesto ningún punto de ruptura, el programa se ejecutará entero.
(gdb) r

Starting program: /ramdisk/home/knoppix/test

Resultado: 10

Program exited normally.

(gdb)

Vamos a colocar ahora un punto de ruptura. Como su nombre indica, un punto

de ruptura es un punto donde la ejecución de nuestro programa se detiene. Para colocar
un punto de ruptura utilizamos el comando (b)reakpoint seguido de la línea donde
queremos ponerlo.
(gdb) b 9

Breakpoint 1 at 0x804834e: file test.c, line 9.

(gdb)

Ya tenemos un punto de ruptura en la línea 9. Si ahora ejecutamos el programa

se detendrá cuando llegue a esa línea.
(gdb) r

Starting program: /ramdisk/home/knoppix/test

Breakpoint 1, main () at test.c:9

9 v += i;

(gdb)

Para continuar la ejecución del programa utilizamos el comando (c)ontinue. En

nuestro ejemplo, el programa se volverá a detener en el mismo punto de ruptura.
(gdb) c

Continuing.

Breakpoint 1, main () at test.c:9

9 v += i;

(gdb) c

Continuing.

Breakpoint 1, main () at test.c:9

9 v += i;

78
 (gdb) c

Continuing.

Breakpoint 1, main () at test.c:9

9 v += i;

(gdb) c

Continuing.

Breakpoint 1, main () at test.c:9

9 v += i;

(gdb) c

Continuing.

Resultado: 10

Program exited normally.

(gdb)

Puesto que tenemos un punto de ruptura en el bucle y este da 5 vueltas, hemos

tenido que continuar 5 veces para ejecutar el programa completo. También es posible
ejecutar el programa línea a línea con el comando (n)ext.
(gdb) r

Starting program: /ramdisk/home/knoppix/test

Breakpoint 2, main () at test.c:9

9 v += i;

(gdb) n

8 for (i = 0; i < 5; i++) {

(gdb) n

Breakpoint 2, main () at test.c:9

9 v += i;

(gdb)

En cualquier momento podemos ver el valor de una variable con el comando

(p)rint seguido del nombre de la variable.
(gdb) p v

$1 = 1

79
 (gdb) c

Continuing.

Breakpoint 2, main () at test.c:9

9 v += i;

(gdb) c

Continuing.

Breakpoint 2, main () at test.c:9

9 v += i;

(gdb) p v

$2 = 6

(gdb)

Para eliminar un punto de ruptura utilizamos el comando delete y el número del

punto a eliminar. En nuestro ejemplo
(gdb) delete 1

(gdb)

Por último, para salir del depurador utilizamos el comando (q)uit.

Hay mucha más información disponible tanto en la página del manual como en
los archivos info:
$ man gdb

$ info gdb

También puede utilizarse interfaces gráficos para trabajar con GB de manera

más cómoda. Uno de esos interfaces es DDD y puede descargarse en
http://sourceforge.net/projects/ddd/

80
Apéndice B. Referencia rápida de Emacs.
^ significa Ctrl.

Crear / cargar fichero: ^x^f

Salvar fichero (buffer): ^x^s
Salvar como: ^x^w
Salir: ^x^c
Insertar fichero: ^x i

Matar buffer: ^x k

Deshacer: ^_ o ^x u
Borrar línea: ^k
Ir a fin de línea: ^e
Selecionar todo: ^x h
Intercambia líneas: ^x^t

Partir pantalla horizontal: ^x 2

Partir pantalla vertical: ^x 3
Cierra la ventana: ^x 0
Cierra las demás ventanas: ^x 1
Cambiar de ventana: ^x o

81