Minikernel

Material complementario para la asignatura de Sistemas Operativos

Preparado por Gabriel Astudillo Muoz
Escuela de Ingeniera Civil Informtica
Universidad de Valparaso

Resumen

Este documento tiene como objetivo describir el entorno de desarrollo que se utilizar para las tareas
prcticas de la asignatura de Teora de Sistemas Operativos, relativas a gestin de procesos.

Introduccin

El software que se utiliza para el tema de Gestin de Procesos, es un kernel, denominado minikernel,
que es utilizado en el libro Prcticas de Sistemas Operativos: de la base al Diseo [1] y que su diseo se
basa en una estructura de Hardware Virtual [2]. Desde este punto de vista, consiste en una virtualizacin a
nivel de sistema operativo.
Debido a lo anterior, el minikernel est organizado en dos capas: una que implementa el hardware virtual,
denominal HAL (Hardware Abstraction Layer)1, y otra que implementa el sistema operativo propiamente
tal.

Entorno de desarrollo

En esta seccin, se describen los principales mdulos que componen el minikernel. En forma concreta,
posee tres componentes principales, cada una de ellas representada por un directorio, cuya descripcin
est en la Tabla 3.1.
Directorio
Raz

Directorio
boot/
minikernel/

kernel/
usuario/

Descripcin
Cargador del
sistema
Entorno
relacionado
con el kernel
Programas
que generan
los procesos
de la capa de
usuario

Archivos
boot
HAL.o
kernel.c
include/
lib/
init.c
simple.c
excep_arit.c
excep_mem.c

Descripcin
Programa cargador del sistema
operativo
Mdulo que representa el
Hardware Virtual
Sistema Operativo
Cabeceras utilizas por el kernel
Bibliotecas utilizas por los
programas de usuario
Proceso inicial del sistema.
Procesos de ejemplo

Tabla 3.1

Debido a que el objetivo de la utilizacin de este entorno es poner en prctica los conocimientos de
gestin de procesos, no se incluyen los cdigos fuentes del cargador (boot) ni de la capa de abstraccin
de hardware (HAL.o).

3.1

Mdulo HAL.o

Este mdulo implementa mediante software los componentes de hardware que tiene un computador, tales
como el procesador, memoria, reloj temporizador, pantalla y teclado. En el caso de los dos ltimos, el
sistema utliza la pantalla y el teclado del computador real. Adems, implementa interrupciones y nivel de
interrupciones y ofrece una API que permite acceder a los recursos implementados.

La capa HAL es parte del diseo de los sistemas operativos Unix y similares. Actualmente, HAL ha sido
reemplazo por la capa udev.

3.1.1
3.1.1.1

Implementacin de componentes de hardware

Procesador

El procesador tiene dos modos de operacin: modo privilegiado y modo usuario [2]. En el primero, se
ejecuta cdigo propio del sistema operativo mientras que en segundo permite la ejecucin de los cdigos
de los procesos de usuario. El cambio de modo de usuario a privilegiado ocurre slo cuando exite algn
tipo de interrupcin.
Existe un registro de estado del procesador, que almacena el modo de ejecucin del mismo. Para pasar
de modo privilegerado a modo usuario, el sistema operativo debe modificar ese valor dentro de ste
registro.
Por ltimo, dispone de seis registros de propsito general de 32 bits. Se utilizan para el paso de
parmetros en las llamadas al sistema. La cantidad de registros est definido en la macro NREGS, en el
arhivo de cabecera del kernel HAL.h.
3.1.1.2

Dispositivos de I/O

El sistema tiene implementado dos dispositivos de I/O basados en interrupciones: el terminal y el reloj.
El terminal es el tipo mapeado en memoria y est formado por dos dispositivos independientes: pantalla
y teclado. La salida de datos a la pantalla se realiza escribiendo directamente en su memoria de video y
no se utilizan interrupciones. La entrada de datos desde el teclado est comandada por interrupciones que
se producen cada vez que se pulsa una tecla.
El reloj temporizador tiene una frecuencia de interrupcin programable. Esto significa que este
temporizador interrumpe peridicamente y su perodo es modificable.
3.1.1.3

Interrupciones

El tratamiento de interrupciones se realiza mediante el uso de una tabla de vectores de interrupcin.

Existen seis vectores disponibles, los que se muestran en la Tabla 3.2.
Vector
0
1
2
3
4
5

Descripcin
Excepcin
Aritmtica
Excepcin
por
acceso no vlido a
memoria
Interrupcin de reloj
Interrupcin
del
terminal
Llamada al sistema
Interrupcin
por
Software

Modo de manejo
Con excepciones

Valores Nemotcnicos
EXC_ARITM
EXC_MEM

Interrupciones de
I/O

INT_RELOJ
INT_TERMINAL

Interrupciones de
software

LLAM_SIS
INT_SW

Tabla 3.2 Vectores disponibles. Los valores nemotcnicos estn definidos en la cabecera const.h.

El procesador tiene mltiples niveles de interrupcin, los que tienen asignado un nmero. Mientras mayor
sea, su prioridad es ms alta. Los niveles disponibles se muestran en la Tabla 3.3.
Nivel

Descripcin

3
2
1

Interrupcin de Reloj
Interrupcin de terminal
Interrupcin de software o
llamada al sistema
Ejecucin en modo usuario

Valores
Nemotcnicos
NIVEL_3
NIVEL_2
NIVEL_1
N/A

Tabla 3.3 Niveles de interrupcin. Los valores nemotcnicos estn definidos en la cabecera const.h.

En cada momento el procesador ejecuta cdigo en un determinado nivel de interrupcin, cuyo valor est
almacenado en el registro de estado. Cabe destacar que slo admite interrupciones de una nivel superior
al actual.

Inicialmente, el procesador ejecuta cdigo en modo privilegiado y en el nivel de interrupcin mximo,

por lo que todas las interrupciones estn inhibidas. Por otro lado, cuando el procesador ejecuta cdigo en
modo usuario, lo hace en un nivel 0, lo que significa que todas las interrupciones estn habilitadas.
3.1.2
3.1.2.1

API ofrecidas al sistema operativo.

Iniciacin de los controladores de dispositivos
void iniciar_cont_teclado();
Inicia el controlador del teclado.
void iniciar_con_reloj(int ticks_por_segundo);
Permite iniciar el controlador de reloj. El parmetro ticks_por_segundo es la
frecuencia de interrupcin deseada, medido en cantidad de interrupcione por segundo.
unsigned long long int leer_reloj_CMOS();
Permite leer la hora almacenada en el reloj del sistema real.

3.1.2.2

Manejo de interrupciones
void iniciar_cont_int();
Permite iniciar el controlador de interrupciones.
void instal_man_int(int nvector, void (*manej)() );
Permite que la funcin manjec() sea la que maneje la intrrupcin correspondiente a
nvector (ver tabla 3.2).
int fijar_nivel_int(int nivel)
Fija el nivel de interrupcin del procesador devolviendo el nivel previo. Los niveles estn
descritos en la 3.3.
void activar_int_SW()
Activa las interrupciones por software
int viene_de_modo_usuario()
Consulta el registro de estado salvado por la interrupcin actual y permite conocer si
previamente se estaba ejecutando en modo usuario, devolviendo un valor 1 en tal caso.

3.1.2.3

Gestin de la informacin del contexto de los procesos

El contexto de un proceso se representa por una estructura denominada contexto_t, la que almacena
una copia de los registros del procesador con los valores correspondientes a la ltima vez que ejecut el
proceso. La estructura se muestra en la Tabla 3.4.
/* Contexto "hardware" de un proceso */
typedef struct {
ucontext_t ctxt;
long registros[NREGS];
} contexto_t;
Tabla 3.4 Estructura que permite almacenar el contexto de un proceso. (Archivo HAL.h)

Las funciones que crean el contexto inicial de un proceso nuevo, as como las que permiten realizar un
cambio de contexto [2] son:
void fijar_contexto_ini(void *memoria, void *inicia_pila,
tam_pila, void *pc_inicial, contexto_t *contexto_ini);

int

Crea el contexto inicial. Establece los valores iniciales del contador de programa
(pc_inicial), puntero de la pila (inicia_pila) y su tamao (tam_pila). Como
parmetro de entrada, debe recibir una referencia al mapa de memoria del proceso
(memoria), creado con anterioridad. Como salida, retorna un contexto iniciado
(contexto_ini) de acuerdo con los valores especificados.

void cambio_context(contexto_t
*contexto_a_restaurar);

*contexto_a_salvar,

contexto_t

Bsicamente, esta funcin guarda el contexto de un proceso (contexto_a_salvar) y

restaura el de otro (contexto_a_restaurar).
3.1.2.4

Gestin de memoria de los procesos

void *crear_imagen(char *prog, void **dir_ini);
Crea el mapa de memoria a partir del ejecutable especificado por prog. Para esto, debe
procesar el archivo ejecutable y crear las regiones de memoria correspondientes. Devuelve
un identificador del mapa de memoria creado, as como la direccin de inicio del programa
en el parmetro de salida dir.
void liberar_imagen(void *mem);
Libera una imagen de memoria previamente creada, representada por el parmetro mem.
void *crear_pila(int tam);
Reserva una zona de memoria para la regin de pila (stack). Se especifica el tamao de la
misma (parmetro tam). Devuelve la direccin inicial de la zona reservada.
void liberar_pila(void *pila);
Reserva una zona de memoria para la regin de pila (stack). Se especifica el tamao de la
misma (parmetro tam). Devuelve la direccin inicial de la zona reservada.

3.1.2.5

Funciones varias
int leer_registro(int nreg);
int escribir_registro(int nreg, int valor);
Permiten leer y escribir en los registros de propsito general del prosesador.
char leer_puerto(int dir_puerto);
Lee y retorna un byte del puerto de I/O especificado por dir_puerto. El sistema posee un
solo puerto definido en la macro DIR_TERMINAL, que tiene el valor 1.
void halt();
Detiene el procesador hasta que se active una interrupcin
void escribir_ker(char *buffer, unsigned int longi)
Perminete escribir en pantalla los datos especificados en el parmetro buffer y cuyo tamao
es longi. Para ello, copia en la memoria de video del terminal dichos datos. El cdigo es:
/* Funcion interna que escribe en la pantalla */
void escribir_ker(char *texto, unsigned int longi)
{
int nivel_previo;
nivel_previo=fijar_nivel_int(NIVEL_3);
write(1, texto, longi);
fijar_nivel_int(nivel_previo);
}
Tabla 3.5

int printk(const char *, ...)

Funcin que llama internamente a escribir_ker(). Funciona como la funcin
printf().
void panico(char *mens)
Escribe el mensaje especificado por el parmetro mens por pantalla y termina la ejecucin
del sistema operativo.

3.2

Mdulo Kernel

3.3

Carga del sistema operativo

En el directorio raz, se debe ejecutar la intruccin:

./boot/boot minikernel/kernel
3.3.1

Inicio del sistema operativo

Una vez cargado en memoria el sistema operativo, el programa cargador pasa el control al punto de
entrada del kernel, que es la funcin main(). En este momento, el sistema inicia sus estructuras de
datos, dispositivos de hardware e instala los manejadores en la tabla de procesos. Por ltimo crea el
proceso inicial, denominado init, y lo activa pasndole el control del sistema.
Duranta la fase descrita anteriormente, el procesador ejecuta cdigo en modo privilegiado y las
interrupciones estn inhibidas (nivel de interrupcin 3). Cabe destacar que cuando se activa el proceso
init, el procesador pasa a ejecutar cdigo en modo usuario y se habilitan todas las interrupciones (nivel
0). Adems, una vez hecho el cambio de contexto (ver lnea 22 del cdigo de kernel mostrado en la Tabla
3.6), el kernel no puede volver nunca a su funcin main(). A partir de este evento, el sistema operativo
slo se ejecutar cuando se produzca una llamda al sistema, una excepcin o una interrupcin de un
dispositivo.
1: int main(){
2:
/* se llega con las interrupciones prohibidas */
3:
iniciar_tabla_proc();
4:
5:
instal_man_int(EXC_ARITM, exc_arit);
6:
instal_man_int(EXC_MEM, exc_mem);
7:
instal_man_int(INT_RELOJ, int_reloj);
8:
instal_man_int(INT_TERMINAL, int_terminal);
9:
instal_man_int(LLAM_SIS, tratar_llamsis);
10:
instal_man_int(INT_SW, int_sw);
11:
12:
iniciar_cont_int();
/* inicia cont. interr. */
13:
iniciar_cont_reloj(TICK); /* fija frec. del reloj */
14:
iniciar_cont_teclado();
/* inicia cont. teclado */
15:
16:
/* crea proceso inicial */
17:
if (crear_tarea((void *)"init")<0
18:
panico("no encontrado el proceso inicial");
19:
20: /* activa proceso inicial */
21: p_proc_actual=planificador();
22: cambio_contexto(NULL, &(p_proc_actual->contexto_regs));
23: panico("S.O. reactivado inesperadamente");
24: return 0;
25: }
Tabla 3.6 Cdigo principal del kernel a utilizar.

3.3.2

Tratamiento de interrupciones

En el caso de interrupciones externas, las nicas fuentes son el reloj y el terminal. Las rutinas de atencin
instaladas, tanto para interrupciones externas y de software, slo muestran un mensaje por pantalla
indicando la ocurrencia del evento. En el caso de la interrupcin del teclado, la rutina de atencin, adems
usa la funcin leer_puerto() para obtener el carcter ingresado.
static void int_terminal(){
printk("-> TRATANDO INT. DE TERMINAL %c\n",
leer_puerto(DIR_TERMINAL));
return;
}
static void int_reloj(){
printk("-> TRATANDO INT. DE RELOJ\n");
return;
}
Tabla 3.7 Ejemplo de rutinas de tratamiento de interrupciones.

3.3.3

Tratamiento de excepciones

Las dos posibles excepciones presentes en el sistema tienen un tratamiento comn que depende del modo
que se ejecutaba el procesador antes de producirse la excepcin. Si estaba en modo usuario, se termina la
ejecucin del proceso actual. En caso contrario, se trata de un error del propio sistema operativo, por lo
que se invoca a la funcin panico() para termina su ejecucin.
3.3.4

Llamadas al sistema

Existe una nica rutina de atencin para todas las llamadas a sistema, denominada
tratar_llamsis()(ver Tabla 3.8). Tanto el cdigo de la llamada como sus parmetros se pasan
mediante registros. Por convencin, el cdigo se pasa en el registro 0 y los parmetros en los siguientes,
considerando hasta cinco parmetros. El resultado de la llamada se devuelve en el registro 0. Esta rutina
invoca indirectamente, a travs de la estructura tabla_sevicios[](ver Tabla 3.9 y Tabla 3.10), a la
funcin correspondiente. Dicha tabla almacena en cada posicin la direccin de la funcin del sistema
operativo que lleva a cabo la llamada al sistema cuyo cdigo corresponde con dicha posicin.
static void tratar_llamsis(){
int nserv, res;
nserv=leer_registro(0);
if (nserv<NSERVICIOS)
res=(tabla_servicios[nserv].fservicio)();
else
res=-1;
/* servicio no existente */
escribir_registro(0,res);
return;
}
Tabla 3.8 Funcin de atencin de llamadas a sistema. Archivo kernel.c.

/* Numero de llamadas disponibles */

#define NSERVICIOS 3
#define CREAR_PROCESO 0
#define TERMINAR_PROCESO 1
#define ESCRIBIR 2
Tabla 3.9 Macros utlizados por la estructura tabla_servicios[]. Archivo llamsis.h.

typedef struct{
int (*fservicio)();
} servicio;
servicio tabla_servicios[NSERVICIOS]={
{sis_crear_proceso},
{sis_terminar_proceso},
{sis_escribir}
};
Tabla 3.10 Tabla de Servicio. Archivo kernel.h.

Por ejemplo, el llamada a sistema CREAR_PROCESO, est relacionada con la funcin

sis_crear_proceso(). Esta funcin se muestra en la Tabla 3.11. Se debe notar que el nombre del
proceso a crear se pasa a travs del registro 1 y la funcin que realmente lo crea es crear_tarea().
Todas las funciones de atencin a llamadas de sistemas, estn programadas en el archivo kernel.c.
int sis_crear_proceso(){
char *prog;
int res;

prog=(char *)leer_registro(1);
res=crear_tarea(prog);
return res;

Tabla 3.11 Funcin sis_crear_proceso(). Archivo kernel.c.

3.4

Programas de usuario

En el subdirectorio usuario existe inicialmente un conjunto de programas de ejemplo que usan los
servicios del minikernel. El ms importante, al igual que los sistemas operativos reales, es el proceso init,
que es el primer programa que ejecuta el sistema operativo. Este proceso es el que va a lanzar o ejecutar
otros procesos, que bsicamente sern muy simples, no como los procesos de los sistemas reales.
Los programas tienen acceso a las llamadas del sistema como funciones de bibioteca. Para este fin, existe
una biblioteca esttica, denominada libserv.a, que contiene las funciones de interfaz (ver Tabla 3.12)
para las tres llamadas bsicas al sistema, mencionadas en la seccin anterior. Esta biblioteca se crea a
travs de los objetos misc.o y serv.o. El alumno slo tiene acceso al cdigo de ste ltimo objeto. Se
debe tener presente que por convencin, los programas de usuario no deben usar llamadas al sistema
directamente. Lo deben hacer a travs de bibliotecas.
int crear_proceso(char *prog){
return llamsis(CREAR_PROCESO, 1, (long)prog);
}
int terminar_proceso(){
return llamsis(TERMINAR_PROCESO, 0);
}
int escribir(char *texto, unsigned int longi){
return llamsis(ESCRIBIR, 2, (long)texto, (long)longi);
}
Tabla 3.12 Interfaces para las llamadas bsicas al sistema. Archivo serv.c.

La funcin llamsis() est definido en misc.o y tiene la estructura que se muestra en la Tabla 3.13.
Aunque se pueden implementar las funciones de llamadas a sistema directamente, es preferible, en modo
usuario, utilizar esta funcin para realizar dicha tarea. Ntese que los argumentos de las llamadas a
sistema se pasan a travs de registros internos del procesador.
int llamsis(int llamada, int nargs, ... /* args */)
{
va_list args;
int registro;
escribir_registro(0, llamada);
va_start(args, nargs);
for ( registro=1; nargs; nargs--, registro++) {
escribir_registro(registro, va_arg(args, long));
}
va_end(args);
trap();
return leer_registro(0);
}
Tabla 3.13 Estructura de la funcin llamsis() para realizar llamadas a sistema en modo usuario.

Finalmente, est definida la funcin start(), que constituye el punto real de inicio del programa. Su
estructura se encuentra en la Tabla 3.14. Esta funcin se encarga de invocar a la funcin main, que es el
punto de inicio del programa para el programador. Este truco permite asegurarse de que el programa
siempre invoca la llamada al sistema de finalizacin, terminar_proceso(), al terminar. Si no lo ha
hecho la funcin main(), lo har start() al terminar la funcin main.

void start(void (*fini) (void)) {

fini();
terminar_proceso();
}
Tabla 3.14 Funcin start. Includa en misc.o.

Todos los programas de usuario utlizan el archivo usuario/include/servicios.h, que contiene

los prototipos de las funciones de interfaz a las llamadas al sistema.

Cdigo fuente de apoyo

En la Tabla 4.1 se describe detalladamento los archivos que se utillizarn en las tareas.
Directorio Raz

Archivo o
Directorio
Makefile
boot/
boot/boot
minikernel/
Makefile
kernel
HAL.o
kernel.c
include/
HAL.h
const.h
llamsis.h

minikernel/
kernel.h
usuario/
Makefile
init.c
*.c
include/
servicios.h
lib/
Makefile
libserv.a
serv.c
misc.o

Descripcin
Makefile general del entorno. Invoca a los
archivos Makefile de los subdirectorios.
Carga del sistema.
Programa de arranque del sistema operativo.
Entorno relacionado con el kernel.
Permite generar el ejecutable del sistema
operativo.
Ejecutable del sistema operativo.
Archivo que contiene las funciones relativas a la
capa de hardware.
Archivo que contiene la funciones del sistema
operativo. Este archivo debe ser modificado por
el alumno para incluir la funcionalidad solicitada
en cada tarea.
Archivos de cabecera
Contiene prototipos de las funciones del mdulo
HAL. No debe ser modificado.
Contiene algunas constantes, como los vectores
de interrupcin del sistema.
Contiene los cdigos numricos asignados a cada
llamada del sistema. Este archivo debe ser
modificado para incluir nuevas llamadas.
Contiene definiciones usadas por el mdulo
kernel.c, como la tabla de servicios. Este archivo
debe ser modificado.
Programas de usuario.
Permite compilar los programas de usuario.
Primer programa que ejecuta el sistema
operativo. Se debe modifcar para que invoque a
los programas que se consideren oportunos.
Programas que son ejecutados por init.c.
Archivos de cabecera.
Contiene los prototipos de las funciones que
sirven de interfaz a las llamadas al sistema. Debe
ser modificado para incluir la interfaz para
nuevas llamadas.
Mdulos que permiten generar la biblioteca que
utilizan los programas de usuario.
Genera la biblioteca de servicios.
Biblioteca de servicios.
Contiene la interfaz a los servicios del sistema
operativo. Debe ser modificado para incluir la
interfaz a nuevas llamadas.
Contiene otros funciones de bibliotecas
auxiliares.

Tabla 4.1 Descripcin de los archivos utlizados por el entorno minikernel.

Gestin de procesos

La gestin de procesos del sistema corresponde al de un sistema monoprogramado. Esto significa que
aunque se puedan crear y cargar en memoria mltiples programas, el proceso en ejecucin contina hasta
que termina, ya sea voluntariamento o involutariamente a travs de una excepcin. Las llamadas al
sistema disponibles no pueden causar que el proceso pase a un estado bloqueado.

5.1

Caractersticas de la gestin de procesos del minikernel

La tabla de procesos (tabla_procs) es un arreglo de tamao fijo (MAXPROC) de BCP.

BCP tabla_procs[MAX_PROC];

El BCP tiene la siguiente estructura (minikernel/include/kernel.h):

typedef struct BCP_t {
int id;
/* ident. del proceso */
int estado;
/* TERMINADO|LISTO|EJECUCION|BLOQUEADO*/
contexto_t contexto_regs; /* copia de regs. de UCP */
void * pila;
/* dir. inicial de la pila */
BCPptr siguiente; /* puntero a otro BCP */
void *info_mem;
/* descriptor del mapa de memoria */
} BCP;

El BCP dispone de un puntero (siguiente) que permite que el sistema operativo construya listas de
BCP que tengan alguna caracterstica en comn. Una lista de este tipo es la de procesos en estado listo
(lista_listos). Esta lista incluye al que se est ejecutndose actualmente.
El tipo usado para la fila de listos (tipo lista_BCP) permite construir listas con enlace simple,
almacenando referencias al primero y al ltimo elemento de la lista. Para facilitar su gestin, se ofrecen
funciones que permiten eliminar e insertar BCP en una lista de este tipo. Este tipo puede usarse para otras
listas del sistema operativo (por ejemplo, para un semforo). Este tipo de datos exige que un BCP no
pueda estar en dos listas simultneamente.
La variable p_proc_actual apunta al BCP del proceso en ejecucin. Este BCP est incluido en la fila de
listos.
La funcin que crea procesos (crea_proceso()) realiza los siguiente pasos:

Busca una entrada libre.

Crea el mapa de memoria a partir del ejecutable.
Reserva la pila del proceso.
Crea el contexto inicial.
Rellena el BCP adecuadamente.
Pone el proceso como listo para ejecutar y lo coloca al final de la fila de listos.

Cuando un proceso termina, se liberan sus recursos (imagen de memoria, pila y BCP). Luego se invoca al
planificador para que elija otro proceso y hacer un cambio de contexto a este nuevo proceso.
El planificador est determinado por la funcion planificador(). Debido a que el sistema es
monoprogramado, no se llama hasta que el proceso actual termina. Su poltica es FIFO. En el caso que
todos los procesos estn bloqueado (por ejemplo, si se cambia la poltica), se llamara a la funcin
espera_int(), de la que no se volvera hasta que se produjese una interrrupcin.

5.2

Cambios de contexto

El cambio de contexto es la operacin que cambia el proceso asignado al procesdor por otro. Existen dos
tipos de cambios de contexto.

Cambio de contexto Voluntario: se produce cuando el proceso en ejecucin pasa al estado

bloqueado debido a que tiene que esperar por algn tipo de evento. Slo pueden ocurrir dentro
de una llamada a sistema. No pueden darse nunca en una funcin de interrupcin, ya que ste
generalmente no est relacionada con el proceso que est actualmente ejecutando.
Cambio de contexto Involuntario: se produce cuando el proceso en ejecucin tiene que pasar
al estado Listo, ya que debe dejar el procesador por algn motivo (por ejemplo, cuando se le
acaba su ventana de tiempo de ejecucin o por que hay otro proceso con ms prioridad que hay
que ejecutar).

10

5.3

Cambio de contexto Voluntario

En este caso, el programador incluye llamadas a la funcin cambio_contexto() cuando lo requiera.

Por ejemplo:
{
...
//Bloquear el proceso por que se
//necesitan datos
bloquear() //Llamada a sistema
...
}

y la funcion bloquear(), tendra la forma:

bloquear(){
proc_anterior = proc_actual;
proc_anterior->estado = BLOQUEADO;
proc_actual = planificador();
cambio_contexto(proc_anterior, proc_actual);
}

Ntese que la funcin bloquear() debera elevar al mximo el nivel de interrupcin del procesador,
puesto que est modificando la lista de procesos listos y es prcticamente suguro que todas las funciones
de interrupcin manipulan esta lista.

5.4

Cambio de contexto Involuntario

Los cambios de contexto involuntario se producen a travs de interrupciones de software. Algunos

procesadores proporcionan este mecanismo, que consiste en una instruccin especial, que slo puede
ejecutarse en modo privilegiado, que causa una interrupcin de mnima prioridad.
Con la interrupcin de software, el cambio de contecto involuntario es trivial: cuando dentro del cdigo
de una llamada o una interrupcin se detecta que hay que realizar, por motivo que sea, un cambio de
contexto involuntario, se activa la interrupcin de software respectiva. Dado que se trata de una
interrupcin del nivel mnimo, su rutina de tratamiento no se activar hasta que el nivel de interrupcin
del procesador sea 0 (esto es, modo usuario). Esta funcin de tratamiento se encargar de realizar el
cambio de contexto involuntario.

Modalidad de trabajo

Originalmente, el minikernel se entregaba en formato comprimido estndar de unix (.tar.gz). El nico

requisito es que la persona que desee utilizarlo, lo debe instalar en un sisema operativo Linux. Para esto,
la Escuela de Ingeniera Civil Informtica posee computadores con Linux instalado. Pero para promover
la movilidad y el trabajo en otros lugares que no sean las salas de computadores y que no sea necesario
tener Linux instalado en un computador personal, se ha decidido entregar el minikernel junto con una
distribucin de Linux en formato de Mquina Virtual. Especificamente, se entrega un appliance, que
bsicamente consiste en un archivo que tiene todas las definiciones y archivos para que el usuario final
disponga de un computador virtual sin la necesidad de instalarlo. Para esto, slo es necesario instalar el
software de virtualizacin VirtualBox [3] y luego importar el archivo que constituye el appliance. Es
recomendable instalar adicionalmente el software VirtualBox Extension Pack. Ambos se pueden bajar
de la pgina de VirtualBox.

Bibliografa

[1] Prcticas de Sistemas Operativos, Jess Carretero Prez, MC Graw-Hill, 2003.

[2] Operating system concepts, Abraham Silberschatz, Peter Baer Galvin, Greg Gagne, 6 ed.
[3] Virtual Box. http://www.virtualbox.org

Anexo: Utilizacin de Virtual box.

Se asume que el sistema operativo que usted utiliza es alguna versin de windows superior a XP y que el
software Virtual Box est instalado en su sistema. Adems, usted necesitar el programa WinSCP, el que
lo puede bajar de http://portableapps.com/apps/internet/winscp_portable. Finalmente, el archivo
appliance se llama INC303.ova, el que estar publicado en un servidor que se dar a conocer a travs del
Aula Virtual.

11

Paso 1: Importar el appliance en Virtual Box: Men Archivo->Importar Servicio virtualizado. Luego
seleccionar el archivo ramosinc.ova. Inicie la mquina virtual. Si sale un error con respecto a las
interfaces de red, slo coloque configurar las interfaces, acepte los cambios propuesto e inicie la mquina
nuevamente.
Paso 2: Ejecutar WinSCP, y seleccionar Sesin del tipo SFTP. En la IP del servidor, debe ingresar
192.168.56.10. El puerto de comunicacin es 22. El usuario es root y su contrasea es admin. Una vez
realizado lo anterior, debe presionar Conectar. Luego de conectar, sus archivos locales estarn en el
lado izquierdo de la ventana del programa, y los archivos de la mquina virtual, es el lado derecho. Para
copiar de un lado a otro, slo arrastre y suelte.
Observaciones:
Para compilar, es necesario que usted ingrese directamente a la mquina virtual. Para esto, debe ingresar a
ella con el usuario root y su contrasea admin. Usted deber averiguar comandos bsicos de Linux para
moverse en los directorios, en modo consola.
La distribucin entregada es Debian, versin Jessie, con entorno grfico XFCE. Para acceder a dicho
entorno, cuando usted ingrese al sistema, debe ejecutar el comando startxfce4. El software instalado
en la mquina virtual, est resumido en el campo descripcin de la misma.

12