Diseño e Implementacion de MINIX

Universidad de El Salvador
Facultad Multidisciplinaria de Occidente
Departamento de Ingeniería y Arquitectura
Ciclo II / 2008
Proyecto sobre el diseño e implementación de MINIX

Cátedra: Sistemas Operativos
Catedrático: Tec. Edenilson López
Integrantes: Figueroa Landaverde, Miguel Gehovani
Vasquez Castaneda, Guillermo Rafael
Grupo: Siete
Santa Ana, Martes 25 de noviembre de 2008

Índice
RESUMEN DEL SISTEMA OPERATIVO MINIX. ................................................................................................ 4
ESTRUCTURA DE MINIX................................................................................................................................ 6
RECORRIDO POR LOS FUENTES DEL MINIX - /USR/SRC - /USR/INCLUDE. ..................................................... 7
SISTEMA DE ARRANQUE DE MINIX .............................................................................................................. 9
MASTERBOOT.S .......................................................................................................................................... 10
Pseudocódigo. .................................................................................................................................... 10
Código fuente en ensamblador. .......................................................................................................... 11
BOOTBLOCK.S ............................................................................................................................................ 17
Pseudocódigo. .................................................................................................................................... 17
Código fuente en ensamblador. .......................................................................................................... 18
ESQUEMA DE CABECERAS DEL SISTEMA DE ARRANQUE. ......................................................................................... 24
ESQUEMA DE ARCHIVOS FUENTES DEL SISTEMA DE ARRANQUE. ............................................................................... 24
CABECERAS POSIX - /USR/INCLUDE. .......................................................................................................... 26
ESQUEMA DE CABECERAS POSIX - /USR/INCLUDE. ............................................................................................... 26
ESQUEMA DE CABECERAS IBM - /USR/INCLUDE/IBM ........................................................................................... 29
ESQUEMA DE CABECERAS NET - /USR/INCLUDE/NET............................................................................................ 29
ESQUEMA DE CABECERAS DE MINIX - /USR/INCLUDE/MINIX ................................................................................. 30
ESQUEMA DE CABECERAS DE SYS - /USR/INCLUDE/SYS ......................................................................................... 32
CAPA 1 - 2 - ADMINISTRACIÓN DE PROCESOS / TAREAS DE E/S - /USR/SRC/KERNEL ................................. 34
KERNEL. ................................................................................................................................................... 34
MICROKERNEL............................................................................................................................................ 34
ADMINISTRACIÓN DE PROCESOS. ..................................................................................................................... 34
TAREAS DE E/S. .......................................................................................................................................... 35
ESQUEMA DE CABECERAS DEL ADMINISTRADOR DE PROCESOS / TAREAS DE E/S ......................................................... 36
ESQUEMA DE ARCHIVOS FUENTES DEL ADMINISTRADOR DE PROCESOS. ..................................................................... 38
ESQUEMA DE ARCHIVOS FUENTES DE TAREAS DE E/S............................................................................................ 40
CAPA 3 - ADMINISTRADOR DE MEMORIA (MM) - /USR/SRC/MM. ............................................................ 43
FUNCIONAMIENTO DEL MM. ......................................................................................................................... 43
TIPOS DE MENSAJES ..................................................................................................................................... 43
ESQUEMA DE CABECERAS DEL ADMINISTRADOR DE MEMORIA. ............................................................................... 45
ESQUEMA DE ARCHIVOS FUENTES DEL ADMINISTRADOR DE MEMORIA. ..................................................................... 46
CAPA 3 - SISTEMA DE FICHEROS (FS) - /USR/SRC/FS. ................................................................................. 48

SISTEMA DE FICHEROS EN MINIX. ................................................................................................................... 48
FUNCIONAMIENTO DEL SISTEMA DE FICHEROS. ................................................................................................... 49
ESQUEMA DE CABECERAS DEL SISTEMA DE FICHEROS. ........................................................................................... 51
ESQUEMA DE ARCHIVOS FUENTE DEL SISTEMA DE FICHEROS. .................................................................................. 53
RECOMENDACIONES. ................................................................................................................................. 56
ANEXOS. .................................................................................................................................................... 57
MANUAL DE INSTALACIÓN DE VIRTUALBOX SOBRE EL SISTEMA OPERATIVO GNU/LINUX. .............................................. 58
MANUAL DE INSTALACIÓN DE MINIX 2 EN LA MAQUINA VIRTUAL VIRTUALBOX CORRIENDO SOBRE GNU/LINUX. ............... 64
CONFIGURACIÓN DE VIRTUALBOX CORRIENDO SOBRE GNU/LINUX PARA LA INSTALACIÓN DE MINIX 3. ........................... 72
INSTALACIÓN DE MINIX 3 EN LA MAQUINA VIRTUAL VIRTUALBOX CORRIENDO SOBRE GNU/LINUX. ................................ 80
MANUAL DE INSTALACIÓN DE VIRTUALBOX SOBRE EL SISTEMA OPERATIVO MICROSOFT WINDOWS. ................................. 88
MANUAL DE INSTALACIÓN DE MINIX 2 EN LA MAQUINA VIRTUAL VIRTUALBOX CORRIENDO SOBRE WINDOWS. .................. 94
CONFIGURACIÓN DE VIRTUALBOX CORRIENDO SOBRE WINDOWS PARA LA INSTALACIÓN DE MINIX 3. ........................... 102
INSTALACIÓN DE MINIX 3 EN LA MAQUINA VIRTUAL VIRTUALBOX CORRIENDO SOBRE WINDOWS. ................................ 109
MANUAL DE INSTALACIÓN DE LA MAQUINA VIRTUAL VMWARE WORKSTATION EN WINDOWS. ................................... 117
MANUAL DE INSTALACIÓN DE MINIX 2 EN LA MAQUINA VIRTUAL VMWARE PLAYER ................................................. 122
CONFIGURACIÓN DE VMWARE WORKSTATION CORRIENDO SOBRE WINDOWS PARA LA INSTALACIÓN DE MINIX 3. .......... 126
MANUAL DE INSTALACIÓN DE MINIX 3 SOBRE LA MAQUINA VIRTUAL VMWARE WORKSTATION CORRIENDO SOBRE WINDOWS.
............................................................................................................................................................ 131
MANUAL DE INSTALACIÓN DE MINIX 3 EN UNA COMPUTADORA DIRECTAMENTE. ..................................................... 139
TROUBLESHOOTING. .................................................................................................................................. 147
MINIX 2. ........................................................................................................................................... 147
MINIX 3. ........................................................................................................................................... 149
MANUAL DE USUARIO DE MINIX. ................................................................................................................. 152
Comandos para Gestión de archivos y directorios ............................................................................. 155
Comandos para Gestión de procesos ................................................................................................ 158
Comandos para Gestión de usuarios ................................................................................................. 158
Comandos para la gestión de permisos sobre archivos ...................................................................... 160
Comandos para la gestión del sistema de ficheros ............................................................................ 161
COMPILACIÓN DE MINIX............................................................................................................................ 164
Pequeña guía de compilación de MINIX. ........................................................................................... 164
Compilación de MINIX 2. .............................................................................................................................. 165
MODIFICACIÓN DE ALGUNOS PARÁMETROS DEL BOOT MONITOR. .......................................................................... 170
PEQUEÑO MANUAL DEL EDITOR DE TEXTO VI. ................................................................................................... 173
MODIFICACIÓN DE MENSAJE DE ARRANQUE DEL MINIX. ..................................................................................... 174
DANDO FUNCIONALIDAD A LA TECLA F6. ......................................................................................................... 175
Resumen del sistema operativo MINIX.
MINIX fue creado con propósitos pedagógicos, debido a ello su código está a disposición del
público y puede ser estudiado y modificado a voluntad en cada una de sus partes o capas. Este
sistema operativo consta de cuatro capas, las cuales son la administración de procesos, tareas de
E/S, los procesos servidores y los procesos de usuario; las primeras dos capas comprenden el
Kernel.
En un sistema operativo la parte fundamental es el Kernel, ya que es este quien gestiona las
conexiones a hardware que solicitan los programas, además gestiona todos los recursos, por
medio de llamadas al sistema. El hecho que la administración de servicios este desvinculada del
Kernel lo convierte en lo que se denomina un Microkernel.
Un proceso no es más que un programa en ejecución, e incluye los valores actuales del contador
de programa, los registros y las variables, en MINIX la parte encargada de gestionar dichos
procesos es el Administrador de procesos, que es la primera de las cuatro capas que componen
este sistema operativo, entre sus tareas está la de atender interrupciones y programar tareas.
La función de controlar los dispositivos de E/S, se realiza en la segunda capa, esta envía comandos
a los dispositivos, detecta interrupciones, maneja los errores y contiene los drivers de los diversos
dispositivos como memoria y discos duros entre otros.
La administración de memoria se lleva a cabo en la capa tres, la cual conserva una lista de huecos
de direcciones de memoria ordenada, cuando se necesita memoria debido a una instrucción FORK
o EXEC, se busca el primer bloque lo suficientemente grande utilizando el algoritmo FIRST FIT, una
vez un proceso es colocado en memoria este no se moverá de allí hasta que se termine. El ciclo del
Manejador de Memoria consiste en esperar mensaje, resolución de la petición y emisión de una
contestación.
Otro componente de la tercera capa de MINIX, es El Sistema de Ficheros, el cual se puede

almacenar en cualquier dispositivo de bloques, con la misma estructura en todos los casos, MINIX
implementa un Sistema de Ficheros de nodos-i, una vez iniciado al igual que el Manejador de
Memoria queda bloqueado a la espera de mensajes.
Los nodos-i son estructuras de 64 bytes (32 bytes en la versión 1 del sistema de ficheros) en las
que se encuentra información de cada fichero físico existente en el sistema de archivos,
principalmente la relativa a la situación de las zonas de datos de dicho fichero.
El principal directorio de MINIX es el directorio root del cual se desprenden otros subdirectorios
como el usr donde se encuentran los archivos del sistema.
4
La codificación de MINIX se encuentra en /usr/include - /usr/src, en el primero se encuentran las
cabeceras Posix estándar y en la segunda están el código del Kernel, así como La Administración
de Memoria y El Sistema de Ficheros.
Entre las funciones que desempeña el sistema de arranque de MINIX, está la de hacer pruebas
para almacenar información de todos los dispositivos, busca la primera unidad de arranque, sino
encuentra una, envía un mensaje de unidad no encontrada, en dado caso se debe elegir una
manualmente que sea la adecuada; MINIX carga un boot secundario o Monitor el cual permite
configurar características de arranque.
Los archivos .c y .h están escritos en código C y los .s en código de lenguaje Ensamblador y que
solo se encuentran en la capa de administración de procesos dentro del Kernel, asi como también
en la parte del sector arranque.
5
Estructura de MINIX.
El sistema operativo MINIX está estructurado de la siguiente manera:
root
bin dev etc fd0 fd1 minix mnt mnt2 root tmp usr
bin: Debe contener los programas utilizados más frecuentemente, ya que se encuentra en RAM (resto en /usr/bin).
dev: Contiene los ficheros utilizados para el manejo de dispositivos de E/S.
etc: Contiene parte de los ficheros de datos y configuración del sistema, otros se encuentran en /usr/etc.
fd0 y fd1: Directorios vacios para que el usuario monte su sistema de ficheros.
minix: Contiene las imágenes ejecutables del sistema operativo MINIX.
mnt y mnt2: Directorios vacios.
root: Directorio para el usuario root.
tmp: Lo utilizan los programas para situar ficheros temporales, se sitúa en RAM para que los programas sean más rápidos. Existe otro en
/usr/tmp.
usr: Acá se encuentran ficheros del sistema.
6
Recorrido por los fuentes del MINIX - /usr/src - /usr/include.
MINIX tiene su código fuente distribuido de la siguiente manera:
/usr/src
boot commands etc fs inet kernel lib mm test tmp tools
boot: Fuentes del sistema de arranque. tmp: Directorio vacio.
commands: Fuentes de los comandos del sistema. tools: Herramientas para construir imágenes de MINIX.
etc: Ficheros del administrador.
fs: Fuentes del sistema de ficheros (FS).
inet: Fuentes para soporte de red.
kernel: Fuentes del administrador de procesos y dispositivos de E/S.
lib: Fuentes de las librerías de las que hace uso MNIX.
mm: Fuentes del administrador de memoria (MM).
test: Fuentes del test para verificar MINIX.
7
Además, hay que mencionar que también hay código fuente en otra ruta, la cual se muestra a
continuación:
/usr/include
ibm minix net sys
Dentro de /usr/include, hay código fuente de cabeceras Posix, sin embargo, también están
presentes cuatro directorios más, los cuales se explican a continuación:
ibm: Fuentes de archivos de cabecera con definiciones especificas para IBM – PC.
minix: Fuentes de archivos de cabecera utilizados por el sistema operativo.
net: Fuentes de archivos cabeceras para soporte de red.
sys: Contiene fuentes con cabeceras Pos adicionales.
De ahora en adelante, nos centraremos en presentar los esquemas del código fuente del sistema
de arranque de MINIX, además las cabeceras estándar de Posix, sin dejar a un lado los esquemas
del código correspondiente al kernel del sistema operativo MINIX, es decir, administración de
procesos, tareas de E/S, administrador de memoria y sistema de ficheros.
8
Sistema de arranque de MINIX
Una vez encendido la PC, lo primero que realiza la BIOS (Basic Input Output System) son una serie
de test para almacenar la información de todos los dispositivos. Una vez hecho esto, la BIOS
escoge la primera unidad de arranque, comprueba que realmente se trata de una unidad de
arranque; en el caso que no lo sea, se prosigue con la siguiente unidad definida como arranque en
la BIOS y así sucesivamente hasta encontrar una que se pueda arrancar. Si ninguna de las unidades
es de arranque, lo más normal es que aparezca un mensaje en pantalla indicando que no se ha
encontrado ninguna unidad de arranque, en tal caso se debe resetear la máquina y elegir
correctamente la/s unidad/es de arranque.
Una característica de MINIX es que no carga directamente el Sistema Operativo, sino un boot
secundario (el monitor, desde el cual se puede modificar el comportamiento del arranque del
sistema: elegir el arranque entre varios Sistemas Operativos, por ejemplo).
A continuación se muestra el esquema del proceso de arranque de MINIX.
BIOS
Masterboot y tabla
de particiones
BootBlock
Boot Monitor
Imagen de MINIX:
Kernel, MM, FS, init
Para un mejor entendimiento del proceso de arranque, se mostrara el pseudocódigo y el código

fuente de los primeros dos archivos utilizados en el proceso de arranque, es decir los
correspondientes a Masterboot y BootBlock.
El orden en que aparecerán los archivos con su código, es el que se sigue cuando el sistema
operativo arranca.
9
Masterboot.s
Se encuentra en el primer sector de la partición de arranque (en la tabla 1 se identifica con el
código de arranque) y solo tiene sentido cuando se trata de seleccionar cual de las cuatro
particiones posibles es la de arranque (una característica del sistema de ficheros Minix es que
permite realizar particiones en los floppy’s, de esta manera se comporta igual que un disco duro y
por tanto tendrá esta estructura).
Pseudocódigo.
Una vez cargado el primer sector en la posición 0x7C00 (la BIOS es quien lo carga), los pasos que
realiza el programa son:
1.- Copiar el código cargado de la posición 0x7C00 a la posición 0x0600 y saltar a esta última
posición (lo hace por seguridad).
2.- Se verifica si se ha pulsado la tecla ALT. Se da la posibilidad de arrancar desde otra unidad.
2.1.- Si está pulsada la tecla ALT, se espera a que se pulse un número de 0-9, que indica el disco
desde el cual se va a proceder la carga del Sistema Operativo.
3.- Una vez se sabe el disco desde el cual se va arrancar (ya sea la unidad por defecto o por que el
usuario ha elegido otra), se realizan los siguientes pasos:
3.1.- Se leen las características de la unidad elegida (cabeza, cilindro y sector si se trata de un disco
duro).
3.2.- Se carga el primer sector físico de la unidad.
3.2.1.- Si existe error, se reintenta la lectura del primer sector 3 veces. Si falla, se muestra un
mensaje en pantalla: ‘Error de lectura’ y se queda en un bucle infinito.
3.2.2.- Si la lectura tiene éxito, el siguiente paso consiste en comprobar si es de arranque:
a) Si no está la firma de arranque, se muestra un mensaje en pantalla: ‘Unidad no iniciable’ y se

queda en un bucle infinito.
b) Si está la firma, se continúa con el programa.
4.- Se salta al código cargado (bootstrap).
10
Código fuente en ensamblador.
BUFFER=0x0600 ; Comienzo de la memoria libre
PART_TABLE=446 ; Localización de la tabla de partición
dentro de este código
PENTRYSIZE=16 ; Tamaño de una entrada de la tabla de
partición
MAGIC=510 ; Localización del número mágico AA55
; <ibm/partition.h>:
bootind = 0
sysind = 4
lowsec = 8
.define begtext, begdata, begbss, endtext, enddata, endbss, _main

.data
begdata:
.bss
begbss:
.text
begtext:
_main:
; Encontrar (sub)partición activa, cargar su primer sector,

ejecutarlo.
master:
jmp over
fix: .data1 0 ;Si 1-9 entonces siempre arrancar ese
dispositivo
over:
xor ax, ax
mov ds, ax
mov es, ax
cli
mov ss, ax ; ds = es = ss = Vector segmento
mov sp, #LOADOFF
sti
mov bp, #BUFFER+PART_TABLE ; Dirección usada a menudo
; Copia este código por seguridad, luego saltar a él.

mov si, sp ; si = comienzo de este código
push si ; también su dirección de retorno
mov di, #BUFFER ; Area del buffer
mov cx, #512/2 ; Un sector
cld
rep
movs
jmpf BUFFER+migrate, 0 ; Por seguridad
migrate:
11
; ¿ Tecla ALT pulsada para ignorar el arranque del dispositivo
activo ?
key:
movb ah, #0x02 ; Desplazamiento del estado del
teclado
int 0x16
testb al, #0x08 ; Bit 3 = tecla ALT
jz noalt ; No pulsada la tecla ALT
call print
.data2 BUFFER+devhd
getkey: xorb ah, ah ; Esperar a pulsar una

tecla
int 0x16
movb BUFFER+choice, al
subb al, #0x30 ; al -= '0'
cmpb al, #10
jae getkey ; La tecla no está en el rango 0 - 9
push ax
call print ; Mostrar la tecla pulsada
.data2 BUFFER+choice
pop ax
jmp override
noalt:
movb al, BUFFER+fix ;¿Siempre arranca una cierta
partición?
testb al, al
jz findactive ; No, arranca la partición
activa
override:
cbw ; ax = partición elegida
movb dl, #5
divb dl ; al = disco, ah = partición dentro de
disco
movb dl, #0x80
addb dl, al ; dl = disco
movb al, ah ; al = partición dentro de disco
push ax ; Grabar partición elegida
call load0 ; Coger el sector 0
jb error0 ; Deshabilitar su lectura
pop ax ; Restablecer la partición elegida
subb al, #1 ; ¿ Fue 0 modulo 5?
jl bootstrap ; Saltar al master bootstrap
mov si, #LOADOFF+PART_TABLE ; si = nueva tabla de
partición
mov di, bp ; Para area de buffer
mov cx, #4*PENTRYSIZE/2
rep
12
movs
addb cl, #4 ; Cuatro veces es suficiente para
ordenar
sort: mov si, bp ; Primera entrada de la tabla
bubble: lea di, PENTRYSIZE(si) ; Siguiente entrada

cmpb sysind(si), ch ; Tipo de partición, en uso
distinta
de cero
jz exchg ; Entradas no usadas ordenar al
final
inuse: mov bx, lowsec+0(di)

sub bx, lowsec+0(si) ; Realizar di->lowsec - si-
>lowsec
mov bx, lowsec+2(di)
sbb bx, lowsec+2(si)
jnb order ; En orden si si-
>lowsec <= di-
>lowsec
exchg: movb ah, (si)

xchgb ah, PENTRYSIZE(si) ; Intercambiar entradas byte
a byte
movb (si), ah
inc si
cmp si, di
jb exchg
order: mov si, di

cmp si, #BUFFER+PART_TABLE+3*PENTRYSIZE
jb bubble
loop sort
mov si, bp ; si = tabla ordenada
movb ah, #PENTRYSIZE
mulb ah ; ax = al * PENTRYSIZE
add si, ax ;si = dirección de la entrada
de la
cmpb sysind(si), #1 ; Debería estar en uso
jb error0
jmp loadpart ; Coger la partición del
bootstrap
; Encontrar la partición activa.

findactive:
testb dl, dl
jge nextdisk ;No particiones en floppys
mov si, bp
13
find: cmpb sysind(si),#0 ;Tipo de partición, en uso distinta
de cero
jz nextpart
testb bootind(si), #0x80 ; Flag de la partición
activa en bit 7
jz nextpart ; No está activa
loadpart:
call load ; Cargar la partición del
bootstrap
error0: jb error1 ; No supuso fallo
bootstrap:
ret ; Saltar al master bootstrap
nextpart:
add si, #PENTRYSIZE
cmp si, #BUFFER+PART_TABLE+4*PENTRYSIZE
jb find
; No partición activa, dimelo

call print
.data2 BUFFER+noactive
; No hay particiones activas en esta unidad, intentar la próxima

unidad.
nextdisk:
incb dl ; Incrementar dl para la próxima
unidad
testb dl, dl
jl nexthd ; Disco duro si negativo
int 0x11 ; Coger la configuración del equipo
shl ax, #1 ; Número de unidad de
floppy más alto en los bist 6-7
shl ax, #1 ; Ahora en los bits 0-1 de ah
andb ah, #0x03 ; Extraer bits
cmpb dl, ah ; Debe ser dl <= ah para que la unidad
exista
ja nextdisk ; En otro caso intentar hd0
eventualmente
call load0 ; Leer el próximo floppy del
bootstrap
jb nextdisk ; Si falló, próximo disco por favor
ret ; Saltar al próximo master
bootstrap
nexthd: call load0 ; Leer el bootstrap del disco

duro
14
error1: jb error ; ¿ No disco?
ret
; Cargar sector 0 desde el dispositivo actual. Es o el floppy del

bootstrap
o un ;disco duro del master bootstrap.
load0:
mov si, bp
mov lowsec+0(si), ds ; Crear una entrada con un
lowsec cero
mov lowsec+2(si), ds
!jmp load
; Cargar el sector lowsec(si) desde el dispositivo actual. Los

número de
cabeza, sector y ;cilindro son ignorados para favorecer de manera
absoluta
el comienzo de la particón.
load:
mov di, #3 ; Tres reintentos para comprobar si
hay floppy
retry: push dx ; Grabar código de la unidad
push es
push di ; La próxima llamada destruye es y di
movb ah, #0x08 ; Código para los parámetros de la unidad
int 0x13
pop di
pop es
andb cl, #0x3F ; cl = número máximo de sector (1-origen)
incb dh ; dh = 1 + número de cabeza máximo (0-origen)
movb al, cl ; al = cl = sectores por pista
mulb dh ; dh = cabezas, ax = cabezas * sectores
mov bx, ax ; bx = sectores por cilindro = cabezas *
sectores
mov ax, lowsec+0(si)
mov dx, lowsec+2(si); dx:ax = sector dentro de la
unidad
div bx ; ax = cilindro, dx = sector dentro de
cilindro
xchg ax, dx ; ax = sector dentro de cilindro,
dx =
cilindro
movb ch, dl ; ch = 8 bits inferiores de cilindro
divb cl ; al = cabeza, ah = sector (0-origen)
xorb dl, dl; Desplazamiento de los bits 8-9 del cilindro

en dl
shr dx, #1
shr dx, #1 ; dl[6..7] = cilindro superior
15
orb dl, ah ; dl[0..5] = sector (0-origen)
movb cl, dl ; cl[0..5] = sector, cl[6..7] =
cilindro
superior
incb cl ; cl[0..5] = sector (1-origen)
pop dx ; Restablecer código de la unidad en dl
movb dh, al ; dh = al = cabeza
mov bx, #LOADOFF ; es:bx = donde se carga el sector
mov ax, #0x0201; Código para leer, unicamente un sector
int 0x13 ; Llamar a la BIOS para una lectura
jnb ok ; Lectura satisfactoria
cmpb ah, #0x80 ; ¿ Timed out del disco? (Floppy
vacío)
je bad
dec di
jl bad ; Recuperar contador expirado
xorb ah, ah
int 0x13 ; Resetear
jnb retry ; Intentar de nuevo
bad: stc ; Poner bandera de acarreo

ret
ok: cmp LOADOFF+MAGIC, #0xAA55

jne nosig ; Error si “firma” erronea
ret ; Retornar con acarreo limpio
nosig: call print

.data2 BUFFER+noboot
jmp hang
; Ha ocurrido error en una lectura, reclamar y bucle infinito.

error:
call print
.data2 BUFFER+readerr
; Bucle infinito esperando por CTRL-ALT-DEL

hang: jmp hang
print: pop si ; dirección de retorno

lods ;ax = *si++ = palabra después de'call
print'
push si ; nueva dirección de retorno
mov si, ax
prnext: lodsb ; al = *si++ es el carácter a imprimir

testb al, al
jz prdone ; Nulo marca fin
movb ah, #14 ; 14 = imprimir
caracter
16
mov bx, #0x0001 ; Página 0, color de primer plano
int 0x10 ; Llamar a la BIOS VIDEO_IO (E/S
de la BIOS)
jmp prnext
prdone: ret
.data
devhd:
choice:
noactive:
readerr:
noboot:
.text
endtext:
.data
enddata:
.bss
endbss:
Bootblock.s
Se instala en el primer sector de la partición, y es el que propiamente carga el Sistema Operativo
(en realidad carga el monitor). En un floppy sin particiones, este código es el que se encuentra en
el primer sector.
Pseudocódigo.
1.- Creación del entorno de trabajo: inicializa ds=ss=ax=0, sp=bp=0x7C00.
2.- Se comprueba si se va a cargar de disco duro o de floppy.
2.1.- Si es un disco duro, se obtienen los parámetros de la unidad y se salta a cargar el boot
secundario.
2.2.- Si es un floppy, hay que determinar que tipo de unidad se trata. El proceso que se sigue es
sencillo, se tiene una variable que contiene los parámetros de las distintas unidades posibles (3.5’’
alta densidad, 3.5’’ baja densidad, 5.25’’ alta densidad y 5.25’’ baja densidad) y se lee el último
sector de la primera pista, si falla la prueba se sigue con la siguiente unidad y así sucesivamente.
Cuando se determina el tipo de unidad, se salta a cargar el boot secundario (monitor).
3.- El monitor se empieza a cargar en la posición 0x1000:0x0000. Se entra en un proceso iterativo:

Mientras queden sectores por leer del monitor:
3.1.- Cargar el sector especificado en la posición de memoria es:bx.
3.2.- Se modifica la próxima posición de memoria: es:bx+512
3.3.- Si existe error, mostrarlo en pantalla y quedarse en un bucle infinito.

17
4.- Cuando están todos los sectores del monitor cargados en memoria, se salta a la posición de
memoria adecuada (0x1000:0x0000) para ceder el control al monitor.
Código fuente en ensamblador.

LOADOFF=0x7C00 ; 0x0000:LOADOFF donde se encuentra este código
BOOTSEG=0x1000 ; Segmento de código del boot secundario
BOOTOFF =0x0030 ; Desplazamiento en el boot secundario por encima
de la cabeza
BUFFER= 0x0600 ; Comienzo de la memoria libre
DSKBASE=0x1E ; Vector de parámetros del floppy
DSKPARSIZE=11 ; 11 bytes de parámetros del floppy
SECTORS=4 ; Desplazamiento en los parámetros de los
sectores por pista
LOWSEC=8 ; Desplazamiento del primer sector lógico en la
tabla de particiones
; Variables direccionadas usando el registro bp

device = 0 ; El dispositivo de arranque
lowsec = 2 ; Desplazamiento de la partición dentro de
la unidad
secpcyl = 6 ; Sectores por cilindro = cabezas * sectores
.define begtext, begdata, begbss, endtext, enddata, endbss, _main

.data
begdata:
.bss
begbss:
.text
begtext:
_main:
; Comienzo del procedimiento de arranque

boot:
xor ax, ax ; ax = 0x0000, el vector de
segmento
mov ds, ax
cli ; Desactiva las
interrupciones mientras inicializa la pila
mov ss, ax ; ss = ds = vector de segmento
mov sp, #LOADOFF ; Lugar usual para la pila del
bootstrap
sti
push ax
push ax ; Pone un cero en lowsec(bp)
push dx ; Dispositivo de arranque
en dl será device(bp)
mov bp, sp ; Usar var(bp) es un byte más
económico que var.
18
push es
push si ; es:si = entrada de la tabla de
partición si disco duro
mov di, #LOADOFF+parameters ; carcáter
(*di)[DSKPARSIZE] = parámetros;
testb dl, dl ; Disco duro si dl >= 0x80
jge floppy
winchester:
; Obtiene el desplazamiento del primer sector de la partición de

arranque desde la tabla de partición. La tabla se encuentra en
es:si, el parámetro lowsec en desplazamiento ;LOWSEC.
eseg
les ax, LOWSEC(si) ; es:ax =
LOWSEC+2(si):LOWSEC(si)
mov lowsec+0(bp), ax ; 16 bits inferiores del primer
sector de la partición
mov lowsec+2(bp), es ; 16 bits superiores del
primer sector de la partición
; Obtiene los parámetros de la unidad, el número de sectores es de

manera terminante escrito en los parámetros del floppy.
movb ah, #0x08 ; Codigo para los parámetros de la

unidad
int 0x13 ; dl aún contiene la unidad
andb cl, #0x3F ; cl = número máximo de sector (1-
origen)
movb SECTORS(di), cl ; Número de sectores por
pista
incb dh ; dh = 1 + número máximo de cabeza
(0-origen)
jmp loadboot
; Floppy:
; Ejecuta 3 tests de lectura para determinar el tipo de unidad.
Prueba para cada tipo de ;floppy mediante la lectura del último
sector de la primera pista. Si esto falla, intenta un ;tipo que
tenga menos sectores. Por lo tanto comenzamos con 1.44M (18
sectores) luego ;con 1.2M (15 sectores) y finaliza con 720K/360K
(ambos con 9 sectores). (Los ;parámetros del floppy de
los dos últimos son iguales, aparte del tiempo de arranque del
motor. Esto nos evita el desagradable test “intentar leer pista
41”).
next: add di, #DSKPARSIZE ; Siguiente conjunto de

parámetros
19
floppy: mov DSKBASE*4+0, di ; Carga el
desplazamiento de los parámetros del disco
mov DSKBASE*4+2, ds ; Carga el segmento de los
parámetros del disco
xorb ah, ah ; Resetea la unidad

int 0x13
movb cl, SECTORS(di) ; cl =

número del último sector de la pista
cmp di, #LOADOFF+dsdd3 ; No necesita hacer
el último test 720K/360K
jz success
; Intenta leer el último sector de la pista 0
mov es, lowsec(bp) ; es = vector segmento (lowsec = 0)

mov bx, #BUFFER ; es:bx buffer = 0x0000:0x0600
mov ax, #0x0201 ; Leer sector, número de sectores =
1
xorb ch, ch ; Pista 0, último sector
xorb dh, dh ; Unidad dl, cabeza 0
int 0x13
jb next ; Error, intentar el próximo tipo
de floppy
success:movb dh, #2 ; Cargar el número de cabezas para

multiplicar
; El número
de sectores está aún en cl
loadboot:
; Carga el código del boot secundario desde el dispositivo de
arranque
movb al, cl ; al = cl = sectores por pista
mulb dh ; dh = cabezas, ax = cabezas *
sectores
mov secpcyl(bp), ax ; Sectores por cilindro =
cabezas * sectores
mov ax, #BOOTSEG ; Segmento para cargar dentro el
código del
;boot secundario mov es,ax
xor bx, bx ; Carga el primer sector
en es:bx = BOOTSEG:0x0000
mov si, #LOADOFF+addresses ; Comienzo de la dirección
del código del boot
load:
mov ax, 1(si) ; Obtiene el próximo número de
sector: 16 bits inferiores
movb dl, 3(si) ; Bits 16-23 para tu disco de 8GB
20
xorb dh, dh ; dx:ax = sector dentro de la
partición
add ax, lowsec+0(bp)
adc dx, lowsec+2(bp); dx:ax = sector dentro de la
unidad
div secpcyl(bp) ; ax = cilindro, dx = sector dentro
del cilindro
xchg ax, dx ; ax = sector dentro del cilindro,
dx = cilindro
movb ch, dl ; ch = 8 bits inferiores del
cilindro
divb SECTORS(di) ; al = cabeza, ah = sector (0-
origen)
xorb dl, dl ; Desplazar los bits 8-9 del
cilindro en dl
shr dx, #1
shr dx, #1 ; dl[6..7] = cilindro superior
orb dl, ah ; dl[0..5] = sector (0-origen)
movb cl, dl ; cl[0..5] = sector, cl[6..7] =
cilindro superior
incb cl ; cl[0..5] = sector (1-origen)
movb dh, al ; dh = al = cabeza
movb dl, device(bp) ; dl = dispositivo para leer
movb al, SECTORS(di) ; Sectores por pista –
Número de sector (0-origen)
subb al, ah ; = Sectores a la izquierda en ésta
pista
cmpb al, (si) ; Compara con
el número de sectores a leer
jbe read ; ¿ No puede leer después del final
del cilindro ?
movb al, (si) ; (si) < sectores a la
izquierda en esta pista
read: push ax ; Guarda al = sectores a leer
movb ah, #2 ; Código para leer disco (¡ todos
los registro se usan ahora ;)
int 0x13 ; Llamar a la BIOS para una lectura
pop cx ; Restaura al en cl
jb error ; Salta al disco para leer un error
movb al, cl ; Restaura al = sectores leídos
addb bh, al ; bx += 2 * al * 256 (suma bytes
leídos)
addb bh, al ; es:bx =donde debe ser leído el
próximo sector
add 1(si), ax ; Actualizar
dirección mediante
adcb 3(si), ah ; No olvidar los
bits 16-23 (sumar ah = 0)
subb (si), al ; Decrementar el
contador de sector por sectores leídos
21
jnz load ; No todos los sectores han sido
leídos
add si, #4 ; Siguiente par (dirección ,
contador)
cmpb ah, (si) ; Hecho cuando no hay
sectores a leer
jnz load ; Lee el siguiente trozo del código
del boot secundario
done:
; Llama al boot secundario, asumiendo una cabecera larga a.out (48

bytes).
La cabecera a.out es normalmente pequeña (32 bytes), pero el boot
secundario tiene dos puntos de ;entrada: Uno es el desplazamiento
0, para la cabecera larga, y el otro es el ;desplazamiento 16 para
la cabecera corta.
; Los parámetros pasados en los registros son:
; dl = Dispositivo del boot

; es:si = Entrada de la tabla de partición si es el disco
duro.
pop si ; Restablecer es:si = entrada en

la tabla de partición
pop es ; dl está aún cargado
jmpf BOOTOFF, BOOTSEG ;Saltar al sector del boot
(saltando a la cabecera).
; Error de lectura: imprimir mensaje, bucle infinito

error:
;mov si, #LOADOFF+errno+1 ; Sin comentarios esto en tiempo
destroso
;prnum: movb al, ah ; Número de error en ah
; andb al, #0x0F ; 4 bits inferiores
; cmpb al, #10 ; ¿A-F?
; jb digit ; 0-9
; addb al, #7 ; 'A' - ':'
;digit: addb (si), al ; Modificar '0' en la
ristra
; dec si
; movb cl, #4 ; Próximos 4 bits
; shrb ah, cl
; jnz prnum ; De nuevo si digit > 0
mov si, #LOADOFF+rderr ; Ristra a imprimir
print: lodsb ; al = *si++ es el carácter a ser

imprimido
22
movb ah, #14 ; 14 = imprimir carácter
mov bx, #0x0001 ; Página 0, color de primer plano
int 0x10 ; Llamar a la BIOS VIDEO_IO (E/S de
la BIOS)
cmp si, #LOADOFF+errend ; ¿ Alcanzado el fin de la
ristra ?
jb print
; Bucle infinito esperando por CTRL-ALT-DEL

hang: jmp hang
.data
rderr: .ascii "Read error "
;errno: .ascii "00 "
errend:
parameters:
; Los parámetros del floppy ordenados de forma decreciente en los
sectores por pista. ;(La longitud de los parámetros de los diskets
de 3.5” podría ser erronea, pero eso no ocurrirá).
; 1.44M 3.5"
dshd3: .data1 0xAF, 0x02, 25, 2, 18, 0x1B, 0xFF, 0x54, 0xF6, 15, 8
; 1.2M 5.25"
dshd5: .data1 0xDF, 0x02, 25, 2, 15, 0x1B, 0xFF, 0x54, 0xF6, 15, 8
; 720K 3.5", también usado por 360K 5.25"

dsdd3: .data1 0xDF, 0x02, 25, 2, 9, 0x2A, 0xFF, 0x50, 0xF6, 15, 8
; Únicamente para completar, aquí están los 360K de parámetros

reales.
;dsdd5: .data1 0xDF, 0x02, 25, 2, 9, 0x2A, 0xFF, 0x54, 0xF6, 15, 3
.text
endtext:
.data
enddata:
addresses:
;El espacio por debajo de esto es para las direcciones de disco
para un programa de boot ;secundario (el peor de los casos, es
decir el fichero está fragmentado). Debería ser suficiente.
.bss
endbss:
23
Esquema de cabeceras del sistema de arranque.
Cabecera Descripción
Información entre
boot.h diferentes partes del
boot.
Información entre
image.h diferentes partes del
boot.
Soporte para el
rawfs.h sistema de ficheros
tipo Raw.
Esquema de archivos fuentes del sistema de arranque.

Fuente Descripción
Boot Monitor, boot

boot.c secundario, carga y
arranca el MINIX.
bootstrap para el
primer sector de la
bootblock.s
partición activa, carga
el boot.
Soporte de la BIOS
boothead.s
para el boot.c.
Carga y ejecuta una

bootimage.c imagen del sistema
operativo.
Soporte de DOS & BIOS

doshead.c
para el boot.c
Instala el sector de arranque

(bootblock), o instala el
installboot.c ejecutable del MINIX (image),
para crear un disco de
arranque.
jumpboot.s Salta a otro bootstrap.
24
Fuente Descripción
Boot master de
masterboot.s arranque para el
primer sector del disco.
Soporte de DOS & BIOS

mkfhead.s
para el mkfile.c
Crea un archivo dentro

mkfile.c de DOS para usar en un
disco MINIX.
Soporte para manejar

rawfs.c un sistema de ficheros
tipo RAW.
Boot master de
extboot.s arranque para
particiones extendidas
de MS-DOS.
Permite modificar
edparams.c parámetros del
sistema.
Los archivos que aparecen con .h y .c, están escritos en lenguaje C, y los archivos con .s están
escritos en ensamblador.
El fichero Makefile de este directorio tiene las órdenes para que se compilen estos programas y se
dejen en los siguientes directorios:
Directorio /usr/mdec contiene los compilados:
 boot
 bootblock
 extboot
 masterboot
Directorio /usr/bin contiene los compilados:
 installboot
 edparams
25
Cabeceras Posix - /usr/include.
En esta parte, se mencionaran los archivos de cabecera estándar Posix, de los que MINIX hace uso.
Esquema de cabeceras Posix - /usr/include.

Describe el formato de
a.out.h los archivos
ejecutables.
alloca.h Función alloca().
Intenta decidir si el
ansi.h compilador se ajusta lo
suficiente a Stándar C.
Contiene una macro a

assert.h
la llamada “assert”.
Configuración genérica
configfile.h
de formato de archivo.
Define algunas macros

ctype.h usadas para identificar
caracteres.
Define macros y
curses.h prototipos para
“curses”.
Declaración para el
dirent.h directorio de lectura de
rutinas.
Define los números de los
diversos errores que pueden
errno.h ocurrir al ejecutarse un
programa.
Se necesita para las

fcntl.h llamadas open() y
fcntl().
Define algunos límites

float.h de implementación
para coma flotante.
26
Usado para las

grp.h llamadas getgrid() y
getgrnam().
Cabecera maestra
lib.h
usada por las librerías.
Define algunos
limits.h
tamaños básicos.
Usado para los símbolos

de dinero, puntos
locale.h
decimales y otros ítems
de estilo local.
Contiene prototipos para

math.h
funciones matemáticas.
Constantes
mathconst.h
matemáticas.
Define ítems para los

pwd.h
archivos de password.
Código derivado del

regex.h software de contribución de
Berkeley.
Usado por las rutinas

regexp.h
regexp().
Usado para escapar de

setjmp.h la situación actual en
una situación previa.
Contiene estructuras
sgtty.h
de datos para ioctl().
Se encarga de un
stdarg.h variable número de
parámetros.
27
Define ciertos macros

stddef.h
normalmente usados.
Definiciones de
stdio.h
entrada/salida.
Define ciertas macros,
stdlib.h tipos y funciones
comunes.
Contiene prototipos
string.g para las funciones que
manejan cadenas.
Usado con el
tar.h
archivador tar.
Define algunos
termcap.h
prototipos.
Usado para controlar

termios.h
los modos tty.
Usado por los

time.h procedimientos que
tratan con el tiempo.
Constantes que
tools.h
describen el disco.
ttyent.h Usado por getttyent().
Contiene constantes
unistd.h
diversas manifiestas.
Usado para la llamada

utime.h
al sistema utime().
Usado por init, login,

utmp.h
who, etc.
Todos estos archivos están dentro del directorio /usr/include. Dentro de este directorio, hay otros,
los cuales se mencionaran a continuación, con sus respectivas cabeceras.
28
Esquema de cabeceras IBM - /usr/include/ibm
Definiciones para el
cmos.h CMOS. Basado en el
Dallas DS12887.
PC BIOS estructura
diskparm.h para los parámetros de
disco.
Tipos de interrupción
int86.h
del 8086.
Descripción de entrada
partition.h en la tabla de
particiones.
portio.h Entrada/Salida.
Esquema de cabeceras NET - /usr/include/net

Convierte a un
hton.h
estándar de red.
Operaciones de control
ioctl.h de dispositivos con
respecto a la red.
netlib.h Librerías de net.
Dentro de este directorio esta otro llamado “gen”, el cual contiene muchas más cabeceras, sin
embargo las mencionadas anteriormente son las más principales.
29
Esquema de cabeceras de MINIX - /usr/include/minix
Define el número de
callnr.h
llamadas.
Contiene algunas
cdrom.h estructuras usadas por
Mitsumi cdrom driver.
com.h Llamadas al sistema.
Números de tarea,
com.h204 códigos de función y
códigos de contestación.
Fija parámetros de
config.h configuración para el
kernel, MM y FS.
Configuración de
config.h204 parámetros para
kernel, MM y FS.
const.h Definición de
constantes.
Definición de
const.h204
constantes.
Estructura usada en
dl_eth.h
DL_GETSTAT.
Soporte de funciones
fslib.h
de/hacia la memoria.
Incluido por cada

ioctl.h archivo del título que
define los códigos del
ioctl.
Para usar con programas en
jmp_buf.h código ensamblador que
necesitan manipular el
jmp_buf.
30
keymap.h Define el mapa.
minlib.h Misceláneos de BSD.
Lugar de una partición

partition.h en disco y la geometría
del mismo.
Definiciones usadas en
sound.h /dev/audio y
/dev/mixer.
Define el superbloque de las
swap.h particiones swap y algunas
constantes usadas.
Prototipos del sistema

syslib.h para funciones de
librerías.
type.h Definiciones de tipos.
Funciones para
u64.h manipular direcciones
de disco de 64 bits.
31
Esquema de cabeceras de SYS - /usr/include/sys
Usado para programas

escritos para MINIX-vmd
asynchio.h
que también deben correr
bajo el estándar MINIX.
Da la organización de
dir.h
un directorio.
Códigos de comando
ioc_disk.h
de disco ioctl().
Códigos de comando
ioc_memory.h
de memoria ioctl().
Códigos de comando
ioc_scsi.h
de scsi ioctl().
Códigos de comando
ioc_sound.h
de sonido ioctl().
Códigos de comando
ioc_tape.h de cinta magnética
ioctl().
Códigos de comando
ioc_tty.h
de terminal ioctl().
Declara operaciones de
ioctl.h
control de dispositivos.
Comandos de cinta
mtio.h
magnética.
Definiciones para
ptrace.h
ptrace().
Es usada por la llamada

sigcontext.h
sigreturn().
Define la estructura
stat.h
que se usa en las
funciones stat() y fstat.
32
Servidor de control de
comandos que tienen
svrctl.h la misma codificación
como las ordenes para
ioctls.
Es para la llamada al
times.h
sistema times().
Contiene definiciones
types.h de tipos de datos
importantes.
Da el nombre del
utsname.h
sistema.
Contiene macros
wait.h relacionados con
wait().
33
Capa 1 - 2 - Administración de procesos / Tareas de E/S -
/usr/src/kernel
Para esta parte, se definirá primeramente que es un kernel, luego pasaremos al microkernel,
seguido de administración de procesos y al final las tareas con los dispositivos de E/S.
Kernel.
Es la parte fundamental de un sistema operativo. Es el software responsable de facilitar a los
distintos programas acceso seguro al hardware de la computadora o en forma más básica, es el
encargado de gestionar recursos, a través de servicios de llamada al sistema. Como hay muchos
programas y el acceso al hardware es limitado, el núcleo también se encarga de decidir qué
programa podrá hacer uso de un dispositivo de hardware y durante cuánto tiempo, lo que se
conoce como multiplexado. Acceder al hardware directamente puede ser realmente complejo, por
lo que los núcleos suelen implementar una serie de abstracciones del hardware. Esto permite
esconder la complejidad, y proporciona una interfaz limpia y uniforme al hardware subyacente, lo
que facilita su uso para el programador.
Microkernel.
Consiste en definir una abstracción muy simple sobre el hardware, con un conjunto de primitivas o
llamadas al sistema que implementan servicios del sistema operativo mínimos, como la gestión de
hilos, el espacio de direccionamiento y la comunicación entre procesos.
El objetivo principal es la separación de la implementación de los servicios básicos y de la política

de funcionamiento del sistema. Por ejemplo, el proceso de bloqueo de E/S se puede implementar
con un servidor en espacio de usuario ejecutándose encima del micronúcleo. Estos servidores de
usuario, utilizados para gestionar las partes de alto nivel del sistema, son muy modulares y
simplifican la estructura y diseño del núcleo. Si falla uno de estos servidores, no se colgará el
sistema entero, y se podrá reiniciar este módulo independientemente del resto.
Administración de procesos.
Un proceso no es más que un programa en ejecución, e incluye los valores actuales del contador
de programa, los registros y las variables.
En MINIX la parte encargada de gestionar dichos procesos es el Administrador de procesos, que es

la primera de las cuatro capas que componen este sistema operativo. Las funciones que ofrece
esta capa son las siguientes:
 Atiende las interrupciones.
 Guardar y restaurar registros.
34
 Planificación de tareas y procesos.
 Verifica que los destinos sean validos.
 Copiar bytes del emisor al receptor.
Tareas de E/S.
Una de las principales funciones de un sistema operativo es controlar todos los dispositivos de E/S
(entrada/salida) de una computadora. El sistema operativo debe enviar comandos a los
dispositivos, detectar interrupciones y manejar errores; también debe proveer una interfaz entre
los dispositivos y el resto del sistema que sea sencilla y fácil de usar. Se debe tratar al máximo que
la interfaz sea la misma para todos los dispositivos (independencia respecto al dispositivo).
En MINIX la parte encargada de gestionar dichas tareas es la segunda capa, Los procesos E/S y sus
respectivos drivers son:
 Memoria.
 Discos.
 Impresora.
 Terminal.
 Reloj.
De acá en adelante, se mostrara el esquema de las cabeceras utilizadas por ambas capas, así como
también los fuentes correspondientes a dichas capas (es decir, capas 1 y 2).
35
Esquema de cabeceras del Administrador de Procesos / Tareas de E/S
Comparación y
afirmación de
assert.h
resultados de los
procedimientos.
Constantes generales
const.h
que utiliza el núcleo.
Variables globales que
glo.h
se utilizan en el núcleo
Ésta es la cabecera
maestra del kernel;
kernel.h incluye algunos otros
archivos y define las
principales constantes.
proc.h Tabla de procesos.
Aquí se crean los

proto.h Prototipos de
funciones.
Misceláneo de
sconst.h constantes utilizadas
por el ensamblador
Definición de tipos,
type.h
tasktab, stakframe_s.
Constantes para modo

protect.h
protegido.
Constantes diversas
sconst.h empleadas en código
ensamblador.
Definiciones de
drvlib.h controlador de
dispositivos IBM.
36
Tipos y constantes
compartidos entre el código
driver.h de controlador de
dispositivos genérico Y
dependiente del dispositivo.
Utilizados por los

sb16.h drivers de
SoundBlaster.
dp8390.h Control de interfaz de

NS DP8390 Network.
ne2000.h Cabecera del

manejador de red
wdeth.h Western Digital Plus o

WD800E3.
37
Esquema de archivos fuentes del Administrador de Procesos.
Fuente Descripción
Elige entre las

versiones 8086 Y 386
mpx.s
del código de arranque
de Minix.
Manejo de
mpx386.s interrupciones para
386 o superior.
Manejador de las
mpx88.s
interrupciones para 86.
Contiene el código de inicio

en C para Minix en
start.c procesadores Intel; coopera
con mpx.s para establo buen
entorno para main().
Driver para el chip

i8259.c i8259 controlador de
interrupciones.
Este archivo contiene

un manejador de
exception.c excepciones sencillo,
interrupciones de la
CPU.
Contiene código para

inicializar el modo
protegido, los descriptores
protect.c de segmentos de código y
de datos, y los descriptores
globales.
Escoge entre versiones

klib.s 8086 y 386 de código
de kernel de bajo nivel.
38
Fuente Descripción
Procedimientos
klib386.s utilizados por
mpx386.s
Procedimientos
klib88.s utilizados por mpx88.s

proc.c casi todo el manejo de
procesos y mensajes.
Contiene el vector de
table.c
tareas.
39
Esquema de archivos fuentes de Tareas de E/S.

main.c el programa principal
de MINIX.

interfaz de control de
driver.c
independencia de
dispositivos.
Parte dependiente de
dispositivo de disco
esdi_wini.c
duro de controlador
para ibm/pc.
Funciones de utilería
drvlib.c de controlador de
dispositivos IBM.
Driver de memoria
memory.c
principal.
floppy.c Driver de floppy.
Driver de disco duro,

wini.c escoge controlador
winchester.
Driver de un disco duro

xt_wini.c
tipo XT.
Driver para el disco

at_wini.c
duro IBM-AT.
Driver para disco duro

bios_wini.c
que utiliza la BIOS.
Manejador de disco
aha_scsi.c
duro scsi
Driver para el disco

ps_wini.c
duro de un ps.
40
Este archivo contiene rutinas de

dmp.c vaciado para depuración.
Manejador para un
mcd.c
CDROM.
Driver del reloj. Inicializa la
tarea de reloj para Obtener
clock.c trabajo, procesarlo y veces
responder.
Driver para un terminal

tty.c
tty.
Manejador para un
pty.c
seudo terminal.
Driver para el terminal

console.c
consola de IBM.
Driver para el teclado
keyboard.c
ya sea PC o AT.
Driver para los puertos

rs232.c
seriales rs232 en C.
Driver para la
printer.c
impresora.
ne2000.c Manejador de red.
Esta tarea maneja la

interfaz entre el sist.
system.c arch. y el kernel y entre el
administrador de
memoria y el kernel.

una colección de
misc.c
procedimientos
diversos o misceláneos
41
Fuente Descripción
Driver para DSP en una

sb16_dsp.c tarjeta de sonido
SoundBlaster 16.
Driver para mixer en
sb16_mixer.c una tarjeta de sonido
SoundBlaster 16.
Contiene controlador de
dp8390.c dispositivo Ethernet para
dispositivos dp8390.
Controlador para
wdeth.c Western Digital Plus o
WD800E3.
Todos los archivos que se han mencionado, están en la ruta siguiente:
/usr/src/kernel
Estos archivos se encuentran a partir de la línea 4,200 correspondiente al archivo kernel.h, y

finaliza en la línea 15,575 correspondiente al archivo system.c, estos archivos están dentro de la
ruta mencionada anteriormente.
42
Capa 3 - Administrador de Memoria (MM) - /usr/src/mm.
El administrador de la memoria conserva una lista de huecos ordenada en secuencia de
direcciones de memoria. Cuando se necesita memoria debido a una llamada al sistema FORK o
EXEC, se busca en la lista de huecos utilizando el Algoritmo FIRST FIT (se elige el primer hueco libre
lo suficientemente grande). Una vez que un proceso se ha colocado en la memoria, éste
permanece exactamente en el mismo sitio hasta que termina. Nunca se intercambia ni se mueve a
otro sitio de la memoria. Tampoco crece ni se comprime el área asignada.
El retiro del administrador de la memoria del Kernel es un ejemplo de la separación de política y

mecanismo. Las decisiones acerca de qué proceso se colocará en qué sitio de la memoria (política)
son tomadas por el administrador de la memoria. La colocación real de mapas de memoria para
los procesos (mecanismo) es realizada por la tarea del sistema contenida en el Kernel. Esta división
facilita en forma relativa el cambio de la política de la administración de la memoria (algoritmos,
etc.) sin tener que modificar los estratos inferiores del sistema operativo.
Funcionamiento del MM.

Al igual que todos los otros componentes del MINIX, el administrador de memoria es impulsado
por mensajes. Después de que el sistema se ha inicializado, el administrador de memoria entra en
su ciclo central, el cual consta de:
 Espera por un mensaje.
 Ejecución de la solicitud contenida en el mensaje.
 Emisión de una contestación.
Tipos de mensajes
Relacionados con la asignación y desasignación de la memoria.
 FORK, EXIT, WAIT, WAITPID, BRK, EXEC.
Pueden afectar al contenido de la memoria (una señal que elimina un proceso también provoca
que su memoria sea desasignada).
 KILL, ALARM, PAUSE, SIGACTION, SIGSUSPEND, SIGPENDING, SIGMASK, SIGRETURN
Con efectos en todo el Sistema Operativo, (pero su primera tarea es enviar señales para terminar
todos los procesos de forma controlada).
 REBOOT
43
No afectan al manejo de la memoria, (pero tienen que ir en el sistema de archivos o en el
administrador de memoria, ya que cada llamada al sistema es manejada por uno u otro; y el
sistema de archivos ya era bastante grande).
 GETUID, GETGID, GETPID, SETUID, SETGID, SETSID, GETPGRP, PTRACE.
Utilizado por el Kernel para informar al administrador de memoria de una señal que se origina en
el Kernel (no es una llamada al sistema).
 KSIG
La principal estructura algorítmica tanto de los procesos MM como de FS es la siguiente:
Inicialización
while (TRUE)
{
Recibir un mensaje
Ejecutar el procedimiento adecuado
Devolver una respuesta si es necesario
}
El administrador de memoria tiene dos estructuras de datos principales:
 Tabla de Procesos (mproc)
 Tabla de Huecos (HOLE)
44
Esquema de cabeceras del Administrador de Memoria.
Constantes utilizadas
const.h por el administrador
de memoria.
Declaración de
glo.h
variables globales.
Cabecera principal del

mm, incluye algunos
mm.h otros archivos y
definiciones de las
principales constantes.
Esta cabecera contiene
mproc.h
la tabla de procesos.
Sinónimos para las

param.h variables de los
mensajes de entrada.
Definición de funciones
proto.h
prototipo.
Acá se encuentran las

definiciones de tipos
type.h locales, normalmente
esta cabecera está
vacía.
45
Esquema de archivos fuentes del Administrador de Memoria.
Fuente Descripción
Acá se encuentra el
programa principal de
main.c
la administración de
memoria
Se encuentra la tabla
para mapear el
table.c número de llamada
con rutina que la
realiza.
Aquí está la tabla de

huecos, la cual es
alloc.c
utilizada para los
espacios en blanco.
Desde este archivo se
realizan las llamadas al
forkexit.c sistema FORK, EXIT,
WAIT y WAITPID.
La llamada al sistema
exec.c EXEC está definida
dentro de este archivo.
Cuando se necesita
más memoria, se hace
break.c esta llamada, para
obtener espacio entre
pila y datos.
Este archivo maneja las

señales, por ejemplo
signal.c
KILL, REBOOT, ALARM,
etc.
Contiene diferentes
rutinas utilizadas por el
utility.c MM, estas son: allowed,
no_sys, panic y tell_fs.
46
Fuentes Descripción
Contiene la función
do_getset(), la cual
gestiona llamadas para
getset.c
leer y escribir distintos
tipos de
identificadores.
Las funciones
contenidas en este
trace.c archivo son:
do_trace(), findproc y
stop_proc.
Dentro de este archivo

se encuentran las
misc.c
funciones: do_reboot y
do_svrctl.
Sirve para la impresión

de mensajes, por
putk.c
medio de las rutinas
putk() y flush().
Todos los archivos que se han mencionado, están en la ruta siguiente:
/usr/src/mm
Estos archivos se encuentran a partir de la línea 15,800 correspondiente al archivo mm.h, y finaliza
en la línea 19,346 correspondiente al archivo putk.c, estos archivos están dentro de la ruta
mencionada anteriormente.
47
Capa 3 - Sistema de Ficheros (FS) - /usr/src/fs.
Sistema de ficheros en MINIX.

Un sistema de archivos MINIX se puede almacenar en cualquier dispositivo de bloques, como un
disco flexible o una partición de un disco duro. En todos los casos el sistema de archivos tiene la
misma estructura. La siguiente figura muestra este esquema para un disco flexible de 360K con
127 nodos-i y un tamaño de bloque de 1K. Los sistemas de archivos mayores o bien aquellos con
más o menos nodos-i o un tamaño de bloque diferente tienen las mismas 6 componentes en el
mismo orden, aunque sus tamaños relativos pueden ser distintos.
Bloque de arranque
Cada sistema de archivo comienza con un bloque de arranque, el cual ocupa siempre un sólo
bloque. Sólo es necesario en el disco boot del sistema, sin embargo, con el fin de mantener
uniforme la estructura del sistema de archivos, todos los dispositivos tienen uno aunque no se
utilice. Para identificar el bloque que contiene código ejecutable del que no, existe un número
mágico que se sitúa en una posición conocida del bloque. El código de la BIOS al cargar este
bloque comprueba que ése número es válido.
Superbloque
Ocupa un solo bloque. Contiene información relativa al tamaño de las distintas partes del sistema
de archivos.
Mapa de bits de los nodos-i
Se utiliza para llevar el control de los nodos-i libres y ocupados. Por cada nodo-i existe un bit en
dicha tabla que indica su estado. Si el bit es 0 significa que el nodo-i está libre, en caso contrario
quiere decir que está ocupado.
48
Mapa de bits de zonas
Se utiliza para llevar el control de las zonas de datos. Su funcionamiento es idéntico al del mapa de
bits de los nodos-i.
Nodos-i
Son estructuras de 64 bytes (32 bytes en la versión 1 del sistema de ficheros) en las que se
encuentra información de cada fichero físico existente en el sistema de archivos, principalmente la
relativa a la situación de las zonas de datos de dicho fichero. El número de bloques necesarios para
almacenar los nodos-i depende del número de nodos-i. Por ejemplo, para 128 nodos-i se necesitan
8 bloques de 1K.
Datos
Es el conjunto de bloques que se utiliza para el almacenamiento de los ficheros.
Funcionamiento del sistema de ficheros.

El archivo MAIN.C contiene el programa principal del "sistema de ficheros", el cual se inicializa una
vez que lo hayan hecho el kernel y el MM (recordemos que ambos, una vez inicializados, quedan
bloqueados a la espera de un mensaje).
El bucle principal del procedimiento es semejante al del manejador de memoria y al de las tareas
de E/S. Mediante la llamada a GET_WORK, espera a que le llegue un mensaje de solicitud de
servicio. Una vez recibido, actualiza la variable global who, que nos va a indicar qué proceso
(dentro de la tabla de procesos) realiza la llamada al FS y fs_call que nos informa del nº de la
llamada del FS a efectuar. La variable who servirá como entrada, una vez retornado al programa
principal, a la tabla de procesos (fproc), donde se comprobará si es superusuario o no
(super_user).
Seguidamente se colocará don't_reply a falso, lo que indica que a no ser que se especifique lo
contrario se enviará respuesta al solicitante de la llamada (un caso en el que se inhibe la respuesta
es en el proceso de revivir, en el que los procesos son despertados por el manejador de tareas y a
éste nunca se le envía respuesta).
A continuación realiza la llamada, empleando fs_call como índice al vector de punteros de

procedimientos call_vector (el cual maneja los distintos tipos de mensaje).
Las llamadas manejadas por el FS son:
exit, fork, revive, setuid, setgid. chmod, chown, umask, acces.
mount, umount. link, unlink, rename.
sync, dup, fcntl. pipe, unpause.

49
ioctl. read, write.
creat, mknod, open, close, lseek. time, utime, stime, times.
chdir, chroot, stat, fstat.
Una vez efectuada dicha llamada, si la variable don't_reply no ha sido modificada, se envía una
respuesta.
Para finalizar con este procedimiento, se hará una llamada al READ_AHEAD (read.c), para permitir
leer un bloque en el pool antes de que se necesite con el fin de mejorar el rendimiento. (Esta
operación se efectuará después de enviar la respuesta de manera que el usuario podrá continuar
la ejecución, aunque el sistema de archivos tenga que esperar un bloque de disco para realizar la
lectura anticipada).
50
Esquema de cabeceras del Sistema de Ficheros.
Cache de bloques
buf.h (buffers) del sistema de
ficheros.
Definición de
constantes utilizadas
const.h
por el sistema de
ficheros.
Tabla de dispositivos,
enlaza el número
dev.h
mayor con la rutina
que lo procesa.
Acá se encuentra la
tabla filp,
file.h intermediario entre
descriptores de
ficheros e i – nodos.
En esta cabecera se
fproc.h encuentra la tabla de
procesos.
Cabecera maestra del fs,

incluye algunos otros
fs.h
archivos y define las
constantes principales.
Las variables globales

glo.h para el fs se
encuentran aquí.
Contiene la tabla de los

inode.h
i – nodos.
lock.h Contiene la tabla de

candados.
Sinónimos de las
param.h variables de los
mensajes de entrada
51
Acá se encuentran los

proto.h prototipos de
funciones.
En esta cabecera se
super.h encuentra la tabla de
superbloques.
Acá se encuentran las
type.h definiciones de los
tipos.
52
Esquema de archivos fuente del Sistema de Ficheros.
Fuente Descripción
Acá se encuentra el
main.c programa principal del
sistema de archivos.
Relaciona el número
de llamada al sistema
table.c
con la función que lo
maneja.
Las funciones
respectivas para abrir,
open.c
crear, cerrar ficheros
están acá.
Este archivo es un
complemento para la
write.c escritura de ficheros,
ya que incluye
funciones específicas.
Sirve para la creación de

una tubería, así como
pipe.c también tiene que ver
con la suspensión y
reanimación de procesos.
Busque de trayectorias
path.c (rutas) en los
directorios.
Las funciones del

montado y
mount.c desmontado de
dispositivos esta en
este archivo.
Este archivo es el
link.c encargado de enlazar y
desenlazar ficheros.
53
Fuente Descripción
Sirve para el cambio de

un directorio a otro, ya
stadir.c
que tiene las llamadas
correspondientes.
Contiene las llamadas

protect.c al sistema para la
protección de ficheros.
Conjunto de procedimientos, de
los cuales algunos realizan
llamadas al sistema simples y
mis.c otros realizan una parte de
algunas llamadas al sistema que
efectúa que el mm.
Lee bloques de disco

device.c que no están en el
buffer.
Maneja la tabla de i –
inode.c
nodos.
Maneja la tabla de
super.c
superbloques.
Contiene tres
funciones para
filedes.c manipular los
descriptores de
archivos.
Contiene dos funciones

lock.c para el bloqueo de
ficheros.
Mantiene un buffer
cache.c para reducir el acceso
al disco.
Indica los procedimientos

que se encargan de
cache2.c manejar cache de
segundo nivel en disco
RAM.
54
Fuente Descripción
Contiene las llamadas

time.c relacionadas con el
tiempo.
Contiene rutinas de
utility.c
utilidad general.
Utilizado para exhibir

putk.c
mensajes del fs.
Todos los archivos de los que se ha hecho mención en los esquemas anteriores, están dentro de la
ruta siguiente:
/usr/src/fs
Estos archivos empiezan en la línea 19,400 con el archivo fs.h y terminan en la línea 27,646 con el
archivo putk.c, estos archivos están dentro de la ruta mencionada anteriormente.
55
Recomendaciones.
Las siguientes recomendaciones van encaminadas a todo aquel que desee utilizar MINIX, ya sea en
maquinas virtuales o directamente en alguna computadora.
 Usar el sistema operativo MINIX solo como una herramienta pedagógica, ya que esta es su
finalidad, por lo tanto no es lo suficientemente robusto como para ser usado de otra
manera.
 No utilizar más de 32 MB de RAM y 512 MB de disco duro, ya que esto sería un
desperdicio de recursos (refiriéndose a la versión 3 del MINIX).
 No utilizar más de 64 MB de RAM y 1GB de disco duro, ya que esto sería un desperdicio de
recursos (refiriéndose a la versión 3 del MINIX).
 Hacer las modificaciones al código fuente, para comprender como esto afecta al sistema
operativo en general.
 Estudiar cada una de sus capas, para comprender como se comunican entre sí por medio
de los mensajes.
 Analizar el sistema de arranque de MINIX, para comprender como se inicializa un sistema
operativo.
56
Anexos.
En esta parte del documento, se explican las respectivas implementaciones de MINIX en los
siguientes entornos de trabajo:
 MINIX implementado sobre VirtualBox:

o MINIX 2 sobre la maquina virtual VirtualBox corriendo en GNU/Linux.
o MINIX 3 sobre la maquina virtual VirtualBox corriendo en GNU/Linux.
o MINIX 2 sobre la maquina virtual VirtualBox corriendo en Windows.
o MINIX 3 sobre la maquina virtual VirtualBox corriendo en Windows.
 MINIX implementado sobre VMWare:
o MINIX 2 sobre la maquina virtual VMWare Player corriendo en Windows.
o MINIX 3 sobre la maquina virtual VMWare Workstation corriendo en Windows.
 MINIX 3 sobre una maquina directamente.
Dichas implementaciones incluyen los manuales de instalación de las maquinas virtuales (en las
que aplica), la configuración de dichas maquinas, así como los pasos respectivos para la instalación
de MINIX en esas maquinas.
Luego se explican algunos problemas que se dan luego de la instalación de MINIX, así como sus
respectivas soluciones.
Además se incluye un manual de usuario de MINIX, con los comandos más usados (no se incluyen
todos los comandos, sino más bien los más comunes, que son los que más se utilizan).
Para finalizar se presenta un manual sobre como compilar MINIX, además como cambiar los
parámetros del boot monitor, también los pasos a seguir para empezar a cambiar código fuente
de MINIX y generar las respectivas imágenes, esto incluye un manual sobre el editor de textos
ocupado para el cambio de código fuente.
57
Manual de instalación de VirtualBox sobre el sistema operativo
GNU/Linux.
En nuestro caso, se explicara como instalar en Debian Lenny (testing), el cual al momento de la
creación del manual se encontraba utilizando el kernel 2.6.26 – 1 – 686; la versión de VirtualBox es
la 2.0.4.
 Descargamos la versión correspondiente al sistema operativo donde instalaremos nuestra

maquina virtual, en nuestro caso la correspondiente a Debian Lenny, para eso nos vamos a
la siguiente dirección: http://www.virtualbox.org/wiki/Downloads
 Acá seleccionamos el sistema operativo para descargar nuestro instalador (en nuestro
caso nos vamos a la sección de Linux, y luego seleccionamos el correspondiente a nuestra
distribución, es decir Lenny).
 El archivo descargado en nuestro caso se llama “virtualbox-2.0_2.0.4-
38406_Debian_lenny_i386.deb”, esto dependerá del archivo descargado.
 Al hacer doble clic sobre este archivo, aparecerá que requiere de la instalación de doce
paquetes.
 Si hacemos clic en “Detalles”, nos aparecerán los paquetes que hay que instalar.
58
 Estos son los paquetes a instalar: libqt4-sql, libqt4-script, qt4-qtconfig, libqt4-qt3support,
libqtcore4, libqt4-sql-mysql, libqt4-dbus, libqt4-designer, libqt4-network, libqt4-xml,
libqtgui4 y libaudio2.
 En nuestro caso, al hacer clic en “instalar”, no se instalo, por ese motivo nos salimos de
acá, y fuimos a la consola, luego tecleamos lo siguiente, eso sí, como usuario root:
 Con esto, estamos instalando los paquetes que hacen falta para satisfacer las
dependencias.
 Empezara a descargar los paquetes correspondientes, luego los configurara.
59
 Después de todo esto, ya tendremos instalados los paquetes necesarios para instalar el
VirtualBox.
 Ahora, si volvemos a hacer doble clic sobre el instalador del VirtualBox, ya aparecerá que
se satisfacen todas las dependencias.
 Como se había hablado anteriormente, al hacer clic en “Instalar paquete” no lo hace, por
eso, nos vamos como root en consola hasta la ubicación del paquete y lo instalamos con
dpkg.
60
 Creara el grupo “vboxusers”, a lo cual solamente presionamos Enter.
 Después de esto, la instalación habrá finalizado.
 Nuestro usuario debe añadirse al grupo creado anteriormente para poder usarlo. Para
esto, nos vamos a consola, y escribimos lo siguiente:
61
 En la parte “nombre_de_tu_cuenta” vamos a digitar el nombre de nuestra cuenta, en
nuestro caso particular, nuestra cuenta se llama “guillermo”, la siguiente imagen muestra
lo que hay que digitar para que la operación se complete satisfactoriamente.
 Ahora, ya estamos listos para correr nuestro VirtualBox, para esto hay dos opciones, la
primera es presionar la combinación de teclas Alt-F2, y digitar “VirtualBox”.
 La otra opción es reiniciar sesión, y luego al irnos al menú Aplicaciones – Herramientas del
Sistema – Sun xVM VirtualBox, con esto, estaremos entrando a la maquina virtual.
 En cualquiera de los casos, al ingresar nos aparecerá lo siguiente, a lo cual tenemos que
irnos hasta la parte de abajo de la licencia y clic en “Estoy de Acuerdo”.
62
 Nos pedirá que nos registremos, en este caso cancelamos.
 Ahora ya estamos dentro del VirtualBox, solamente nos queda empezar a configurarlo
dependiendo del sistema operativo a instalar.
63
Manual de instalación de MINIX 2 en la maquina virtual VirtualBox
corriendo sobre GNU/Linux.
La maquina virtual en nuestro caso está instalada en Debian Lenny (testing).
Los requisitos de software para correr MINIX 2 son los siguientes:
 PC-386-486-Pentium.
 2MB de RAM.
 30MB de disco duro.
 Disquetera.
 Video CGA, EGA, VGA.
Estos requisitos son para sistemas de 32 bits.
Ahora van los pasos para instalar el sistema en una maquina virtual, es posible que los pasos no
sean iguales de una versión de maquina virtual a otra.
 Obtener el archivo “minix204vmwp01.zip”, descargándolo de la siguiente dirección:

http://minix1.woodhull.com/pub/demos-2.0/VMWarePlayer/minix204vmwp01.zip (el
archivo es realmente pequeño, no llega a los 10 MB).
 Ahora, lo descomprimimos, para esto, solamente hacemos clic derecho sobre el archivo y
seleccionamos la opción “Extract here”.
 Mover la carpeta recién generada a la ubicación donde queramos que se aloje, hay que
saber que en esta ubicación quedaran creados todos los archivos que utilizara el sistema,
así que no hay que moverlo una vez se haya instalado en la maquina virtual.
 Una vez instalada la maquina virtual, ingresamos a esta por medio de Aplicaciones –
Herramientas del sistema – Sun xVM VirtualBox, o bien con la combinación de teclas Alt-
F2, luego digitando “VirtualBox” y Enter.
64
 Ya dentro de este, nos aparecerá la siguiente pantalla:
 Acá, nos vamos a la opción “Nueva, luego nos aparecerá el siguiente asistente para
creación de maquinas virtuales, hacemos clic en “Next >”.
 Damos un nombre a nuestra maquina donde instalaremos el MINIX, en nuestro caso

digitamos “MINIX 2”, en el tipo de OS seleccionamos Other/Unknown, luego “Next >”.
65
 Seleccionamos el tamaño de memoria RAM a asignar al MINIX, en nuestro caso le dejamos
32 MB, aunque es posible que funcione con menos, como se ha visto en los requisitos de
dicho sistema operativo.
 Esta parte es de la asignación de un disco duro para la maquina virtual, en nuestro caso,
como la imagen del MINIX que hemos bajado ya está preparada para ser utilizado en una
maquina virtual, utilizaremos esta, esto a pesar de que dicha imagen esta creada para
poder ser utilizada exclusivamente ya sea por VMware Workstation o Player. Gracias a la
compatibilidad de VirtualBox para poder utilizar imágenes de VMware, podremos llevar a
cabo esto, para eso hacemos clic en el botón “Existente…”.
66
 Aparecerá otra ventana, en esta hacemos clic en el botón “Agregar”.
 Buscamos el archivo imagen de VMware, el cual es de extensión .vmdk, este lo

encontraremos en la ubicación donde hayamos dejado el archivo que descomprimimos , el
cual es el que se mencionaba al principio del manual, luego de haberlo hallado hacemos
doble clic izquierdo sobre dicho archivo.
67
 Ahora bien, volveremos a la ventana anterior, pero ahora ya aparecerá dicha imagen,
tenemos que hacer clic en “Seleccionar”.
 Volveremos a la ventana anterior de la creación de la maquina virtual, pero ahora si

aparecerá un disco duro, el cual será el que acabamos de seleccionar, tenemos que hacer
clic en “Next >”.
68
 Nos aparecerá un resumen sobre la maquina virtual que se creara, hacemos clic en
“Finish”.
 Con esto ya se habrá creado la maquina virtual para MINIX 2, observaremos que aparecerá
en el estado de “Apagada”.
69
 Para iniciarla, solamente hacemos clic en el botón “Iniciar”, con lo cual se iniciara el
sistema.
 Ahora bien, presionamos el botón = (igual) para iniciar MINIX, con lo cual observaremos lo
siguiente:
70
 Ahora nos logueamos como root.
 Con esto, ya estamos dentro de MINIX 2, con lo cual concluimos nuestro manual sobre la
instalación de MINIX 2 en VirtualBox corriendo sobre GNU/Linux. Si nos damos cuenta, no
se configuro casi nada, esto es porque esta imagen de MINIX ya viene configurada, por tal
motivo no es necesario realizar modificaciones para hacerlo funcionar, lo único es la
asignación de la memoria RAM.
71
Configuración de VirtualBox corriendo sobre GNU/Linux para la
instalación de MINIX 3.
La maquina virtual en nuestro caso está instalada en Debian Lenny (testing).
 Una vez instalada la maquina virtual, ingresamos a esta por medio de Aplicaciones –
Herramientas del sistema – Sun xVM VirtualBox, o bien con la combinación de teclas Alt-
F2, luego digitando “VirtualBox” y Enter.
72
 Ingresamos la cantidad de memoria RAM a asignar, en nuestro caso con lo que nos ofrece
la maquina es suficiente (64 MB), sin embargo es opcional, pero no hay que dejarle menos
de 16 MB, ni tampoco más de 128 MB, ya que sería un desperdicio, luego “Next >”.
 Ahora está la selección del disco duro virtual, si tenemos uno lo podemos seleccionar,
pero en nuestro caso como no tenemos uno, nos vamos a la opción “Nuevo...”.
73
 Nos aparecerá un nuevo asistente de creación de discos duros virtuales, hacemos clic en
“Next >”.
 Tenemos dos opciones: “Imagen de expansión dinámica” y “Imagen de tamaño fijo”. Más
adelante le vamos a asignar un tamaño al disco duro virtual que estamos creando. Esta
fase es para especificar si queremos que se ocupe ya todo ese espacio que vamos a
reservar (segunda opción), o que ocupe lo necesario según vayamos instalando y vaya
creciendo según se vaya necesitando. Podemos elegir la opción que queramos, en nuestro
caso elegimos “Imagen de expansión dinámica”.
74
 En esta fase vamos a decirle dónde va a guardar esa imagen (por defecto en
“/home/tu_cuenta/.VirtualBox/VDI/” y cómo se va a llamar dicho fichero (por defecto
igual que la máquina virtual, “MINIX 3” en nuestro ejemplo). Si no hay problema de
espacio en nuestro /home, recomendamos dejarlo como está, así como su nombre para
saber de qué sistema es ese disco duro virtual en caso de que instalemos más de uno.
Finalmente le damos el tamaño del disco duro. Con 1 GB tendremos suficiente para MINIX.
Si queremos podemos asignarle más o menos espacio, pero no menos de 50 MB, ni más
de 4 GB, en nuestro caso queda con 1 GB y luego “Next”.
 Nos muestra un resumen en lo referente al disco duro virtual. Si está todo en orden le
damos a “Finish”, en caso contrario volvemos “< Back” y cambiamos lo que queramos.
75
 Nos ha devuelto a la sección donde estábamos en el primer asistente. Ya hemos creado el
disco duro virtual y está seleccionado (”MINIX 3.vdi”), luego clic en “Next >”.
 Un nuevo resumen, en esta ocasión del primer asistente, el global. Al igual que antes, clic
en “Finish” para finalizar si está todo en regla o “< Back” para cambiar algo.
 Ahora nos aparecerá la siguiente pantalla:
76
 Con esto ya hemos creado la maquina virtual para MINIX, ahora nos queda configurar los
parámetros necesarios, para esto hacemos clic en “Configuración”.
 En esta parte como se puede apreciar, podemos configurar la RAM, memoria de Video,
nombre y tipo de sistema, pero en nuestro caso nos iremos a la pestaña “Avanzado”.
77
 Como se puede observar, podemos configurar la secuencia de booteo, en nuestro caso
eliminamos el disquette, y dejamos intacto lo demás.
 Ahora nos vamos a las opciones de la izquierda, y seleccionamos “CD/DVD-ROM”, luego

marcamos la casilla “Montar la unidad de CD/DVD”. Ahora bien, tenemos dos opciones,
seleccionar la unidad lectora si es que vamos a instalar desde el CD de instalación, o bien
seleccionar una imagen “ISO” que tengamos del disco de instalación, en nuestro caso
como disponemos de la imagen ISO seleccionamos dicha imagen; lo más recomendable es
que cuando descargamos la imagen de instalación de MINIX, obtenemos una ISO,
entonces deberíamos de seleccionar esa imagen para evitarnos tener que quemar dicha
imagen, sin embargo esto es opcional.
78
 Con esto, todo estará configurado, solamente hacemos clic en “Aceptar”.
Con esto, ya estamos listos para instalar MINIX en nuestra maquina virtual.
79
Instalación de MINIX 3 en la maquina virtual VirtualBox corriendo
sobre GNU/Linux.
En nuestro caso VirtualBox está instalado sobre la distribución Debian Lenny (testing).
 Primeramente descargamos la última versión de MINIX estable del siguiente enlace:

http://www.minix3.org/download/IDE-3.1.2a.iso.zip, el archivo descargado tendrá como
nombre en nuestro caso “IDE-3.1.2a.iso.zip”.
 Ahora, lo descomprimimos, para esto, solamente hacemos clic derecho sobre el archivo
recién descargado y seleccionamos la opción “Extraer aquí”, empezara a descomprimir el
archivo.
 Obtendremos una imagen ISO con el nombre “minix3_1_2a_ide_build2.iso”.
 Ahora tenemos dos opciones, la primera es utilizar directamente la imagen ISO con la
maquina virtual, con lo que nos ahorraremos la quemada del CD, la otra opción es quemar
el CD en un disco en blanco y luego utilizar este disco. En la explicación de la configuración
de la maquina virtual, se detallo que hacer para instalar desde la imagen ISO y desde el
CD.
80
 Acto seguido, ingresamos a la maquina virtual como se ha explicado anteriormente, y
seleccionamos en la parte de la izquierda la maquina virtual correspondiente, en nuestro
caso “MINIX 3”, la cual aparecerá con el estado de apagada.
 Luego hacemos clic en “Iniciar”. Algo importante que hay que destacar, es que si hacemos
la instalación desde el CD tendremos que tener el disco dentro de la lectora especificada
en la configuración; si es la imagen ISO, tener correcta la ruta especificada dentro de la
configuración de la maquina virtual, como se había explicado con anterioridad. Después
de haber hecho, aparecerá la pantalla de instalación de MINIX 3.
81
 Ese mensaje nos indica que cuando la ventana del MINIX 3 este activa, automáticamente
capturara el teclado, y si hacemos clic sobre la pantalla de MINIX, también capturara el
mouse, podemos marcar ese mensaje para que no se vuelva a mostrar. La explicación a
esto es la siguiente: Se quedará con el control del ratón y puede que no sepamos cómo
hacer que nos lo devuelva a nuestro Ubuntu. Pulsamos la tecla “Control” de la derecha. Es
un conmutador para dar y devolver el control del ratón y teclado entre el sistema anfitrión
y el huésped. Hacemos clic sobre la casilla para que no vuelva a aparecer el mensaje, luego
clic en “OK”.
 Ahora ya estamos en la instalación de MINIX 3, dependiendo de qué tipo de instalación

realicemos, presionamos la opción 1 o 2 (en nuestro caso la opción 1).
82
 Esperamos a que cargue, luego digitamos “root”, después “setup”.
 Presionamos “Enter” e Ingresamos el tipo de teclado, si seleccionamos por defecto

presionar “Enter”.
 Seleccionamos la tarjeta de red, por medio del número correspondiente a la tarjeta

mencionada, por defecto con “Enter”.
83
 Seleccionamos el tipo de instalación: con la letra F significa Full y con la letra M Minimal.
 Presionamos “Enter” para modo automático, para modo experto hay que tipear “expert” y
“Enter”.
 Seleccionamos el disco donde instalar MINIX por medio del número correspondiente al
dispositivo, luego seleccionar región de espacio libre, luego confirmamos lo seleccionado
tipeando “yes” y “Enter”.
84
 Especificamos el tamaño de la partición /home (el programa de instalación nos indica el
rango del tamaño), luego nos pregunta por el tamaño recién asignado y confirmamos con
la letra “Y”, después el tamaño de los bloques y “Enter”.
 Luego de esto, creara las carpetas necesarias (carpeta raíz, home, usr), y después
empezara a verificar las particiones seleccionadas, si queremos detener esto, presionamos
la combinación de teclas Ctrl-C.
 Ahora hay que esperar a que se copien los archivos del sistema a la partición seleccionada.
85
 Después de un rato, se habrán copiado todos los archivos y volveremos al prompt, donde
debemos digitar “shutdown” y “Enter”.
 Ahora bien, tenemos que salirnos de MINIX e irnos a la opción “Configuración”, luego en la
opción “CD/DVD-ROM” desmarcamos la casilla “Montar la unidad de CD/DVD” y
“Aceptar”. Con esto nos estaremos asegurando que cuando volvamos a arrancar la
maquina virtual, arrancará MINIX directamente desde el disco duro virtual.
86
 Acto seguido, volvemos a arrancar la maquina virtual como ya se ha explicado antes, nos
logueamos y estaremos dentro de MINIX 3 funcionando, si queremos instalar mas
paquetes, con el CD dentro digitamos “packman” para poder instalar los paquetes, pero
como root.
87
Manual de instalación de VirtualBox sobre el sistema operativo
Microsoft Windows.
En nuestro caso, se explicara como instalar en la versión Vista Ultimate sin ningún Service Pack; la
versión de VirtualBox es la 2.0.4.
 Descargamos la versión correspondiente al sistema operativo donde instalaremos nuestra

maquina virtual, en nuestro caso la correspondiente a Windows, para eso nos vamos a la
siguiente dirección: http://www.virtualbox.org/wiki/Downloads
 Acá seleccionamos el sistema operativo para descargar nuestro instalador (en nuestro
caso nos vamos a la opción de Windows).
 El archivo descargado en nuestro caso se llama “VirtualBox-2.0.4-38406-Win_x86”, esto
dependerá del archivo descargado.
 Hacemos doble clic sobre este archivo, y nos aparecerá lo siguiente:
 Esperamos un momento, luego aparecerá la pantalla de bienvenida del programa,

hacemos clic en “Next >”.
88
 Aceptamos la licencia y luego clic en “Next >”.
 Clic en “Next >”.
89
 Clic en “Install”.
 Aparecerá lo siguiente.
90
 Sin embargo, como es la versión Vista de Windows, nos preguntara si damos los permisos
para instalar el programa, le decimos “Continuar”, luego aparece lo siguiente:
 Nos preguntara si deseamos instalar Software de dispositivo, a lo cual respondemos

“Instalar”.
91
 Luego de esto, la instalación habrá finalizado satisfactoriamente, hacemos clic en “Finish”.
 Ahora, en el menú Inicio del Windows, tendremos que encontrar una opción llamada “Sun
xVM VirtualBox”, dentro de esta habrá una opción llamada “VirtualBox”, hacemos clic en
esta y estaremos dentro de la maquina virtual recién instalada.
92
 Cuando ingresemos al programa, nos dirá que nos registremos, en nuestro caso lo
cancelamos, pero esto es opcional.
 Con esto, toda la instalación está finalizada, ya dentro de la maquina nos aparecerá lo
siguiente:
 Ahora solo queda configurar las nuevas maquinas virtuales, esto dependerá del sistema
operativo a instalar.
93
Manual de instalación de MINIX 2 en la maquina virtual VirtualBox
corriendo sobre Windows.
La maquina virtual en nuestro caso está instalada en Vista Ultimate.
 2MB de RAM.
 Disquetera.

 Ahora, lo descomprimimos, para esto, solamente hacemos uso del extractor que posee
Windows, o en nuestro caso utilizando la utilidad de compresión/descompresión WinRAR,
solamente hacemos clic derecho sobre el archivo y seleccionamos “Extract Here”.
94
 Una vez instalada la maquina virtual, ingresamos a esta por medio de Menu Inicio – Todos
los programas – Sun xVM VirtualBox – VirtualBox.
95

 Seleccionamos el tamaño de memoria RAM a asignar al MINIX, en nuestro caso le dejamos

32 MB, aunque es posible que funcione con menos, como se ha visto en los requisitos de
dicho sistema operativo.
96
 Esta parte es de la asignación de un disco duro para la maquina virtual, en nuestro caso,
como la imagen del MINIX que hemos bajado ya está preparada para ser utilizado en una
maquina virtual, utilizaremos esta, esto a pesar de que dicha imagen esta creada para
poder ser utilizada exclusivamente ya sea por VMware Workstation o Player. Gracias a la
compatibilidad de VirtualBox para poder utilizar imágenes de VMware, podremos llevar a
cabo esto, para eso hacemos clic en el botón “Existente…”.
 Aparecerá otra ventana, en esta hacemos clic en el botón “Agregar”.
97
 Buscamos el archivo imagen de VMware, el cual es de extensión .vmdk, este lo
encontraremos en la ubicación donde hayamos dejado el archivo que descomprimimos , el
cual es el que se mencionaba al principio del manual, luego de haberlo hallado hacemos
doble clic izquierdo sobre dicho archivo.
 Ahora bien, volveremos a la ventana anterior, pero ahora ya aparecerá dicha imagen,
tenemos que hacer clic en “Seleccionar”.
98
 Volveremos a la ventana anterior de la creación de la maquina virtual, pero ahora si
aparecerá un disco duro, el cual será el que acabamos de seleccionar, tenemos que hacer
clic en “Next >”.
 Nos aparecerá un resumen sobre la maquina virtual que se creara, hacemos clic en
“Finish”.
99
 Con esto ya se habrá creado la maquina virtual para MINIX 2, observaremos que aparecerá
en el estado de “Apagada”.
 Para iniciarla, solamente hacemos clic en el botón “Iniciar”, con lo cual se iniciara el
sistema.
100
 Ahora bien, presionamos el botón = (igual) para iniciar MINIX, con lo cual observaremos lo
siguiente:
 Ahora nos logueamos como root.
Con esto, ya estamos dentro de MINIX 2, con lo cual concluimos nuestro manual sobre la
instalación de MINIX 2 en VirtualBox corriendo sobre GNU/Linux. Si nos damos cuenta, no se
configuro casi nada, esto es porque esta imagen de MINIX ya viene configurada, por tal motivo no
es necesario realizar modificaciones para hacerlo funcionar, lo único es la asignación de la
memoria RAM.
101
Configuración de VirtualBox corriendo sobre Windows para la
instalación de MINIX 3.
La maquina virtual en nuestro caso está instalada en la versión Vista Ultimate.
 Una vez instalada la maquina virtual, ingresamos a esta por medio del botón de Inicio –
Todos los programas – Sun xVM VirtualBox – VirtualBox.
102

 Ingresamos la cantidad de memoria RAM a asignar, en nuestro caso con lo que nos ofrece
la maquina es suficiente (64 MB), sin embargo es opcional, pero no hay que dejarle menos
de 16 MB, ni tampoco más de 128 MB, ya que sería un desperdicio, luego “Next >”.
103
 Ahora esta la selección del disco duro virtual, si tenemos uno lo podemos seleccionar,
pero en nuestro caso como no tenemos uno, nos vamos a la opción “Nuevo...”.
 Nos aparecerá un nuevo asistente de creación de discos duros virtuales, hacemos clic en
“Next >”.
 Tenemos dos opciones: “Imagen de expansión dinámica” y “Imagen de tamaño fijo”. Más
adelante le vamos a asignar un tamaño al disco duro virtual que estamos creando. Esta
fase es para especificar si queremos que se ocupe ya todo ese espacio que vamos a
reservar (segunda opción), o que ocupe lo necesario según vayamos instalando y vaya
creciendo según se vaya necesitando. Podemos elegir la opción que queramos, en nuestro
caso elegimos “Imagen de expansión dinámica”.
104
 En esta fase vamos a decirle dónde va a guardar esa imagen (por defecto en
“C:\Users\cuenta_usuario\.VirtualBox\VDI” y cómo se va a llamar dicho fichero (por
defecto igual que la máquina virtual, “MINIX 3” en nuestro ejemplo). Si no hay problema
de espacio en nuestro \Users, recomendamos dejarlo como está, así como su nombre para
saber de qué sistema es ese disco duro virtual en caso de que instalemos más de uno.
Finalmente le damos el tamaño del disco duro. Con 1 GB tendremos suficiente para MINIX.
Si queremos podemos asignarle más o menos espacio, pero no menos de 50 MB, ni más
de 4 GB, en nuestro caso queda con 1 GB y luego “Next”.
 Nos muestra un resumen en lo referente al disco duro virtual. Si está todo en orden le
damos a “Finish”, en caso contrario volvemos “< Back” y cambiamos lo que queramos.
 Nos ha devuelto a la sección donde estábamos en el primer asistente. Ya hemos creado el

disco duro virtual y está seleccionado (”MINIX 3.vdi”), luego clic en “Next >”.
105
 Un nuevo resumen, en esta ocasión del primer asistente, el global. Al igual que antes, clic
en “Finish” para finalizar si está todo en regla o “< Back” para cambiar algo.
 Ahora nos aparecerá la siguiente pantalla:
 Con esto ya hemos creado la maquina virtual para MINIX, ahora nos queda configurar los
parámetros necesarios, para esto hacemos clic en “Configuración”.
106
 En esta parte como se puede apreciar, podemos configurar la RAM, memoria de Video,
nombre y tipo de sistema, pero en nuestro caso nos iremos a la pestaña “Avanzado”.
 Como se puede observar, podemos configurar la secuencia de booteo, en nuestro caso

eliminamos el disquette, y dejamos intacto lo demás.
107
 Ahora nos vamos a las opciones de la izquierda, y seleccionamos “CD/DVD-ROM”, luego
marcamos la casilla “Montar la unidad de CD/DVD”. Ahora bien, tenemos dos opciones,
imagen, sin embargo esto es opcional.
 Con esto, todo estará configurado, solamente hacemos clic en “Aceptar”.
 Con esto, ya estamos listos para instalar MINIX en nuestra maquina virtual.
108
Instalación de MINIX 3 en la maquina virtual VirtualBox corriendo
sobre Windows.
En nuestro caso VirtualBox está instalado sobre la versión Vista Ultimate.
 Primeramente descargamos la última versión de MINIX estable del siguiente enlace:

http://www.minix3.org/download/IDE-3.1.2a.iso.zip, el archivo descargado tendrá como
nombre en nuestro caso “IDE-3.1.2a.iso.zip”.
CD.
109
 Luego hacemos clic en “Iniciar”. Algo importante que hay que destacar, es que si hacemos
la instalación desde el CD tendremos que tener el disco dentro de la lectora especificada
en la configuración; si es la imagen ISO, tener correcta la ruta especificada dentro de la
configuración de la maquina virtual, como se había explicado con anterioridad. Después
de haber hecho, aparecerá la pantalla de instalación de MINIX 3.
110
 Ese mensaje nos indica que cuando la ventana del MINIX 3 este activa, automáticamente
capturara el teclado, y si hacemos clic sobre la pantalla de MINIX, también capturara el
mouse, podemos marcar ese mensaje para que no se vuelva a mostrar. La explicación a
esto es la siguiente: Se quedará con el control del ratón y puede que no sepamos cómo
hacer que nos lo devuelva a nuestro Ubuntu. Pulsamos la tecla “Control” de la derecha. Es
un conmutador para dar y devolver el control del ratón y teclado entre el sistema anfitrión
y el huésped. Hacemos clic sobre la casilla para que no vuelva a aparecer el mensaje, luego
clic en “OK”.
 Ahora ya estamos en la instalación de MINIX 3, dependiendo de qué tipo de instalación

realicemos, presionamos la opción 1 o 2 (en nuestro caso la opción 1).
111
 Presionamos “Enter” e Ingresamos el tipo de teclado, si seleccionamos por defecto

presionar “Enter”.

112
 Seleccionamos el tipo de instalación: con la letra “F” significa Full y con la letra “M”
Minimal.
“Enter”.
113
la combinación de teclas Ctrl-C.
114
 Ahora bien, tenemos que salirnos de MINIX e irnos a la opción “Configuración”, luego en la
opción “CD/DVD-ROM” desmarcamos la casilla “Montar la unidad de CD/DVD” y
“Aceptar”. Con esto nos estaremos asegurando que cuando volvamos a arrancar la
maquina virtual, arrancará MINIX directamente desde el disco duro virtual.
115
 Acto seguido, volvemos a arrancar la maquina virtual como ya se ha explicado antes, nos
logueamos y estaremos dentro de MINIX 3 funcionando, si queremos instalar mas
paquetes, con el CD dentro digitamos “packman” para poder instalar los paquetes, pero
como root.
116
Manual de instalación de la maquina virtual VMWare Workstation en
Windows.
Para este manual, nos hemos basado en la versión Vista Ultimate sin ningún Service Pack; la
versión de VMware Workstation es la 6.0.4, esta instalación también instala VMware Player en su
versión 2.0.4.
Primeramente, tenemos que adquirir el VMWare, sin embargo, esto implica poseer la licencia para
poder instalarlo, ya que este es un software vendido, en este caso asumiremos que se ha
adquirido el programa y la licencia de manera legal, por tal motivo no se explicara de donde
descargar dicha maquina.
 Una vez teniendo el programa, el instalador tendrá por nombre “VMware Workstation
6.0.4.b93057 Setup.exe”.
 Ahora, hacemos doble clic sobre dicho archivo, al cabo de un rato, nos preguntara si
damos los permisos para que se ejecute, a lo cual respondemos “Continuar”, luego nos
aparecerá la siguiente imagen.
117
 Nos esperamos un momento a que cargue el instalador.
 Luego de la pantalla anterior, nos aparecerá lo siguiente, a lo cual hacemos clic en “Next
>”.
 Seleccionamos “Typical”, luego “Next >”.
 Nos pregunta por la ruta de instalación de la aplicación, si estamos conformes con dicha
ruta, hacemos clic en “Next >”, si no, podemos hacer clic en “Change”, con lo cual nos dará
la opción para escoger una nueva ruta; en nuestro caso simplemente clic en “Next >”.
118
 Nos pregunta por los accesos directos a crear, estos son: Escritorio, Folder de programas
del menú inicio y acceso rápido en la barra de tareas, podemos marcar y desmarcar los
que sean de nuestro gusto, en nuestro caso solamente hicimos clic en “Next >”.
 Ahora hacemos clic en “Install” para que comience la instalación.
 Durante la instalación, observaremos lo siguiente, hay que esperarse un buen momento,

ya que la instalación tarda mucho tiempo. Si en algún momento queremos detener la
instalación, solamente hacemos clic en “Cancel”.
119
 En este paso, tendremos que introducir el nombre del usuario, nombre de la compañía (si
es que se trata de una) y el número de serie, este ultimo lo tenemos que haber obtenido al
comprar el VMWare; luego de haber introducido todos los datos (con excepción de
compañía que no es obligatorio), hacemos clic en “Enter >”.
 Después de esto, solamente hacemos clic en “Finish”, con lo cual ya habremos finalizado la
instalación.
 Nos dirá que se necesita reiniciar el equipo, a lo cual respondemos “Yes”, con esto se
reiniciara el equipo.
120
 Con esto, cuando el equipo se haya reiniciado, ya tendremos instalada la maquina virtual
VMWare Workstation 6.0.4. Para acceder a esta, solamente nos vamos al menú Inicio –
VMWare – VMWare Workstation.
Nota: cómo podemos notar, además de instalar el Workstation, también se instala el Player, el
cual es una versión gratuita que se puede descargar de la página oficial de VMWare, la cual nos
sirve para emular maquinas a las cuales ya se les han creado específicamente archivos especiales
para tal fin.
121
Manual de instalación de MINIX 2 en la maquina virtual VMWare
Player
Para este manual, nos hemos basado en la versión Vista Ultimate, y la versión de la maquina
virtual es la 2.0.4.
 2MB de RAM.
 Disquetera.

122
 Abrir el programa “VMware” (en nuestro caso “VMware Player v2.0.4”).
 Clic en “Open”.
 Irnos a la ruta donde hallamos movido el archivo recién comprimido, y dentro de este
seleccionar el archivo “mx204.vmx” (lógicamente clic en “Abrir”).
123
 Seleccionar la opción “Take Ownership”.
 Esperamos a que cargue el archivo.
 Seleccionar “I copied it” y luego “OK”.
124
 Ahora nuestro MINIX ya está instalado en la maquina virtual, para poder acceder al MINIX
solamente hacemos clic dentro de la ventana que muestra el sistema o la combinación de
teclas Ctrl-G, ya estando adentro, si queremos salirnos del sistema, solamente
presionamos la combinación de teclas Ctr-Alt.
 Las configuraciones por defecto en esta imagen del sistema son: 32 MB de RAM y disco
duro de 512 MB, la RAM se puede modificar, para aumentar o disminuir esta cantidad,
pero el disco duro, al menos en la versión “Player” no se puede; también se le puede
configurar red Ethernet entre otras cosas.
 Ahora cuando salgamos de la maquina virtual y volvamos a ingresar a esta, ya nos
aparecerá una opción donde podemos ingresar directamente al MINIX 2.
Con lo mencionado anteriormente, concluyen los pasos para la instalación de MINIX2 en la

maquina virtual VMware Player v 2.0.4, posteriormente procuraremos instalar este versión de
MINIX por medio de disquetes, todo esto para poder crear un manual de instalación de una
maquina directamente.
125
Configuración de VMWare Workstation corriendo sobre Windows
para la instalación de MINIX 3.
Para este manual, lo hicimos en la maquina virtual VMware Workstation v 6.0.4, sin embargo el
proceso de instalación es igual tanto en la maquina virtual como directamente, ya que hicimos la
instalación desde el CD de MINIX 3, por esta razón explicaremos en este apartado la configuración
de la maquina virtual, y luego el manual para instalar MINIX 3, ya sea en maquina virtual o
directamente.
 Ingresar al VMware Workstation v 6.0.4
 Ahora dentro del programa, hacemos clic en “New Virtual Machine”.
126
 Clic en “Siguiente”
 Seleccionar en “Typical” y “Siguiente”
 Seleccionar “Other”, versión “Other” y “Siguiente:
127
 Especificamos el nombre de la maquina virtual y la ruta donde se guardara dicha maquina
con el sistema, luego “Siguiente”
 Esta opción es personal, ya que acá se selecciona con respecto a las conexiones de red, en
nuestro caso seleccionamos “Use bridged networking”, luego “Siguiente”
 Especificamos el tamaño de disco duro que tendrá la maquina virtual, el tamaño

dependerá de la instalación que realizara el usuario, en nuestro caso asignamos 1 GB,
luego “Finalizar”
128
 Ahora el programa indicara que la maquina virtual ha sido creada satisfactoriamente, clic
en “Close”
 En esta parte, editamos el hardware de la maquina virtual, esto significa que los cambios
que se realizaran en esta parte son opcionales, pero hay que recalcar que tenemos que
especificar desde que dispositivo arrancar la maquina, esto es para poder bootear desde el
CD-ROM correcto, para hacer esto, nos vamos a la opción “Edit virtual machine settings”
129
 Ya acá, nos vamos a la opción “CD-ROM (IDE 1:0). Ahora bien, tenemos dos opciones,
imagen, sin embargo esto es opcional. Para esto seleccionamos la opción “Use ISO image:”
y en con el botón “Browse” especificamos la ruta donde se encuentra esa imagen ISO.
 Las otras opciones son personales, en nuestro caso lo dejamos de la siguiente manera (al
menos, si le dejamos mas dispositivos en nuestro caso fallo al instalar el MINIX):
Ahora que está todo configurado, vamos a instalar MINIX 3.
130
Manual de instalación de MINIX 3 sobre la maquina virtual VMWare
Workstation corriendo sobre Windows.
Antes de instalar MINIX, es importante mencionar los requisitos de este sistema:
 Pentium o compatible
 16 MB de RAM (instalación completa) o 8 MB de RAM (instalación mínima)
 1 GB de disco duro (instalación completa) o 50 MB de disco duro (instalación mínima)
 IDE CD – ROM
Ahora que ya sabemos los requisitos, viene el manual de instalación.
 Obtener el archivo “IDE-3.1.2a.iso.zip”, bajándolo de la siguiente dirección:

http://www.minix3.org/download/IDE-3.1.2a.iso.zip, sino, podemos descargar otra
versión 3 de MINIX, por ejemplo el que viene en el libro respectivo a esta versión.
CD.
131
 Hacemos clic en “Start this virtual machine”.
 Ya acá, ingresamos a la maquina virtual, haciendo clic dentro de la pantalla del sistema,
dependiendo de qué tipo de instalación realicemos, presionamos la opción 1 o 2 (en
nuestro caso la opción 1).
132
 Presionamos “Enter”
 Ingresamos el tipo de teclado, si seleccionamos por defecto presionar “Enter”.
133
134
“Enter”.
135
la combinación de teclas Ctr-C.
136
137
 Al hacer esto, volveremos al “boot monitor”, para cargar el MINIX, digitamos “boot dxpx”
donde dx se refiere al número de disco a cargar (en nuestro caso d0) y px se refiere a la
partición donde se cargara (en nuestro caso p0).
Con esto, ya tenemos instalado el MINIX 3, solamente nos queda loguearnos y estaremos con
nuestro MINIX 3 funcionando, si queremos instalar mas paquetes, con el CD dentro digitamos
“packman” para poder instalar los paquetes, pero como root.
138
Manual de instalación de MINIX 3 en una computadora directamente.
Antes de instalar MINIX, es importante mencionar los requisitos de este sistema:
 Pentium o compatible
 16 MB de RAM (instalación completa) o 8 MB de RAM (instalación mínima)
 1 GB de disco duro (instalación completa) o 50 MB de disco duro (instalación mínima)
 IDE CD – ROM
Ahora que ya sabemos los requisitos, viene el manual de instalación.
 Obtener el archivo “IDE-3.1.2a.iso.zip”, bajándolo de la siguiente dirección:

http://www.minix3.org/download/IDE-3.1.2a.iso.zip, sino, podemos descargar otra
versión 3 de MINIX, por ejemplo el que viene en el libro respectivo a esta versión.
139
 Ahora podemos quemar la imagen con algún programa para tal fin, en nuestro caso
utilizamos “Alcohol 120%”.
 Ahora reiniciamos la computadora con el CD recién quemado adentro de la lectora,

ingresamos a la BIOS.
 Nos vamos a “Boot” y arreglamos para arrancar desde el CD-ROM, luego desde el disco
duro.
140
 Ahora guardamos los cambios, y con esto la maquina se reiniciara.
 Ahora estamos en la parte de instalación de MINIX 3, dependiendo de qué tipo de

instalación realicemos, presionamos la opción 1 o 2 (en nuestro caso la opción 1).
141
 Presionamos “Enter”
 Ingresamos el tipo de teclado, si seleccionamos por defecto presionar “Enter”.

142
“Enter”.
143

144
la combinación de teclas Ctr-C.
145
 Al hacer esto, volveremos al “boot monitor”, para cargar el MINIX, digitamos “boot dxpx”
donde dx se refiere al número de disco a cargar (en nuestro caso d0) y px se refiere a la
partición donde se cargara (en nuestro caso p0).
Con esto, ya tenemos instalado el MINIX 3, solamente nos queda loguearnos y estaremos con
nuestro MINIX 3 funcionando, si queremos instalar mas paquetes, con el CD dentro digitamos
“packman” para poder instalar los paquetes, pero como root.
146
Troubleshooting.
En esta parte se detallan los problemas que se presentan luego de la instalación de las versiones
de MINIX 2 y 3 respectivamente, también su solución, empezando por MINIX 2.
MINIX 2.
El siguiente problema, solamente es generado cuando MINIX se instala en la maquina virtual
VMware tanto Workstation como Player.
 Una vez instalado MINIX, nos presenta el siguiente problema:
 Si nos damos cuenta, quiere obtener una dirección IP por DHCP, pero como no la
encuentra, nos dice que presionemos la tecla DEL (o SUPR) para entrar como root e
investigar el problema, de lo contrario podemos pasar esperando sin que el sistema pase
de ahí.
 El problema radica, en que siempre que queramos acceder al sistema pasara lo mismo, y
cuando reiniciemos el sistema, nos dirá que no se cerró correctamente y presentara que
hay errores; para solucionar esto, hacemos lo siguiente:
147
 Cerramos el sistema operativo, para esto cuando estemos en la pantalla mostrada
anteriormente presionamos la tecla DEL o SUPR, luego digitamos shutdown, y esperamos
a que se apague el sistema.
 Ahora, digitamos “servers=none” y Enter, luego “save” y también Enter; luego de esto
digitamos “boot” y Enter.
 Ahora, cuando bootee ya no habrá problemas con las IP.
148
¡Problema solucionado!
MINIX 3.
El siguiente problema solamente se presenta cuando se instala MINIX en la maquina virtual
VMware Workstation.
 Cuando instalamos MINIX, la configuración puede quedar como sigue:
 Pero al iniciar la instalación de MINIX, nos saldrá el siguiente error:
149
 Por mucho que intentemos, no se podrá instalar, la solución es remover el “Sound
Adapter”, para eso, nos vamos a la opción “Edit virtual machine settings”.
 Ahí, seleccionamos “Sound Adapter” y hacemos clic en el botón “Remove”.
 Después de haber realizado los pasos anteriores, al adaptador de sonido desaparecerá.
150
 Hacemos clic en “OK”, entonces veremos que en los dispositivos ya no aparecerá el
adaptador de sonido.
 Si intentamos instalar ahora MINIX, ya no tendrá que haber ningún problema.
 Como nos podemos dar cuenta, ya no hubo ningún problema con la instalación, por lo que
podemos asumir que ya está solucionado.
¡Problema solucionado!
151
Manual de usuario de MINIX.
Acá se explicaran los comandos más utilizados en este sistema operativo, notara que son
comandos similares a los empleados en sistemas Unix y derivados (como el sistema operativo
GNU/Linux).
exit
Causa la terminación del intérprete de comandos con valor n. Normalmente usado para salir del
sistema.
Sintaxis
exit [n]
man
Muestra las páginas de manual en línea para el titulo especificado en la sección especificada. Las
opciones más comunes son:
a: Muestra todas las páginas de manual (o las descripciones de una línea) que se encuentre, en las
secciones especificadas y en todos los directorios del path de búsqueda, que contengan el titulo
dado.
s sección: Indica en qué secciones buscar la página.
Sintaxis
man [-antkfq] [-M path] [-s seccion] titulo . . .
clear
Permite limpiar la pantalla.
Sintaxis
clear
pwd
Muestra el directorio donde el usuario está posicionado actualmente.
Sintaxis
pwd
152
echo
Escribe lo que se le pase como argumento a la salida estándar. Cada argumento es separado del
otro por espacios en blancos con un CRLF, a menos que se indique –n.
Sintaxis
echo [–n] argumento .....
date
Permite mostrar y setear la fecha y hora. Las opciones más comunes son:
q: Lee la fecha y hora desde la entrada estándar.
s: Setea la fecha y hora
Sintaxis
date [-qtsu] [[MMDDYY]hhmm[ss]] [+formato]
cd
Cambia de directorio. Sin argumentos se cambia al directorio home del usuario.
cd ~
Cambia al directorio home
cd ~ivan
Cambia al directorio home del usuario ivan.
cd ..
Cambia al directorio padre del directorio donde está posicionado actualmente.
Sintaxis
cd path
ls
Sin argumentos, lista el contenido del directorio actual. Para cada archivo contenido, solo se
mostrará el nombre. Dándole un directorio como argumento, lista el contenido de ese directorio.
Existen numerosas opciones para este comando. Entre las más comúnmente usadas están:
a: muestra también los archivos ocultos.
153
l: listado largo. Además del nombre, se muestra, para cada archivo, los permisos, la cantidad de
enlaces que tiene, el usuario propietario, el grupo propietario, el tamaño y la fecha y hora de
última modificación.
t: muestra los archivos ordenados descendentemente por fecha de última modificación.
R: si recibe como argumento un directorio muestra recursivamente el contenido del. Es decir que,
si dentro del directorio existen subdirectorios, los contenidos de esos subdirectorios son
mostrados también.
ls Mostrará los archivos en formato corto (solo el nombre).
ls -l Mostrará los archivos en formato largo (nombre, fecha, atributos, etc.).
ls *.out Mostrará todos los archivos terminados en “.out”, en formato corto.
ls -l *.out Mostrará todos los archivos terminados en “.out”, en formato largo.
Sintaxis
ls [-acdfgilqrstu1ACDFLMRTX] [nombre]
more/yap
Permite visualizar archivos (o la entrada estándar) por pantalla.
Sintaxis
yap [-cnuq] [-n] [+command+ [file ...]
cat
Permite concatenar archivos y escribirlos en la salida estándar. Si no se da como argumento un

archivo de entrada o si “-“es encontrado como un nombre de archivo, se usa la entrada estándar.
Sintaxis
cat [–u] [archivo]. . .
154
Comandos para Gestión de archivos y directorios
file
Lee el primer bloque del archivo que se le pasó como parámetro e intenta adivinar qué clase de
archivo es. Puede indicar si es un archivo fuente de lenguaje c, archivos ejecutables, scripts de
shell, etc.
Sintaxis
file nombre ....
cp
Copia un archivo a otro, o copia uno o más archivos a un directorio. Las opciones más comunes
son:
i: Pregunta antes de sobrescribir un archivo existente.
p: Preserva el modo, uid, gid y tiempos (de modificación, de creación, etc.) del archivo.
r: Copia arboles de directorio dejando intacta la estructura de links, etc.
R: Copia arboles de directorio tratando a los archivos especiales como archivos ordinarios.
Sintaxis
cp [-pifsmrRvx] archivo1 archivo2
cp [-pifsmrRvx] archivo1 . . . directorio
cp [-ifvx] archivo1 archivo2
mv
Mueve o renombra un archivo. Las opciones más comunes son:
i: Pregunta antes de sobrescribir un archivo existente.
f: No pregunta antes de sobrescribir un archivo existente.
Sintaxis
mv [-ifsmvx] archivo1 archivo2
mv [-ifsvx] archivo1 . . . directorio
155
mkdir
Permite crear directorios. Las opciones más comunes son:
p: Crea directorios intermedios no existentes
m: Equivalente a un chmod luego de su creación.
Sintaxis
mkdir[-p] [-m modo] directorio .....
rm
Remueve uno o más archivos. Las opciones más comunes son:
i: Pregunta antes de remover.
f: No pregunta antes de remover
r o R: Remueve directorios y su contenido
Sintaxis
rmdir [-ifrRvx] nombre ...
rmdir
Permite eliminar directorios. Los archivos comunes no son eliminados. Los directorios deben estar
vacíos.
Sintaxis
rmdir directorio ...
ln
Crea un enlace a un archivo. Es decir, crea una entrada de directorio llamada nombrelink (ver
sintaxis) que apunta a un archivo existente. Después de correr este comando, nombrelink y archivo
pueden ser usados indistintamente para hacer referencia al mismo. Si no se especifica nombrelink,
se usa la última componente de archivo como nombre del link. Si se especifica más de un archivo o
si nombrelink es un directorio, los links son creados dentro de ese directorio. Un nombrelink no
será removido a menos que se especifiquen las opciones –i o –f. Las opciones más comunes son:
i: Pregunta antes de sobrescribir un archivo.
f: Remueva links existentes.
156
r o R: Enlaza recursivamente un árbol de directorios.
Sintaxis
ln [-ifmrRvx] archivo [nombrelink]
ln [-ifrRvx] archivo .... dir
find
Permite buscar archivos que cumplen determinada condición. Básicamente, desciende por el árbol
de directorios, comenzando en el directorio dado como argumento, chequeando cada archivo en
ese directorio y sus subdirectorios contra una condición. Si la condición se cumple, se ejecuta una
acción.
Las condiciones pueden ser conectadas por –a (and) –o (or) y !(negación) n puede ser precedido
por + para indicar cualquier valor mayor que n, por – para indicar cualquier valor menor que n o
por = para indicar exactamente n. Las condiciones más comunes usadas con find son:
-name s: verdadera sy el nombre del archivo es s (incluye caracteres comodín del shell).
-size n: verdadera si el tamaño del archivo es n bloques.
-mtime n: verdadera si la fecha y hora de modificación del archivo (relativa a hoy), en días, es n.
-type x: verdadera si el tipo del archivo es x, donde x puede ser b (block), c (carácter), d (dir), f
(regular file), u (setuid), g (setgid)
Para decirle a find qué hacer con cada archivo que cumpla la condición puede usarse:
-print: escribe el nombre del archivo a la salida estándar.
-exec: ejecuta un comando MINIX {} es expandido al nombre del archivo.
-ok: pregunta antes de ejecutar el comando.
Sintaxis
find directorio condición
157
Comandos para Gestión de procesos
ps
Muestra el estado de los procesos activos. Sin argumentos ni opciones solo se muestran los
campos PID (Identificador del proceso) , TTY (terminal que lo controla), TIME (tiempo de ejecución
acumulado) y CMD (argumentos de la línea de comando). En el formato ampliado, se muestran
además los campos F (Kernel Flags, consultar el man para ver los valores posibles), S (estado del
proceso), UID (Id del usuario propietario), PID, PPID (Id de proceso del proceso padre), PGRP (Id de
grupo del proceso padre), SZ (tamaño del proceso en kb), RECV (Proceso o tarea sobre el cual un
proceso receptor está esperando o durmiendo), TTY, TIME, CMD. Las opciones comunes son:
l: muestra la información en formato ampliado
a: muestra todos los procesos con terminales que lo controlan
x: Incluye procesos sin terminal.
Sintaxis
ps [-alx]
kill
Envía una señal a un proceso. Por defecto, envía la señal 15 (SIGTERM). Los procesos pueden
atrapar y gestionar las señales. Solo existe una señal que no puede ser atrapada: SIGKILL. n puede
ser el número correspondiente a la señal, o su mnemónico (ver /usr/include/signal.h)
Sintaxis
kill [-n] proceso
Comandos para Gestión de usuarios

adduser
Agrega el usuario al sistema. Además, crea el directorio home de dicho usuario y copia el
contenido del directorio home de ejemplo (/usr/ast) en él. El shell por defecto es el Bourne, la
password estará, inicialmente vacía y el nombre completo deberá ser seteado también. Tanto el
shell, como la password y el nombre completo pueden gestionarse usando csh, passwd y chfn.
Sintaxis
adduser usuario grupo homedir
158
passwd
Cambia la password del usuario. Si no se da ningún usuario como argumento se asume el usuario
actual.
Solo el superusuario puede cambiar la password de otros usuarios. Para reducir los errores de
tipeo, la nueva password se pide dos veces.
Sintaxis
passwd [usuario]
chsh
Permite cambiar el shell del usuario.
Sintaxis
chsh [usuario] shell
chfn
Permite cambiar el nombre completo (campo GECOS del archivo de passwords) del usuario
Sintaxis
chfn [usuario] nombrecompleto
who
Muestra una lista de los usuarios logueados actualmente. Para cada usuario se muestra el nombre,
terminal y la cantidad de tiempo transcurrido desde que se logueó. Por defecto la información se
extrae desde el archivo /etc/utmp pero, si se le da un nombre de archivo como argumento, se
usará ese archivo.
Sintaxis
who [archivo]
who am i
Indica el usuario, la consola y la fecha en que se logueó el usuario que lanza este comando.
Sintaxis
who am I
159
su
Permite loguearse temporalmente como el superusuario u otro usuario. Sin argumentos, su asume
root.
A los usuarios normales se le solicitará la password del usuario con cuyo nombre están tratando de
loguearse pero a cualquier usuario con un gid = 0 esta no le será solicitada. Si los chequeos de
identidad son exitosos, se crea un shell con el uid deseado. Para salir de ese shell debe tipearse
Ctrl+D o exit.
Sintaxis
su [usuario]
Comandos para la gestión de permisos sobre archivos

chgrp
Permite cambiar el grupo y, opcionalmente, el usuario de los archivos a grupo y usuario. Solo el
super usuario puede cambiar el grupo indicando grupos arbitrarios. Los usuarios normales solo
pueden utilizarlo si son propietarios del archivo archivy y grupo es su propio grupo o uno de sus
grupos adicionales. Opciones:
R: Indica que los cambios sean aplicados recursivamente a todos los archivos en los directorios
dados como argumento.
Sintaxis
chgrp [-R] [propietario:]grupo archivo ...
chown
Permite cambiar el usuario y, opcionalmente, el grupo de los archivos a grupo y usuario. Solo el
superusuario puede cambiar el usuario indicando usuarios arbitrarios.
Sintaxis
chown [-R] propietario[:grupo] archivo ...
chmod
Permite cambiar el modo de acceso de los archivos. El modo dado, se aplicará a cada archivo en la
lista. Los modos pueden ser dados en forma absoluta o simbólica.
160
Los modos absolutos son dados como un número octal que representan el nuevo modo de acceso
del archivo. Los bits de modo de acceso son definidos como se muestra a continuación:
4000: En ejecución, setear el euid como el id del propietario del archivo.
2000: En ejecución, setear el egid como el id del grupo del archivo.
0400: Permiso de lectura para el propietario del archivo
0200: Permiso de escritura para el propietario del archivo
0100: Permiso de ejecución para el propietario del archivo
0070: Lo mismo que lo anterior pero para otros usuarios del mismo grupo.
0007: Lo mismo que lo anterior pero para el resto de los usuarios.
Los modos simbólicos tienen la forma:
[quien] op permisos {op permisos} {, [who] op .....}
quien puede ser u, g, o y a para indicar usuario, grupo, otros o todos respectivamente. Si quien es
omitido, se asume a. op puede ser +, - o =; + da el permiso, - revoca el permiso, y = da los permisos
exclusivamente para el quien dado.
Los permisos pueden ser r, w, x y s Los tres primeros significan lectura, escritura y ejecución,
respectivamente. S hace referencia al bit de usuario y/o grupo efectivo y solo tiene sentido cuando
quien es u o g.
Comandos para la gestión del sistema de ficheros

mount
Monta el sistema de archivos contenido en el archivo especial es montado en mountpoint. Sin

argumentos, muestra información acerca de los sistemas de archivos montados. Opciones:
r: El sistema de archivos es montado como “solo lectura”
Sintaxis
mount especial mountpoint [-r]
161
umount
Actualiza la cache de disco y desmonta el sistema de archivos contenido en el archivo especial.
Sintaxis
umount especial
fsck
Chequea la consistencia de los sistemas de archivos que se encuentran en los dispositivos

especificados como parámetros. Antes de correr fsck sobre un sistema de archivos que está
montado, debe desmontarse el mismo. Intentar reparar un sistema de archivos montado, es
peligroso y no debería intentarse.
Las opciones más comunes son:
a: Repara automáticamente las inconsistencias
r: Pregunta al usuario antes de reparar
Sintaxis
fsck [-aclmrs] [dispositivo] ...
mkfs
Construye un sistema de archivos y copia archivos específicos al mismo. El archivo prototipo indica
qué directorios y archivos copiar.
Sintaxis
mkfs [-Ldot] [-i inodes] [-b bloques] especial prototipo
df
Muestra la cantidad de espacio en disco y de inodos del sistema de archivos. Se informa tanto la
cantidad ocupada como la libre. Sin argumentos, df muestra información del dispositivo root y
todos los sistemas de archivos montados.
Sintaxis
df especial ...
Para visualizar el valor de una variable de entorno, basta con teclear:
echo $NOMBRE
162
Entre las variables generales más habituales encontramos:
_ EDITOR : Variable que almacena el editor que usará el usuario por defecto.
_ ENV : Variable que almacena el archivo en donde el usuario ha definido sus aliases y funciones.
_ HOME : Variable que almacena el directorio del usuario, desde el que arrancará la shell cuando
entra en el sistema.
_ HOSTNAME : Variable que almacena el nombre de la máquina.
_ LOGNAME : Variable que almacena el nombre o login del usuario.
_ MAIL : Variable que almacena el archivo que contiene el correo de usuario.
_ MAILCHECK : Variable que indica cada cuantos segundos debe comprobarse si el usuario tiene
correo.
_ PATH : Variable en la que se encuentran almacenados los paths de aquellos directorios a los que
el usuario tiene acceso directo, pudiendo ejecutar comandos o programas ubicados en ellos sin
necesidad de acceder a dicho directorio.
_ PS1 : Variable que almacena el prompt que se empleará por defecto en la shell.
_ PS2, PS3, etc. : Variable que almacena el prompt que se empleara en la 2ª , 3ª , etc. Subshells, lo
cual se hace invocando a la shell, es decir, ejecutando por ejemplo, ksh.
_ PWD : Variable que almacena el directorio actual, puede ser útil para modificar el prompt (PS1)
dinámicamente.
_ SHELL : Variable que almacena el interprete de comandos que usa el usuario.
_ TERM : Variable que almacena el tipo de terminal desde el que se está trabajando.
_ TMOUT : Variable que almacena el tiempo de inactividad que se permite al usuario antes de que
el sistema le cierre la sesión.
163
Compilación de MINIX.
Para la compilación de MINIX una vez instalado, mencionamos que lo hicimos tanto para la versión
2 como para la versión 3, sin embargo, en este documento, mostramos como lo hicimos con la
versión 2.
Pero antes de esto, primeramente mencionaremos de manera breve como compilar de manera
general.
Pequeña guía de compilación de MINIX.

Para compilar MINIX se utiliza el comando make y los archivos Makefiles. Es importante que se
pueda entender las reglas utilizadas por el comando make en los Makefiles y que los mismos estén
actualizados.
Cada parte de MINIX puede ser compilada por separado, para ello se utiliza el comando:
make <modulo> donde modulo puede ser boot, kernel, mm, fs o tools
En el caso que se desee realizar una compilación completa del MINIX, se puede ejecutar el
comando:
make programs en el directorio tools.
Si la compilación de las partes fue satisfactoria, se linkearán generando un archivo imagen image,
que contiene la imagen del nuevo kernel de MINIX. Otra forma de realizar la compilación es
usando el comando make hdboot en el directorio tools.
A continuación se enumeran las posibles formas de realizar una generación y copia de la imagen
de MINIX.
make
Esto genera todas las diferentes partes del kernel y las junta en un archivo llamado image.
make fdboot
De la misma forma arriba pero luego genera un disquete booteable que puede ser usado para
iniciar el sistema. Se le pide que ingrese cual es el nombre del device para el disquete.
make hdboot
Primero crea el archivo image y luego lo copia en el directorio /minix. Si ya hay dos imágenes en
ese directorio entonces se elimina la más nueva para generar espacio. El monitor elige la imagen
más nueva en /minix para bootear, pero se puede usar el comando ls minix del monitor para ver
las imágenes presentes y setear la variable image a la que corresponda. Las imágenes en /minix
usan (release, versión, revisión) como nombres para poder distinguirlas.
164
Instalación de una nueva imagen.
Cuando se genera una imagen nueva, no se debe borrar la imagen original, por si existe algún
error no esperado. La forma de utilizar la nueva imagen, es indicando en el monitor de MINIX, cual
es la nueva imagen con la que debería inicializar el sistema. Esto se realiza presionando ESC,
cuando aparece el menú inicial al arrancar el minix. En el prompt del monitor se puede ejecutar el
comando set para ver los valores de las variables y ejecutar el comando image=<imagennueva>,
donde <imagennueva> debe indicar el camino completo hasta la imagen generada.
Compilación de MINIX 2.
Lo mostrado a continuación, corresponde a la posterior compilación del kernel de MINIX 2.
 Primeramente ingresamos al sistema operativo, para esto cuando nos aparece el boot
monitor, introducimos el signo de igual (=).
 Esta imagen de MINIX viene configurada para conectarse por medio de DHCP vía Telnet,
pero como no se le asigna IP, entonces da un error y sugiere presionar la DEL o SUPR para
obtener un root y verificar los problemas, hay que hacer esto.
165
 Para evitar esto, digitamos en el prompt “shutdown”, y luego de esto, estaremos en el
boot monitor, aca hay que digitar “servers = none” y luego “save” para guardar los
cambios, después “menu” para volver al menú del boot monitor.
 En este punto, al ingresar el signo igual (=), ya no tendría que dar esos problemas con el
servicio DHCP y tendría que pedirnos directamente el login, en el cual tenemos que decirle
en este caso “root”.
166
 Al hacer esto, ya tenemos que haber ingresado normalmente.
 Ya que todo está bien, lo siguiente es irnos al directorio /usr/src, ahí observaremos todas
las rutas que se han mencionado anteriormente (es decir las que contienen el código
fuente).
 Ahora bien, podemos irnos al directorio /minix, esto con el fin de observar la imagen que
se encuentra originalmente.
 El nombre que aparece con “mx204….” corresponde a la imagen que se tiene en ese
momento y desde la cual arranca el sistema.
167
 Ahora, compilemos el sistema, para eso nos vamos a la carpeta /usr/src/tolos, ahí
digitamos el comando “make hdboot”
 Al observar esto, significa que se ha empezado a compilar el sistema, cuando se termine

de compilar, tiene que aparecer esto:
 Podemos observar abajo, que aparece un comando “cp image…”, esto significa que se
acaba de crear una nueva imagen del kernel, y esta se ha copiado al directorio /minix, esto
significa que se esa nueva imagen es producto de la compilación del sistema.
 Para borrar los archivos objetos de la compilación, ejecutamos el comando “make clean”.
168
 Ahora, para comprobar lo de la imagen, vamos al directorio /minix y vemos las imágenes
presentes.
 Podemos observar que ahora hay dos imágenes, una de esas corresponde a la que
apareció en comando después de la compilación, esto significa que fue una compilación
satisfactoria, con esto, ya esta compilado nuestro sistema operativo.
 Para hacer que arranque esta nueva imagen, digitamos “shutdown” y una vez dentro del
monitor digitamos image=/minix/2.0.4r0 y luego “save”, después digitamos “menu” y
presionamos el signo igual (=).
 Con esto, el sistema tendría que arrancar con la nueva imagen sin ningún problema.
 Si todo ha ido bien, y quisiéramos compilar por módulos, nos situamos por ejemplo en la
parte del administrador de memoria y compilamos ese modulo, después un “make clean”
para limpiar de archivos objeto.
169
 Con esto, habremos compilado el modulo correspondiente al administrador de memoria
(MM).
 Hay que mencionar que como solo se compilo ese modulo, entonces no se ha generado
una nueva imagen, para eso hay que compilar todo el sistema.
Con esto, se ha finalizado esta descripción de la compilación de MINIX 2 recién instalado.
Modificación de algunos parámetros del boot monitor.

Con esta parte, se pretende customizar en pequeña proporción el boot monitor, el cual es el
gestor de arranque del sistema, haciendo las mismas del grub, es decir, permite arrancar MINIX,
pero también arrancar otros sistemas operativos como puede ser Linux, Windows, etc.
Primeramente se cambiara el mensaje que aparece en la parte superior del boot monitor, para eso
presionamos la tecla ESC cuando nos salga la siguiente imagen:
Ahora acá digitamos lo siguiente:
leader() echo \cSistemas Operativos \n\nPresione ESC para entrar al monitor
Ahora se agregara un pequeño mensaje que aparecerá abajo del recién modificado:
mensaje() echo UESOCC – Ciclo II / 2008
save
170
Después de esto, al reiniciar el monitor, aparecerá de la siguiente manera:
Ahora, agregaremos entradas a otros sistemas operativos, así como también que MINIX arranque
con y sin soporte de red.
Antes de todo hay que mencionar que se agregaran entradas para Windows y para Linux, aunque
estas serán ficticias, ya que donde está instalado MINIX solamente esta ese sistema, no hay otros,
pero en el caso que si hallan otros sistemas, lo que se explicara acá se aplica cuando se dé ese
caso.
Cuando nos aparezca la imagen anterior, presionamos la tecla ESC, luego digitamos la entrada
correspondiente a MINIX sin soporte de red, MINIX con soporte de red, Windows, Linux, y las
configuraciones necesarias para especificar el soporte de red.
m(=,Arrancar MINIX sin soporte de red) {sin_red;boot}
n(n,Arrancar MINIX con soporte de red) {con_red;boot}
w(w,Arrancar Windows) {boot c0d0p0}
l(l,Arrancar Linux) {boot c0d0p1}
sin_red() {servers=none;image=/minix/2.0.4r0}
con_red() {servers=inet;image=/minix/2.0.4r0}
save
Las primeras cuatro líneas corresponden a las entradas de los diferentes sistemas operativos, las
siguientes dos a las definiciones de las funciones con y sin red, y la ultima a guardar los cambios.
Si nos damos cuenta, en la parte de arranque de Windows y Linux después de la palabra boot
aparece c0d0p0 y c0d0p1, la nomenclatura es la siguiente: c0 corresponde al control cero del disco
duro, d0 corresponde al número de disco y p0/p1 al número de partición correspondiente, estos
números son supuestos, y dependerán de cómo tengamos estructuradas nuestras particiones.
171
Las letras que van al principio del paréntesis, significan que según que letra o signo se especifique,
al presionar esa tecla arrancara el sistema indicado, por ejemplo MINIX con red, la letra n, Linux
con l, etc.
Con lo explicado anteriormente, suponemos lo siguiente: Windows esta en el control cero, primer
disco duro y primera partición, Linux se encuentra en el control cero, primer disco duro y segunda
partición. Estos son datos supuestos, dependerá de la configuración de las particiones.
Con las dos líneas siguientes, simplemente definimos lo que harán las funciones que hemos
declarado en la parte de arranque de MINIX, simplemente en la función sin_red le decimos que no
habrán servicios con servers=none, luego especificamos la imagen a cargar que corresponde al
sistema recién compilado.
En la función con_red hacemos lo contrario, especificando servers=inet, al final va la ruta de la

imagen a cargar.
Hablando de la última línea, simplemente le decimos que guarde los cambios.
Introduciendo lo anterior, quedara de la siguiente manera:
Luego con los cambios aplicados quedara de la siguiente manera:
Con esto está concluida esta pequeña guía para la modificación de algunos parámetros del boot
monitor.
172
Pequeño manual del editor de texto vi.
Para las modificaciones del código fuente, utilizamos este editor de texto, pero para poder
utilizarlo, presentamos este pequeño manual.
Para editar un fichero hacemos:
# vi nombre_archivo
Una vez dentro del fichero podemos movernos con las teclas de dirección. Para insertar o borrar el
contenido, pulsamos las siguientes teclas (ojo en minúscula):
i = para empezar a escribir en la posición del cursor.
a = El cursor se sitúa en el próximo espacio en blanco después de la posición del cursor.
Una vez que hayamos terminado de insertar/modificar el fichero, pulsamos la tecla ESCAPE para
salir del modo INSERTAR.
Si nos hemos equivocado en algo, podemos deshacer los cambios mediante la combinación
siguiente:
:u
Para guardar los cambios hechos en el fichero, pulsamos:
:w
Ahora para salir pulsamos:
:q
Podemos simplificar las dos órdenes anteriores pulsando la siguiente combinación, que nos
guardará el fichero y saldremos del vim:
:wq
En el caso de que hayamos modificado el fichero y queramos salir sin guardar los cambios,
debemos forzar la salida del editor con la siguiente combinación.
:!q
NOTA:
Tener en cuenta que todos los comandos aquí expuestos son en minúscula. Si tenemos el bloqueo
mayúsculo activado, la orden producirá la acción que tenga asociada dicha letra mayúscula.
Para salir del modo insertar y poder introducir los comandos, pulsamos la tecla ESCAPE (ESC).
173
Modificación de mensaje de arranque del MINIX.
Con esta pequeña guía, se pretende dar una introducción para modificar el código de MINIX,
solamente cambiaremos el mensaje que aparece cuando MINIX ha cargado y nos pide el login,
para esto hacer lo siguiente:
Dentro de MINIX y como root, irnos al directorio /usr/src/kernel, luego corremos un ls, y veremos
que aparece un archivo llamado tty.c, tendremos que modificar ese archivo, en nuestro caso lo
haremos con el editor de consolar vi.
Ya dentro de este archivo, irnos a la parte correspondiente a tty_task, y ahí comentamos dos
líneas, printf(“Minix….” y la línea “OS REL…”, esto lo hacemos con el símbolo /* y */ al final del
comentario, luego digitamos debajo de esas líneas comentadas tres printf, tal como los que
aparecen en la imagen:
174
Luego guardamos los cambios, recompilamos el sistema como ya se ha explicado anteriormente,
le indicamos que arranque con la nueva imagen, y tendremos que observar los cambios.
Con esto, ya habremos hecho nuestro primer cambio al código de MINIX, y después de recompilar
el sistema, habremos observado los cambios, esto se ha hecho a manera de introducción, además
hay que recalcar que cuando haya un error de sintaxis, cuando compilemos no dejara el MINIX, y
nos dirá en que archivo y en qué línea esta el error, esto implica que no generara la nueva imagen
del kernel.
Dando funcionalidad a la tecla F6.

Normalmente la tecla F6 no hace nada, pero con esto que haremos ahora, ya tendrá que
funcionar, para esto le daremos la misma funcionalidad que la tecla F1, es decir que nos servirá
para visualizar los procesos del sistema.
Primeramente nos vamos a /usr/src/kernel, cuando estemos ahí, como nos habremos dado cuenta
anteriormente, hay un archivo llamado keyboard.c, y es ese archivo el que vamos a modificar, para
eso lo editamos con vi, tal como se ve en la imagen:
175
Nos vamos hasta sección correspondiente a func_key:
Después del case F5, agregamos lo siguiente:
176
Después de esto, recompilamos el sistema, indicamos la nueva imagen a cargar (si no la carga
automáticamente), y luego, al reiniciar el sistema y presionar la tecla F6 tendremos que ver lo
siguiente:
Si apareció eso, significa que hemos hecho una modificación satisfactoria; con esto hemos
pretendido romper el hielo, y tocar un poquito lo que es el código de MINIX.
Al menos, con esta versión hay una ventaja, si nos damos cuenta, cada vez que se genera una
nueva imagen del kernel, la imagen anterior se va borrando, pero si nos damos cuenta, la imagen
original siempre está intacta, es decir que en dado caso cometiéramos un error grave al
recompilar el MINIX y este no arrancara, podemos indicar que arranque desde la imagen original, y
con eso estaremos salvados.
177

Diseño e Implementacion de MINIX

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Diseño e Implementacion de MINIX

Cargado por

Copyright:

Formatos disponibles

Universidad de El Salvador

Facultad Multidisciplinaria de Occidente

Departamento de Ingeniería y Arquitectura

Proyecto sobre el diseño e implementación de MINIX

Catedrático: Tec. Edenilson López

Integrantes: Figueroa Landaverde, Miguel Gehovani

Vasquez Castaneda, Guillermo Rafael

Santa Ana, Martes 25 de noviembre de 2008

CAPA 3 - SISTEMA DE FICHEROS (FS) - /USR/SRC/FS. ................................................................................. 48

Otro componente de la tercera capa de MINIX, es El Sistema de Ficheros, el cual se puede

dev: Contiene los ficheros utilizados para el manejo de dispositivos de E/S.

minix: Contiene las imágenes ejecutables del sistema operativo MINIX.

mnt y mnt2: Directorios vacios.

root: Directorio para el usuario root.

usr: Acá se encuentran ficheros del sistema.

boot commands etc fs inet kernel lib mm test tmp tools

boot: Fuentes del sistema de arranque. tmp: Directorio vacio.

etc: Ficheros del administrador.

fs: Fuentes del sistema de ficheros (FS).

inet: Fuentes para soporte de red.

kernel: Fuentes del administrador de procesos y dispositivos de E/S.

lib: Fuentes de las librerías de las que hace uso MNIX.

mm: Fuentes del administrador de memoria (MM).

test: Fuentes del test para verificar MINIX.

ibm minix net sys

minix: Fuentes de archivos de cabecera utilizados por el sistema operativo.

net: Fuentes de archivos cabeceras para soporte de red.

sys: Contiene fuentes con cabeceras Pos adicionales.

A continuación se muestra el esquema del proceso de arranque de MINIX.

Para un mejor entendimiento del proceso de arranque, se mostrara el pseudocódigo y el código

3.2.- Se carga el primer sector físico de la unidad.

3.2.2.- Si la lectura tiene éxito, el siguiente paso consiste en comprobar si es de arranque:

a) Si no está la firma de arranque, se muestra un mensaje en pantalla: ‘Unidad no iniciable’ y se

b) Si está la firma, se continúa con el programa.

4.- Se salta al código cargado (bootstrap).

.define begtext, begdata, begbss, endtext, enddata, endbss, _main

; Encontrar (sub)partición activa, cargar su primer sector,

; Copia este código por seguridad, luego saltar a él.

getkey: xorb ah, ah ; Esperar a pulsar una

sort: mov si, bp ; Primera entrada de la tabla

bubble: lea di, PENTRYSIZE(si) ; Siguiente entrada

inuse: mov bx, lowsec+0(di)

exchg: movb ah, (si)

order: mov si, di

; Encontrar la partición activa.

error0: jb error1 ; No supuso fallo

; No partición activa, dimelo

; No hay particiones activas en esta unidad, intentar la próxima

nexthd: call load0 ; Leer el bootstrap del disco

; Cargar sector 0 desde el dispositivo actual. Es o el floppy del

; Cargar el sector lowsec(si) desde el dispositivo actual. Los

xorb dl, dl; Desplazamiento de los bits 8-9 del cilindro

bad: stc ; Poner bandera de acarreo

ok: cmp LOADOFF+MAGIC, #0xAA55

nosig: call print

; Ha ocurrido error en una lectura, reclamar y bucle infinito.

; Bucle infinito esperando por CTRL-ALT-DEL

print: pop si ; dirección de retorno

prnext: lodsb ; al = *si++ es el carácter a imprimir

2.- Se comprueba si se va a cargar de disco duro o de floppy.

3.- El monitor se empieza a cargar en la posición 0x1000:0x0000. Se entra en un proceso iterativo:

3.1.- Cargar el sector especificado en la posición de memoria es:bx.

3.2.- Se modifica la próxima posición de memoria: es:bx+512

3.3.- Si existe error, mostrarlo en pantalla y quedarse en un bucle infinito.