UNIVERSIDAD TECNOLGICA

NACIONAL
FACULTAD REGIONAL SANTA FE




DISEO E IMPLEMENTACIN DE SISTEMAS OPERATIVOS



Implementacin de una llamada al Sistema en MINIX
V 3.0

























SANTA FE 2008



IMPLEMENTACIN DE UNA LLAMADA AL SISTEMA EN MINIX..................................................... 1
INTRODUCCIN.............................................................................................................................................. 3
FLUJO DE INFORMACIN EN LA NUEVA LLAMADA AL SISTEMA................................................. 4
COMUNICACIN ENTRE EL PROCESO DE USUARIO Y EL PM........................................................ 5
CONSTRUCCIN DE LA FUNCIN DE BIBLIOTECA LIBC.A:.................................................................................. 5
CONSTRUCCIN DEL PROGRAMA DE PRUEBA.................................................................................................... 6
MODIFICACIN DEL PROCESO SERVIDOR .......................................................................................................... 7
COMUNICACIN PM SYSTASK ............................................................................................................... 9
CONSTRUCCIN DE LA FUNCIN DE LIBRERA .................................................................................................. 9
MODIFICACIN DE LA SYSTASK.................................................................................................................. 10
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
3 de 10

Introduccin
Minix es un Sistema Operativo programado en capas. Las distinguibles son cuatro y se
muestran en la figura siguiente


El microkernel maneja las comunicaciones inter procesos, realiza planificacin de los
mismos, maneja interrupciones y provee algunos mecanismos bsicos para la administracin
de procesos. El manejo de sistemas de archivo, funciones de red, administracin de procesos
y dems servicios a usuarios, son provistos por servidores especializados fuera del
microkernel. De hecho:

El kernel de MINIX tiene cerca de 4000 lneas de cdigo ejecutable, no los millones
encontrados en Windows, Linux, MAC OSX, o FreeBSD. El resto del sistema, incluyendo
todos los manejadores de dispositivos (excepto el driver de reloj) es una coleccin de
procesos de usuario pequeos y modulares, cada uno de los cuales es altamente restringido
en cuanto a lo que puede hacer y con qu otros procesos puede comunicarse
(Andrew S. Tanenbaum Operating Systems Design and Implementation, Third Edition)

Una de las funciones principales del microkernel es proveer un conjunto de funciones
(llamadas al kernel o, en ingles, kernel calls) a los manejadores de dispositivos y a los
servidores que estn en las capas inmediatamente superiores. La encargada de atender y
realizar esas llamadas es la Tarea de Sistema o System Task
Desde el punto de vista del kernel, todos los procesos de las capas superiores son tratados
casi de la misma forma: todos son planificados por el kernel, estn limitados a usar
instrucciones en modo usuario, ninguno puede acceder directamente a puertos de
entrada/salida y ninguno puede acceder a direcciones de memoria fuera del espacio asignado
a si mismo.
La diferencia entre los procesos que pertenecen a las distintas capas radica, principalmente,
en la posibilidad de realizar llamadas al kernel siendo los de la capa 2 los ms privilegiados,
seguidos en orden decreciente de privilegios por la capa 3 y 4. Por ejemplo, los procesos de
capa 2 (device drivers) tienen permitido requerirle a la System Task que lea y escriba datos
en los puertos de Entrada/Salida en su nombre o que copie datos en el espacio de direcciones
de otro proceso.
La capa 3 est compuesta por los Procesos Servidores. Dos de ellos, el Administrador de
Proceso (PM) y el Administrador de Sistemas de archivos (FS) son los esenciales.
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
4 de 10
Por ltimo, en la capa 4 se encuentran los procesos de usuario (editores, compiladores, por
ejemplo)
TIP: Es importante distinguir entre llamadas al kernel (Kernel Calls) y llamadas al Sistema
POSIX (POSIX System calls). Las primeras son llamadas de bajo nivel provistas por la
System Task para permitirle hacer su trabajo a los Manejadores de dispositivos y a los
Proceso Servidores. En contraste las Llamadas al Sistema POSIX son llamadas de Alto
Nivel definidas por el estndar POSIX y estn disponible para los procesos de usuarios en
la capa 4 (Andrew S. Tanenbaum Operating Systems Design and Implementation, Third Edition)

Supondremos la implementacin de la llamada al sistema para recuperar el valor de una
variable del kernel tal como un contador de mensajes, un contador de ticks, un campo de la
tabla de procesos administrada por el kernel, etc.
Tambin supondremos que la llamada ser atendida por el Process Manager (el Memory
Manager de MINIX 2) y resuelta por la SYSTASK que tiene acceso a la memoria y
variables del kernel
En nuestra descripcin utilizaremos la llamada al sistema newcall().

Flujo de informacin en la nueva llamada al Sistema
Programa de Usuario
Libc

PM
Libsys

Systask
En MINIX la comunicacin entre procesos se lleva a cabo utilizando Envo de Mensajes con
mtodo de Rendezvouz. Adems, cada tarea, manejador de dispositivo o proceso servidor
tiene permitido intercambiar mensajes con un grupo acotado de otros procesos. Los
mensajes pueden fluir entre procesos de la misma capa o entre procesos de capas
adyacentes. Los procesos de la capa 4 no pueden enviar mensajes a otros procesos de la capa
4 solo a los de capa3.
Este contexto da lugar a la figura precedente donde las flechas indican mensajes
intercambiados entre las distintas capas de MINIX. La idea, muy simplificada, es la
siguiente:
1. El proceso de usuario hace una llama al sistema. Desde su punto de vista, no es ms que
una funcin de librera. En este ejemplo, la funcin forma parte de la libc.a
2. La funcin de librera arma un mensaje a con la peticin y lo enva a uno de los procesos
servidores quedando a la espera de una respuesta. En el ejemplo, se utiliz el Process
Manager como destinatario del mensaje.
3. El proceso servidor, recibe el mensaje y, dependiendo del tipo de mensaje, ejecutar
operaciones predefinidas. Si la llamada al sistema puede ser resuelta en el mbito del
proceso servidor, se genera un mensaje de respuesta d y se enva al proceso que realiz
la peticin. Si la llamada no puede ser resuelta por el proceso servidor, se generar un
a)
d)
b) c)
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
5 de 10
mensaje y se enviar al manejador de dispositivos correspondiente o, en su defecto a la
SYSTASK. En el ejemplo, la peticin es realizada a la SYSTASK va el mensaje b.
4. La SYSTASK realiza las acciones que correspondan ante un mensaje del tipo b y
genera, eventualmente, un mensaje c con la respuesta a la peticin. La respuesta, no est
dems decirlo, es enviada al proceso servidor que emiti el mensaje b; no al proceso de
usuario.
5. El proceso servidor (el Process Manager, en el ejemplo) toma el mensaje c, lo procesa y
enva la respuesta al proceso de usuario va el mensaje d
6. La funcin de librera desempaqueta el contenido del mensaje y devuelve los resultados,
posiblemente va parmetros pasados por referencia, al proceso de usuario
A continuacin, se presentan los pasos necesarios para lograr la comunicacin de las
distintas partes involucradas.
Comunicacin entre el proceso de usuario y el PM
La comunicacin entre el proceso de usuario y el Process Manager involucra dos tareas:
- La creacin, por parte del proceso de usuario, de un mensaje y el envo del mismo al
proceso servidor
- La creacin de un handler, en el proceso servidor, que realice las acciones
pertinentes cuando llega un mensaje de ese tipo
En cuanto a la generacin del mensaje por parte del proceso de usuario, existen dos
alternativas:
1. Utilizar la llamada la sistema _syscall, que realiza el envo de un mensaje destinado a
otro proceso y se bloquea hasta recibir una respuesta. _syscall toma tres parmetros:
PUBLIC int _syscall(int who, int syscallnr, register message *msgptr);
1.1. who: es el destinatario del mensaje
1.2. syscallnr: es el nmero de la llamada al sistema
1.3. msgptr: es un puntero al mensaje a enviar.
Entonces podramos, por ejemplo llamarla de la siguiente forma:
message m;
_syscall(PM,70,&m);
Donde PM es el nmero de proceso asignado al PM, 70 es el nmero de llamada al
sistema y m es el mensaje a enviar
2. Ocultar todo el manejo de envo y recepcin de mensajes en una funcin de librera. De
esta forma, abstraemos a los procesos de usuario del mecanismo de comunicacin inter
procesos. Esta ser la alternativa a seguir en el resto del documento.

Construccin de la funcin de biblioteca libc.a:
En /usr/src/lib/posix creamos el archivo _newcall.c. En el, codificaremos la funcin
newcall(argumentos), encargada de armar un mensaje y enviarlo al proceso servidor. Si el
proceso de usuario necesitara enviar informacin al proceso servidor, debera pasarla a
newcall() va argumentos. De la misma forma, si el proceso servidor devuelve un mensaje
con informacin, newcall() debera desempaquetar el mensaje y enviar la informacin al
proceso de usuario va argumentos. Por ejemplo:

#include <lib.h>
#include <unistd.h>
PUBLIC long newcall(int numero, int * numero2)
{
message m;
int rcode;
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
6 de 10
/* setear los campos del mensaje a enviar */
m.m1_i1 = numero;
/* La forma de pasar un mensaje a MM es a travs de:
_syscall(MM,NEWCALL,&m);
El mensaje de respuesta queda en m.
*/
rcode=_syscall(MM,NEWCALL,&m);
/* retornar la informacin contenida en el mensaje va parametros*/
/* *numero2=m.m1_i2; */
*numero2 = 1000;
return(rcode);
}
Notar que la funcin del ejemplo no hace mucho. Solo carga el campo m1_i1 del mensaje m
que se enviar al PM y, luego de la llamada a syscall, pone el valor 1000 en la direccin de
memoria suministrada como segundo parmetro. Por ltimo, retorna el valor devuelto como
resultado de la llamada a _syscall.
Para que esta funcin forme parte de la librera, se debe editar el archivo. Makefile.in en el
mismo directorio y agregar el nombre del nuevo archivo a compilar como parte de la libc
..
priority.c \
_newcall.c \
usleep.c"
..
ejecutar, en ese directorio:
make Makefile
Esto generar un nuevo Makefile que incluye las reglas para el nuevo archivo

Como se ve, en la llamada a _syscall, hemos usado la macro NEWCALL en lugar de utilizar
el nmero de llamada al sistema. Entonces, en /usr/src/include/minix editaremos callnr.h
para agregar dicha macro:
#define NEWCALL 70 /* El 70 esta libre en la seccin posix*/

Luego ir a /usr/src/ y ejecutar:
make libraries
Esto compilar e instalar la nueva librera POSIX.
NOTA: Puede ser necesario instalar los nuevos archivos de cabecera en /usr/include
va:
cd /usr/src
make includes
Construccin del programa de prueba
En este punto, solo a los efectos de prueba, podemos construir un programa llamado, por
ejemplo, consumidor.c con el siguiente cdigo:
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
int rcode, numero2, numero;
rcode = newcall(4,&numero2);
printf("\nResultado newcall: %d , valor 2do argumento: %d \n",
rcode,numero2);
return(0);
}
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
7 de 10
Al compilar este programa, va
cc consumidor.c o consumidor.o
veremos un aviso parecido a:
"consumidor.c", line 13: (warning) implicit declaration of function
newcall
Eso se debe a que newcall no est prototipada. Para evitar ese aviso, editar,
/usr/src/include/unistd.h y agregar el prototipo de la funcin:
_PROTOTYPE( long newcall, (int numero1, int * numero2) );

Al ejecutar consumidor.o, se llama, entonces a la funcin de librera newcall() que enva, a
su vez, un mensaje al Process Manager. Como el Process Manager no sabe qu hacer con un
mensaje de ese tipo, el resultado de la ejecucin ser
Resultado newcall: -1 , valor 2do argumento: 1000
Pues la llamada a _syscall() retornar -1 (error). El 1000 es cargado por la funcin de
librera directamente. Lo siguiente, entonces, es aportar la funcionalidad requerida al PM
Modificacin del proceso servidor
El programa principal del Process Manager (/usr/src/servers/pm/main.c) es un ciclo
infinito en el que el servidor queda a la espera de mensajes, cuando recibe un mensaje lo
atiende y luego, eventualmente, enva los resultados a quien realiz la peticin. La forma de
realizar la accin relacionada a cada tipo de mensaje es:
/* Else, if the system call number is valid, perform the call. */
else if ((unsigned) call_nr >= NCALLS) {
result = ENOSYS;
} else {
result = (*call_vec[call_nr])();
}
Como se ve, la funcin que se ejecuta es aquella que se encuentra en la posicin call_nr del
vector call_vec. La variable call_nr, en este contexto, contiene el nmero de System Call
requerida (ver get_work() en main.c).
call_vec es, entonces, un vector de punteros a funcin que contiene en la posicin n-sima un
puntero a la funcin que debe ejecutarse para atender la System Call nmero n y se
encuentra definido en /usr/src/servers/pm/table.c. Por lo tanto, para que el Process
Manager ejecute determinada funcin ante la llegada de un mensaje requiriendo la System
Call 70 hay que cambiar:
_PROTOTYPE( int (*call_vec[NCALLS]), (void) ) = {
...
no_sys, /* 70 = unused */
por esto:
_PROTOTYPE( int (*call_vec[NCALLS]), (void) ) = {
. . .
do_newcall, /* 70 = newcall */
mediante este cambio, se indica al Process Manager que ejecute la funcin do_newcall
Para programar do_newcall debe, en primera instancia, modificarse
/usr/src/servers/pm/proto.h para agregar el prototipo de la funcin:
_PROTOTYPE( int do_newcall, (void) );
luego, para no generar otro archivo, podemos escribir en la funcin do_newcall() en
/usr/src/servers/pm/misc.c
Debe tenerse en cuenta que:
El mensaje de entrada est en m_in
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
8 de 10
El mensaje de respuesta est en mp->mp_reply (mp es un puntero a la posicin de la
tabla de procesos ocupada por el proceso que origin la llamada. (ver setreply() en
main.c )
Si la system call puede ser atendida con los recursos del proceso servidor,
do_newcall debe ser dotada de toda la funcionalidad necesaria y completar los
campos correspondientes del mensaje que se devolver al proceso que realiz la
llamada.
Si debe requerirse algo a la SYSTASK, debe armarse un nuevo mensaje y envirselo
va sys_newcall
/usr/include/minix/ipc.h define los tipos relativos a mensajes.

/*===========================================================*
* do_newcall *
*===========================================================*/
PUBLIC int do_newcall()
{
mp->mp_reply.m2_l1 = m_in.m1_i1 * 2;
return (0);
}
Una vez programada la funcin do_newcall es conveniente, a los efectos de simplificar la
depuracin probar lo hasta ahora realizado. Notar que, en el ejemplo, do_newcall no hace
prcticamente nada. Solo retorna en un campo del mensaje de salida, el doble de lo que se le
informa en el campo m1_i1 del mensaje de entrada (m_in). Una ligera modificacin a la
funcin newcall() de /usr/src/lib/posix/_newcall.c permitir probar el circuito completo:
#include <lib.h>
#include <unistd.h>
PUBLIC long newcall(int numero, int * numero2)
{
message m;
int rcode;
/* setear los campos del mensaje a enviar */
m.m1_i1 = numero;

/* La forma de pasar un mensaje a MM es a travs de:
_syscall(MM,NEWCALL,&m);
El mensaje de respuesta queda en m.
*/
rcode=_syscall(MM,NEWCALL,&m);

/* retornar la informacin contenida en el mensaje va parametros*/
*numero2=m.m2_l1;
return(rcode);
}
Tenemos hasta aqu una llamada al sistema que permite calcular en el PM el doble del
primer valor pasado como argumento.
Ahora debe compilar las libreras va:
cd /usr/src
make libraries
y el PM va
cd /usr/src/servers/pm
make
Si la compilacin del PM no arroja errores, puede crearse e instalarse una nueva imagen de
booteo va:
cd /usr/src/tools
make hdboot
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
9 de 10
Esto generar en /boot/image un archivo de nombre 3.1.2arX donde X es un numero de
release. El monitor de booteo toma, por defecto, la imagen mas nueva de ese directorio para
bootear.
El consumidor.c puede compilarse va
cc consumidor.c o consumidor.o
y rebootear MINIX
Luego de rebootear si se encuentra que el resultado de la corrida de consumidor.o es
# ./consumidor.o

Resultado newcall: 0 , valor 2do argumento: 8
Se habr probado que:
El proceso de usuario puede enviar informacin al PM va un mensaje
Que el PM puede desempaquetar la informacin contenida en el mensaje y realizar la
tarea necesaria para realizar la nueva system call
Que el PM puede enviar informacin de respuesta al proceso que realiz la llamada
al sistema.
Es decir, se ha logrado construir una nueva llamada al sistema y se ha trasmitido
informacin entre las capas 3 y 4 de MINIX. La funcionalidad de la llamada creada es nula
pero, el mecanismo a utilizar para escribir cualquier nueva llamada al sistema, ser muy
similar al descrito.
Comunicacin PM SYSTASK
En el caso en que el proceso servidor no tenga todos los recursos necesarios para satisfacer
la llamada al sistema, por ejemplo, porque se necesita acceder a informacin que est en el
espacio de direcciones del kernel, deber pedir que alguien haga la tarea por l. Nuestro caso
contina, justamente, asumiendo que la SYSTASK realizar la tarea (la multiplicacin por
2 del primer valor pasado como parmetro a newcall()).
La funcin do_newcall, mencionada arriba, debe armar un nuevo mensaje y enviarlo a la
SYSTASK. Como en el caso del programa de usuario, puede programarse al PM para:
- enviar directamente el mensaje utilizando la llamada a _syscall
- crear una funcin de librera que oculte todo el manejo de mensajes.
Optaremos por la segunda opcin agregando una funcin a la librera libsys.a. Para ello:
Construccin de la funcin de librera
En /usr/src/lib/syslib creamos el archivo sys_newcall.c
#include syslib.h
PUBLIC int sys_newcall(argumentos)
{
message m;
...
/* La forma de pasar un mensaje a la SYSTASK es a travs de:
_taskcall(SYSTASK,SYS_NEWCALL,&m);
El mensaje de respuesta queda en m.
*/
...
}

Editar el archivo Makefile.in en el mismo directorio y agregar a sys_newcall.c en la lista de
archivos que componen la librera:
sys_voutl.c \
sys_voutw.c \
sys_newcall.c \
Implementacin de una llamada al Sistema en MINIX 3 DISO UTN-FRSF 2008
10 de 10
taskcall.c"
Rehacer el Makefile ejecutando:
make Makefile
Luego, en /usr/src/include/minix/syslib.h agregar el prototipo de la funcin:
_PROTOTYPE( int sys_newcall, (int numero1, long *numero2) );
Por ltimo, solo resta modificar el funcionamiento de la SYSTASK para que responda a la
nueva peticin.
Modificacin de la SYSTASK
Debe, en primera instancia, agregarse una funcin ms en el vector de punteros a funciones
que utiliza la SYSTASK para ejecutar las funciones que atienden a cada system call.
Comenzamos cambiando en /usr/src/include/minix/com.h la cantidad mxima de llamadas
soportada por el kernel (NR_SYS_CALLS) y definiendo la macro SYS_NEWCALL
utilizada en la llamada a _taskcall():
# define SYS_NEWCALL (KERNEL_CALL + 31) /* sys_newcall() */
#define NR_SYS_CALLS 32 /* number of system calls */

En la funcin initialize() de /usr/src/kernel/system.c mediante llamadas a map() se carga
en cada posicin del vector call_vec[] un puntero a la funcion que debe ejecutarse ante un
mensaje de tipo n Entonces, debe agregarse una llamada a map() para cargar la direccin
correspondiente a la nueva llamada:
map(SYS_NEWCALL, do_newcall); /* Nueva llamada la sistema*/
Agregamos su prototipo en /usr/src/kernel/utility.h:
_PROTOTYPE( int do_newcall, (message *m_ptr) );
En /usr/src/kernel/system.c, puede escribirse la funcin que hace el trabajo solicitado En el
ejemplo, se denomina do_newcall(m_ptr)
int do_newcall(m_ptr)
register message *m_ptr;
{
m_ptr->m2_l1= m_ptr->m1_i1*2;
return(0);
}
Luego de esto, solo falta compilar las bibliotecas y el nuevo kernel. Para ello
cd /usr/src/
make libraries
cd /usr/src/tools
make hdboot
shutdown r now