Directorio Descripción Archivos Descripción. Cargador del sistema Entorno relacionado con el kernel. boot

Transcripción

1 1 Resumen Minikernel Material complementario para la asignatura de Sistemas Operativos Preparado por Gabriel Astudillo Muñoz Escuela de Ingeniería Civil Informática Universidad de Valparaíso Este documento tiene como objetivo describir el entorno de desarrollo que se utilizará para las tareas prácticas de la asignatura de Teoría de Sistemas Operativos, relativas a gestión de procesos. 2 Introducción El software que se utiliza para el tema de Gestión de Procesos, es un kernel, denominado minikernel, que es utilizado en el libro Prácticas de Sistemas Operativos: de la base al Diseño [1] y que su diseño se basa en una estructura de Hardware Virtual [2]. Desde este punto de vista, consiste en una virtualización 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. 3 Entorno de desarrollo En esta sección, se describen los principales módulos que componen el minikernel. En forma concreta, posee tres componentes principales, cada una de ellas representada por un directorio, cuya descripción está en la Tabla 3.1. Directorio Raíz kernel/ Directorio Descripción Archivos Descripción boot/ minikernel/ usuario/ Cargador del sistema Entorno relacionado con el kernel Programas que generan los procesos de la capa de usuario boot HAL.o kernel.c include/ lib/ init.c simple.c excep_arit.c excep_mem.c Tabla 3.1 Programa cargador del sistema operativo Módulo 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 Debido a que el objetivo de la utilización de este entorno es poner en práctica los conocimientos de gestión de procesos, no se incluyen los códigos fuentes del cargador (boot) ni de la capa de abstracción de hardware (HAL.o). 3.1 Módulo HAL.o Este módulo 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. Además, implementa interrupciones y nivel de interrupciones y ofrece una API que permite acceder a los recursos implementados. 1 La capa HAL es parte del diseño de los sistemas operativos Unix y similares. Actualmente, HAL ha sido reemplazo por la capa udev. 1

2 3.1.1 Implementación de componentes de hardware Procesador El procesador tiene dos modos de operación: modo privilegiado y modo usuario [2]. En el primero, se ejecuta código propio del sistema operativo mientras que en segundo permite la ejecución de los códigos de los procesos de usuario. El cambio de modo de usuario a privilegiado ocurre sólo cuando exite algún tipo de interrupción. Existe un registro de estado del procesador, que almacena el modo de ejecución 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 propósito general de 32 bits. Se utilizan para el paso de parámetros en las llamadas al sistema. La cantidad de registros está definido en la macro NREGS, en el arhivo de cabecera del kernel HAL.h 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 interrupción programable. Esto significa que este temporizador interrumpe periódicamente y su período es modificable Interrupciones El tratamiento de interrupciones se realiza mediante el uso de una tabla de vectores de interrupción. Existen seis vectores disponibles, los que se muestran en la Tabla 3.2. Vector Descripción Modo de manejo Valores Nemotécnicos 0 Excepción Con excepciones EXC_ARITM Aritmética 1 Excepción por EXC_MEM acceso no válido a memoria 2 Interrupción de reloj Interrupciones de INT_RELOJ 3 Interrupción del I/O INT_TERMINAL terminal 4 Llamada al sistema Interrupciones de LLAM_SIS 5 Interrupción por software INT_SW Software Tabla 3.2 Vectores disponibles. Los valores nemotécnicos están definidos en la cabecera const.h. El procesador tiene múltiples niveles de interrupción, los que tienen asignado un número. Mientras mayor sea, su prioridad es más alta. Los niveles disponibles se muestran en la Tabla 3.3. Nivel Descripción Valores Nemotécnicos 3 Interrupción de Reloj NIVEL_3 2 Interrupción de terminal NIVEL_2 1 Interrupción de software o NIVEL_1 llamada al sistema 0 Ejecución en modo usuario N/A Tabla 3.3 Niveles de interrupción. Los valores nemotécnicos están definidos en la cabecera const.h. En cada momento el procesador ejecuta código en un determinado nivel de interrupción, cuyo valor está almacenado en el registro de estado. Cabe destacar que sólo admite interrupciones de una nivel superior al actual. 2

3 Inicialmente, el procesador ejecuta código en modo privilegiado y en el nivel de interrupción máximo, por lo que todas las interrupciones están inhibidas. Por otro lado, cuando el procesador ejecuta código en modo usuario, lo hace en un nivel 0, lo que significa que todas las interrupciones están habilitadas API ofrecidas al sistema operativo Iniciación 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 parámetro ticks_por_segundo es la frecuencia de interrupción 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 Manejo de interrupciones void iniciar_cont_int(); Permite iniciar el controlador de interrupciones. void instal_man_int(int nvector, void (*manej)() ); Permite que la función manjec() sea la que maneje la intrrupción correspondiente a nvector (ver tabla 3.2). int fijar_nivel_int(int nivel) Fija el nivel de interrupción del procesador devolviendo el nivel previo. Los niveles están 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 interrupción actual y permite conocer si previamente se estaba ejecutando en modo usuario, devolviendo un valor 1 en tal caso Gestión de la información 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, int tam_pila, void *pc_inicial, contexto_t *contexto_ini); Crea el contexto inicial. Establece los valores iniciales del contador de programa (pc_inicial), puntero de la pila (inicia_pila) y su tamaño (tam_pila). Como parámetro 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. 3

4 void cambio_context(contexto_t *contexto_a_salvar, contexto_t *contexto_a_restaurar); Básicamente, esta función guarda el contexto de un proceso (contexto_a_salvar) y restaura el de otro (contexto_a_restaurar) Gestión 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 dirección de inicio del programa en el parámetro de salida dir. void liberar_imagen(void *mem); Libera una imagen de memoria previamente creada, representada por el parámetro mem. void *crear_pila(int tam); Reserva una zona de memoria para la región de pila (stack). Se especifica el tamaño de la misma (parámetro tam). Devuelve la dirección inicial de la zona reservada. void liberar_pila(void *pila); Reserva una zona de memoria para la región de pila (stack). Se especifica el tamaño de la misma (parámetro tam). Devuelve la dirección inicial de la zona reservada Funciones varias int leer_registro(int nreg); int escribir_registro(int nreg, int valor); Permiten leer y escribir en los registros de propósito 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 interrupción void escribir_ker(char *buffer, unsigned int longi) Perminete escribir en pantalla los datos especificados en el parámetro buffer y cuyo tamaño es longi. Para ello, copia en la memoria de video del terminal dichos datos. El código 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); int printk(const char *,...) Tabla 3.5 Función que llama internamente a escribir_ker(). Funciona como la función printf(). void panico(char *mens) Escribe el mensaje especificado por el parámetro mens por pantalla y termina la ejecución del sistema operativo. 4

5 3.2 Módulo Kernel 3.3 Carga del sistema operativo En el directorio raíz, se debe ejecutar la intrucción: Inicio del sistema operativo./boot/boot minikernel/kernel Una vez cargado en memoria el sistema operativo, el programa cargador pasa el control al punto de entrada del kernel, que es la función 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 pasándole el control del sistema. Duranta la fase descrita anteriormente, el procesador ejecuta código en modo privilegiado y las interrupciones están inhibidas (nivel de interrupción 3). Cabe destacar que cuando se activa el proceso init, el procesador pasa a ejecutar código en modo usuario y se habilitan todas las interrupciones (nivel 0). Además, una vez hecho el cambio de contexto (ver línea 22 del código de kernel mostrado en la Tabla 3.6), el kernel no puede volver nunca a su función main(). A partir de este evento, el sistema operativo sólo se ejecutará cuando se produzca una llamda al sistema, una excepción o una interrupción 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: Tratamiento de interrupciones Tabla 3.6 Código principal del kernel a utilizar. En el caso de interrupciones externas, las únicas fuentes son el reloj y el terminal. Las rutinas de atención instaladas, tanto para interrupciones externas y de software, sólo muestran un mensaje por pantalla indicando la ocurrencia del evento. En el caso de la interrupción del teclado, la rutina de atención, además usa la función leer_puerto() para obtener el carácter 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. 5

6 3.3.3 Tratamiento de excepciones Las dos posibles excepciones presentes en el sistema tienen un tratamiento común que depende del modo que se ejecutaba el procesador antes de producirse la excepción. Si estaba en modo usuario, se termina la ejecución del proceso actual. En caso contrario, se trata de un error del propio sistema operativo, por lo que se invoca a la función panico() para termina su ejecución Llamadas al sistema Existe una única rutina de atención para todas las llamadas a sistema, denominada tratar_llamsis()(ver Tabla 3.8). Tanto el código de la llamada como sus parámetros se pasan mediante registros. Por convención, el código se pasa en el registro 0 y los parámetros en los siguientes, considerando hasta cinco parámetros. El resultado de la llamada se devuelve en el registro 0. Esta rutina invoca indirectamente, a través de la estructura tabla_sevicios[](ver Tabla 3.9 y Tabla 3.10), a la función correspondiente. Dicha tabla almacena en cada posición la dirección de la función del sistema operativo que lleva a cabo la llamada al sistema cuyo código corresponde con dicha posición. 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 Función de atención 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. 6

7 Por ejemplo, el llamada a sistema CREAR_PROCESO, está relacionada con la función sis_crear_proceso(). Esta función se muestra en la Tabla Se debe notar que el nombre del proceso a crear se pasa a través del registro 1 y la función que realmente lo crea es crear_tarea(). Todas las funciones de atención a llamadas de sistemas, están programadas en el archivo kernel.c. 3.4 Programas de usuario int sis_crear_proceso(){ char *prog; int res; prog=(char *)leer_registro(1); res=crear_tarea(prog); return res; Tabla 3.11 Función sis_crear_proceso(). Archivo kernel.c. En el subdirectorio usuario existe inicialmente un conjunto de programas de ejemplo que usan los servicios del minikernel. El más 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 básicamente serán 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 estática, denominada libserv.a, que contiene las funciones de interfaz (ver Tabla 3.12) para las tres llamadas básicas al sistema, mencionadas en la sección anterior. Esta biblioteca se crea a través de los objetos misc.o y serv.o. El alumno sólo tiene acceso al código de éste último objeto. Se debe tener presente que por convención, los programas de usuario no deben usar llamadas al sistema directamente. Lo deben hacer a través 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 básicas al sistema. Archivo serv.c. La función llamsis() está definido en misc.o y tiene la estructura que se muestra en la Tabla Aunque se pueden implementar las funciones de llamadas a sistema directamente, es preferible, en modo usuario, utilizar esta función para realizar dicha tarea. Nótese que los argumentos de las llamadas a sistema se pasan a través 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 función llamsis() para realizar llamadas a sistema en modo usuario. Finalmente, está definida la función start(), que constituye el punto real de inicio del programa. Su estructura se encuentra en la Tabla Esta función se encarga de invocar a la función 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 finalización, terminar_proceso(), al terminar. Si no lo ha hecho la función main(), lo hará start() al terminar la función main. 7

8 void start(void (*fini) (void)) { fini(); terminar_proceso(); Tabla 3.14 Función start. Incluída 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. 8

9 4 Código fuente de apoyo En la Tabla 4.1 se describe detalladamento los archivos que se utillizarán en las tareas. Directorio Raíz minikernel/ Archivo o Directorio Makefile boot/ boot/boot minikernel/ Makefile kernel HAL.o kernel.c include/ HAL.h const.h llamsis.h kernel.h usuario/ Makefile init.c *.c include/ lib/ servicios.h Makefile libserv.a serv.c misc.o Descripción 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 módulo HAL. No debe ser modificado. Contiene algunas constantes, como los vectores de interrupción del sistema. Contiene los códigos numéricos asignados a cada llamada del sistema. Este archivo debe ser modificado para incluir nuevas llamadas. Contiene definiciones usadas por el módulo 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. Módulos 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 Descripción de los archivos utlizados por el entorno minikernel. 9

10 5 Gestión de procesos La gestión de procesos del sistema corresponde al de un sistema monoprogramado. Esto significa que aunque se puedan crear y cargar en memoria múltiples programas, el proceso en ejecución continúa hasta que termina, ya sea voluntariamento o involutariamente a través de una excepción. Las llamadas al sistema disponibles no pueden causar que el proceso pase a un estado bloqueado. 5.1 Características de la gestión de procesos del minikernel La tabla de procesos (tabla_procs) es un arreglo de tamaño 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 característica en común. Una lista de este tipo es la de procesos en estado listo (lista_listos). Esta lista incluye al que se está ejecutándose 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 gestión, 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 semáforo). Este tipo de datos exige que un BCP no pueda estar en dos listas simultáneamente. La variable p_proc_actual apunta al BCP del proceso en ejecución. Este BCP está incluido en la fila de listos. La función 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 política es FIFO. En el caso que todos los procesos estén bloqueado (por ejemplo, si se cambia la política), se llamaría a la función espera_int(), de la que no se volvería hasta que se produjese una interrrupción. 5.2 Cambios de contexto El cambio de contexto es la operación 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 ejecución pasa al estado bloqueado debido a que tiene que esperar por algún tipo de evento. Sólo pueden ocurrir dentro de una llamada a sistema. No pueden darse nunca en una función de interrupción, ya que éste generalmente no está relacionada con el proceso que está actualmente ejecutando. Cambio de contexto Involuntario: se produce cuando el proceso en ejecución tiene que pasar al estado Listo, ya que debe dejar el procesador por algún motivo (por ejemplo, cuando se le acaba su ventana de tiempo de ejecución o por que hay otro proceso con más prioridad que hay que ejecutar). 10

11 5.3 Cambio de contexto Voluntario En este caso, el programador incluye llamadas a la función cambio_contexto() cuando lo requiera. Por ejemplo: y la funcion bloquear(), tendría la forma: {... //Bloquear el proceso por que se //necesitan datos bloquear() //Llamada a sistema... bloquear(){ proc_anterior = proc_actual; proc_anterior->estado = BLOQUEADO; proc_actual = planificador(); cambio_contexto(proc_anterior, proc_actual); Nótese que la función bloquear() debería elevar al máximo el nivel de interrupción del procesador, puesto que está modificando la lista de procesos listos y es prácticamente suguro que todas las funciones de interrupción manipulan esta lista. 5.4 Cambio de contexto Involuntario Los cambios de contexto involuntario se producen a través de interrupciones de software. Algunos procesadores proporcionan este mecanismo, que consiste en una instrucción especial, que sólo puede ejecutarse en modo privilegiado, que causa una interrupción de mínima prioridad. Con la interrupción de software, el cambio de contecto involuntario es trivial: cuando dentro del código de una llamada o una interrupción se detecta que hay que realizar, por motivo que sea, un cambio de contexto involuntario, se activa la interrupción de software respectiva. Dado que se trata de una interrupción del nivel mínimo, su rutina de tratamiento no se activará hasta que el nivel de interrupción del procesador sea 0 (esto es, modo usuario). Esta función de tratamiento se encargará de realizar el cambio de contexto involuntario. 6 Modalidad de trabajo Originalmente, el minikernel se entregaba en formato comprimido estándar 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 Ingeniería Civil Informática 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 distribución de Linux en formato de Máquina Virtual. Especificamente, se entrega un appliance, que básicamente 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, sólo es necesario instalar el software de virtualización 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 página de VirtualBox. 7 Bibliografía [1] Prácticas de Sistemas Operativos, Jesús Carretero Pérez, MC Graw-Hill, [2] Operating system concepts, Abraham Silberschatz, Peter Baer Galvin, Greg Gagne, 6 ed. [3] Virtual Box. 8 Anexo: Utilización de Virtual box. Se asume que el sistema operativo que usted utiliza es alguna versión de windows superior a XP y que el software Virtual Box está instalado en su sistema. Además, usted necesitará el programa WinSCP, el que lo puede bajar de Finalmente, el archivo appliance se llama INC303.ova, el que estará publicado en un servidor que se dará a conocer a través del Aula Virtual. 11

12 Paso 1: Importar el appliance en Virtual Box: Menú Archivo->Importar Servicio virtualizado. Luego seleccionar el archivo ramosinc.ova. Inicie la máquina virtual. Si sale un error con respecto a las interfaces de red, sólo coloque configurar las interfaces, acepte los cambios propuesto e inicie la máquina nuevamente. Paso 2: Ejecutar WinSCP, y seleccionar Sesión del tipo SFTP. En la IP del servidor, debe ingresar El puerto de comunicación es 22. El usuario es root y su contraseña es admin. Una vez realizado lo anterior, debe presionar Conectar. Luego de conectar, sus archivos locales estarán en el lado izquierdo de la ventana del programa, y los archivos de la máquina virtual, es el lado derecho. Para copiar de un lado a otro, sólo arrastre y suelte. Observaciones: Para compilar, es necesario que usted ingrese directamente a la máquina virtual. Para esto, debe ingresar a ella con el usuario root y su contraseña admin. Usted deberá averiguar comandos básicos de Linux para moverse en los directorios, en modo consola. La distribución entregada es Debian, versión Jessie, con entorno gráfico XFCE. Para acceder a dicho entorno, cuando usted ingrese al sistema, debe ejecutar el comando startxfce4. El software instalado en la máquina virtual, está resumido en el campo descripción de la misma. 12