Diseño e Implementacion de MINIX
description
Transcript of 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
4
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.
5
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.
6
Estructura de MINIX. El sistema operativo MINIX está estructurado de la siguiente manera:
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.
bin dev etc fd0 fd1
minix mnt mnt2 root tmp
usr
root
7
Recorrido por los fuentes del MINIX - /usr/src - /usr/include. MINIX tiene su código fuente distribuido de la siguiente manera:
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.
boot commands etc fs
inet kernel lib mm tmp
tools
/usr/src
test
8
Además, hay que mencionar que también hay código fuente en otra ruta, la cual se muestra a
continuación:
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.
ibm minix net
/usr/include
sys
9
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.
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.
BIOS
Masterboot y tabla
de particiones
BootBlock
Boot Monitor
Imagen de MINIX:
Kernel, MM, FS, init
10
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).
11
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:
12
; ¿ 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
13
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
14
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
15
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
16
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
17
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.
18
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.
19
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
20
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
21
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
22
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
23
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:
24
Esquema de cabeceras del sistema de arranque.
Cabecera Descripción
Esquema de archivos fuentes del sistema de arranque.
Fuente Descripción
boot.c Boot Monitor, boot
secundario, carga y
arranca el MINIX.
bootblock.s
bootstrap para el
primer sector de la
partición activa, carga
el boot.
boothead.s Soporte de la BIOS
para el boot.c.
bootimage.c
Carga y ejecuta una
imagen del sistema
operativo.
doshead.c Soporte de DOS & BIOS
para el boot.c
installboot.c
Instala el sector de arranque
(bootblock), o instala el
ejecutable del MINIX (image),
para crear un disco de
arranque.
jumpboot.s Salta a otro bootstrap.
boot.h
Información entre
diferentes partes del
boot.
image.h
Información entre
diferentes partes del
boot.
rawfs.h Soporte para el
sistema de ficheros
tipo Raw.
25
Fuente Descripción
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
masterboot.s
Boot master de
arranque para el
primer sector del disco.
mkfhead.s Soporte de DOS & BIOS
para el mkfile.c
mkfile.c
Crea un archivo dentro
de DOS para usar en un
disco MINIX.
rawfs.c
Soporte para manejar
un sistema de ficheros
tipo RAW.
extboot.s
Boot master de
arranque para
particiones extendidas
de MS-DOS.
edparams.c Permite modificar
parámetros del
sistema.
26
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.
Cabecera Descripción
a.out.h
alloca.h Función alloca().
ansi.h
assert.h Contiene una macro a
la llamada “assert”.
configfile.h Configuración genérica
de formato de archivo.
ctype.h Define algunas macros
usadas para identificar
caracteres.
curses.h
Define macros y
prototipos para
“curses”.
Describe el formato de
los archivos
ejecutables.
Intenta decidir si el
compilador se ajusta lo
suficiente a Stándar C.
dirent.h
Declaración para el
directorio de lectura de
rutinas.
errno.h
Define los números de los
diversos errores que pueden
ocurrir al ejecutarse un
programa.
fcntl.h
Se necesita para las
llamadas open() y
fcntl().
float.h
Define algunos límites
de implementación
para coma flotante.
27
Cabecera Descripción
grp.h
Usado para las
llamadas getgrid() y
getgrnam().
lib.h Cabecera maestra
usada por las librerías.
limits.h Define algunos
tamaños básicos.
locale.h
Usado para los símbolos
de dinero, puntos
decimales y otros ítems
de estilo local.
math.h Contiene prototipos para
funciones matemáticas.
mathconst.h Constantes
matemáticas.
pwd.h Define ítems para los
archivos de password.
regex.h Código derivado del
software de contribución de
Berkeley.
regexp.h Usado por las rutinas
regexp().
setjmp.h
Usado para escapar de
la situación actual en
una situación previa.
sgtty.h Contiene estructuras
de datos para ioctl().
stdarg.h
Se encarga de un
variable número de
parámetros.
28
Cabecera Descripción
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.
stddef.h Define ciertos macros
normalmente usados.
stdio.h Definiciones de
entrada/salida.
stdlib.h
Define ciertas macros,
tipos y funciones
comunes.
string.g
Contiene prototipos
para las funciones que
manejan cadenas.
tar.h Usado con el
archivador tar.
termcap.h Define algunos
prototipos.
termios.h Usado para controlar
los modos tty.
time.h
Usado por los
procedimientos que
tratan con el tiempo.
tools.h Constantes que
describen el disco.
ttyent.h Usado por getttyent().
unistd.h Contiene constantes
diversas manifiestas.
utime.h
Usado para la llamada
al sistema utime().
utmp.h
Usado por init, login,
who, etc.
29
Esquema de cabeceras IBM - /usr/include/ibm
Cabecera Descripción
Esquema de cabeceras NET - /usr/include/net
Cabecera Descripción
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.
hton.h Convierte a un
estándar de red.
ioctl.h
Operaciones de control
de dispositivos con
respecto a la red.
netlib.h Librerías de net.
cmos.h
Definiciones para el
CMOS. Basado en el
Dallas DS12887.
diskparm.h
PC BIOS estructura
para los parámetros de
disco.
int86.h Tipos de interrupción
del 8086.
partition.h
Descripción de entrada
en la tabla de
particiones.
portio.h Entrada/Salida.
30
Esquema de cabeceras de MINIX - /usr/include/minix
Cabecera Descripción
callnr.h
cdrom.h
Contiene algunas
estructuras usadas por
Mitsumi cdrom driver.
com.h
com.h204
Números de tarea,
códigos de función y
códigos de contestación.
config.h
Fija parámetros de
configuración para el
kernel, MM y FS.
config.h204 Configuración de
parámetros para
kernel, MM y FS.
const.h Definición de
constantes.
Define el número de
llamadas.
Llamadas al sistema.
const.h204 Definición de
constantes.
dl_eth.h Estructura usada en
DL_GETSTAT.
fslib.h Soporte de funciones
de/hacia la memoria.
ioctl.h
Incluido por cada
archivo del título que
define los códigos del
ioctl.
jmp_buf.h Para usar con programas en
código ensamblador que
necesitan manipular el
jmp_buf.
31
Cabecera Descripción
keymap.h Define el mapa.
minlib.h Misceláneos de BSD.
partition.h
Lugar de una partición
en disco y la geometría
del mismo.
sound.h
Definiciones usadas en
/dev/audio y
/dev/mixer.
swap.h Define el superbloque de las
particiones swap y algunas
constantes usadas.
syslib.h
Prototipos del sistema
para funciones de
librerías.
type.h Definiciones de tipos.
u64.h
Funciones para
manipular direcciones
de disco de 64 bits.
32
Esquema de cabeceras de SYS - /usr/include/sys
Cabecera Descripción
asynchio.h
dir.h
ioc_disk.h Códigos de comando
de disco ioctl().
ioc_memory.h Códigos de comando
de memoria ioctl().
ioc_scsi.h Códigos de comando
de scsi ioctl().
ioc_sound.h Códigos de comando
de sonido ioctl().
Usado para programas
escritos para MINIX-vmd
que también deben correr
bajo el estándar MINIX.
Da la organización de
un directorio.
ioc_tape.h
Códigos de comando
de cinta magnética
ioctl().
ioc_tty.h Códigos de comando
de terminal ioctl().
ioctl.h Declara operaciones de
control de dispositivos.
mtio.h Comandos de cinta
magnética.
ptrace.h Definiciones para
ptrace().
sigcontext.h Es usada por la llamada
sigreturn().
stat.h Define la estructura
que se usa en las
funciones stat() y fstat.
33
Cabecera Descripción
svrctl.h
Servidor de control de
comandos que tienen
la misma codificación
como las ordenes para
ioctls.
times.h Es para la llamada al
sistema times().
types.h
Contiene definiciones
de tipos de datos
importantes.
utsname.h Da el nombre del
sistema.
wait.h
Contiene macros
relacionados con
wait().
34
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.
35
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).
36
Esquema de cabeceras del Administrador de Procesos / Tareas de E/S
Cabecera Descripción
assert.h
const.h Constantes generales
que utiliza el núcleo.
glo.h
kernel.h
Ésta es la cabecera
maestra del kernel;
incluye algunos otros
archivos y define las
principales constantes.
proc.h Tabla de procesos.
proto.h Aquí se crean los
Prototipos de
funciones.
sconst.h
Misceláneo de
constantes utilizadas
por el ensamblador
Comparación y
afirmación de
resultados de los
procedimientos.
Variables globales que
se utilizan en el núcleo
type.h Definición de tipos,
tasktab, stakframe_s.
protect.h Constantes para modo
protegido.
sconst.h
Constantes diversas
empleadas en código
ensamblador.
drvlib.h
Definiciones de
controlador de
dispositivos IBM.
37
Cabecera Descripción
driver.h
Tipos y constantes
compartidos entre el código
de controlador de
dispositivos genérico Y
dependiente del dispositivo.
sb16.h
Utilizados por los
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.
38
Esquema de archivos fuentes del Administrador de Procesos.
Fuente Descripción
mpx.s
mpx386.s
Manejo de
interrupciones para
386 o superior.
mpx88.s
start.c
Contiene el código de inicio
en C para Minix en
procesadores Intel; coopera
con mpx.s para establo buen
entorno para main().
i8259.c
Driver para el chip
i8259 controlador de
interrupciones.
exception.c
Este archivo contiene
un manejador de
excepciones sencillo,
interrupciones de la
CPU.
protect.c
Contiene código para
inicializar el modo
protegido, los descriptores
de segmentos de código y
de datos, y los descriptores
globales.
Elige entre las
versiones 8086 Y 386
del código de arranque
de Minix.
Manejador de las
interrupciones para 86.
klib.s
Escoge entre versiones
8086 y 386 de código
de kernel de bajo nivel.
39
Fuente Descripción
klib386.s
Procedimientos
utilizados por
mpx386.s
klib88.s Procedimientos
utilizados por mpx88.s
table.c
proc.c
Contiene el vector de
tareas.
Este archivo contiene
casi todo el manejo de
procesos y mensajes.
40
Esquema de archivos fuentes de Tareas de E/S.
Cabecera Descripción
main.c
Este archivo contiene
el programa principal
de MINIX.
driver.c
Este archivo contiene
interfaz de control de
independencia de
dispositivos.
drvlib.c
Funciones de utilería
de controlador de
dispositivos IBM.
memory.c Driver de memoria
principal.
floppy.c Driver de floppy.
wini.c
Driver de disco duro,
escoge controlador
winchester.
xt_wini.c Driver de un disco duro
tipo XT.
at_wini.c Driver para el disco
duro IBM-AT.
bios_wini.c Driver para disco duro
que utiliza la BIOS.
aha_scsi.c Manejador de disco
duro scsi
ps_wini.c Driver para el disco
duro de un ps.
esdi_wini.c
Parte dependiente de
dispositivo de disco
duro de controlador
para ibm/pc.
41
Cabecera Descripción
dmp.c Este archivo contiene rutinas de
vaciado para depuración.
mcd.c Manejador para un
CDROM.
clock.c
Driver del reloj. Inicializa la
tarea de reloj para Obtener
trabajo, procesarlo y veces
responder.
tty.c Driver para un terminal
tty.
pty.c Manejador para un
seudo terminal.
console.c Driver para el terminal
consola de IBM.
keyboard.c Driver para el teclado
ya sea PC o AT.
rs232.c Driver para los puertos
seriales rs232 en C.
printer.c Driver para la
impresora.
ne2000.c Manejador de red.
system.c
Esta tarea maneja la
interfaz entre el sist.
arch. y el kernel y entre el
administrador de
memoria y el kernel.
misc.c
Este archivo contiene
una colección de
procedimientos
diversos o misceláneos
42
Fuente Descripción
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.
sb16_dsp.c
Driver para DSP en una
tarjeta de sonido
SoundBlaster 16.
sb16_mixer.c
Driver para mixer en
una tarjeta de sonido
SoundBlaster 16.
dp8390.c
Contiene controlador de
dispositivo Ethernet para
dispositivos dp8390.
wdeth.c
Controlador para
Western Digital Plus o
WD800E3.
43
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
44
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)
45
Esquema de cabeceras del Administrador de Memoria.
Cabecera Descripción
const.h
glo.h Declaración de
variables globales.
mm.h
mproc.h Esta cabecera contiene
la tabla de procesos.
param.h
proto.h Definición de funciones
prototipo.
type.h
Constantes utilizadas
por el administrador
de memoria.
Cabecera principal del
mm, incluye algunos
otros archivos y
definiciones de las
principales constantes.
Sinónimos para las
variables de los
mensajes de entrada.
Acá se encuentran las
definiciones de tipos
locales, normalmente
esta cabecera está
vacía.
46
Esquema de archivos fuentes del Administrador de Memoria.
Fuente Descripción
main.c
table.c
Se encuentra la tabla
para mapear el
número de llamada
con rutina que la
realiza.
alloc.c
forkexit.c
Desde este archivo se
realizan las llamadas al
sistema FORK, EXIT,
WAIT y WAITPID.
exec.c
La llamada al sistema
EXEC está definida
dentro de este archivo.
break.c
Cuando se necesita
más memoria, se hace
esta llamada, para
obtener espacio entre
pila y datos.
signal.c
Este archivo maneja las
señales, por ejemplo
KILL, REBOOT, ALARM,
etc.
utility.c
Acá se encuentra el
programa principal de
la administración de
memoria
Aquí está la tabla de
huecos, la cual es
utilizada para los
espacios en blanco.
Contiene diferentes
rutinas utilizadas por el
MM, estas son: allowed,
no_sys, panic y tell_fs.
47
Fuentes Descripción
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.
getset.c
trace.c
Las funciones
contenidas en este
archivo son:
do_trace(), findproc y
stop_proc.
misc.c
putk.c
Sirve para la impresión
de mensajes, por
medio de las rutinas
putk() y flush().
Contiene la función
do_getset(), la cual
gestiona llamadas para
leer y escribir distintos
tipos de
identificadores.
Dentro de este archivo
se encuentran las
funciones: do_reboot y
do_svrctl.
48
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.
49
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.
50
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).
51
Esquema de cabeceras del Sistema de Ficheros.
Cabecera Descripción
buf.h
Cache de bloques
(buffers) del sistema de
ficheros.
const.h
Definición de
constantes utilizadas
por el sistema de
ficheros.
dev.h
Tabla de dispositivos,
enlaza el número
mayor con la rutina
que lo procesa.
file.h
Acá se encuentra la
tabla filp,
intermediario entre
descriptores de
ficheros e i – nodos.
fproc.h
En esta cabecera se
encuentra la tabla de
procesos.
fs.h
Cabecera maestra del fs,
incluye algunos otros
archivos y define las
constantes principales.
glo.h
Las variables globales
para el fs se
encuentran aquí.
inode.h Contiene la tabla de los
i – nodos.
lock.h Contiene la tabla de
candados.
param.h
Sinónimos de las
variables de los
mensajes de entrada
52
Cabecera Descripción
proto.h
Acá se encuentran los
prototipos de
funciones.
super.h
En esta cabecera se
encuentra la tabla de
superbloques.
type.h
Acá se encuentran las
definiciones de los
tipos.
53
Esquema de archivos fuente del Sistema de Ficheros.
Fuente Descripción
main.c
Acá se encuentra el
programa principal del
sistema de archivos.
table.c
Relaciona el número
de llamada al sistema
con la función que lo
maneja.
open.c
Las funciones
respectivas para abrir,
crear, cerrar ficheros
están acá.
write.c
Este archivo es un
complemento para la
escritura de ficheros,
ya que incluye
funciones específicas.
pipe.c
Sirve para la creación de
una tubería, así como
también tiene que ver
con la suspensión y
reanimación de procesos.
path.c
Busque de trayectorias
(rutas) en los
directorios.
mount.c
Las funciones del
montado y
desmontado de
dispositivos esta en
este archivo.
link.c
Este archivo es el
encargado de enlazar y
desenlazar ficheros.
54
Fuente Descripción
protect.c
Contiene las llamadas
al sistema para la
protección de ficheros.
mis.c
Conjunto de procedimientos, de
los cuales algunos realizan
llamadas al sistema simples y
otros realizan una parte de
algunas llamadas al sistema que
efectúa que el mm.
device.c
Lee bloques de disco
que no están en el
buffer.
inode.c Maneja la tabla de i –
nodos.
super.c Maneja la tabla de
superbloques.
filedes.c
Contiene tres
funciones para
manipular los
descriptores de
archivos.
lock.c
Contiene dos funciones
para el bloqueo de
ficheros.
cache.c
Mantiene un buffer
para reducir el acceso
al disco.
cache2.c
Indica los procedimientos
que se encargan de
manejar cache de
segundo nivel en disco
RAM.
stadir.c
Sirve para el cambio de
un directorio a otro, ya
que tiene las llamadas
correspondientes.
55
Fuente Descripción
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.
time.c
Contiene las llamadas
relacionadas con el
tiempo.
utility.c Contiene rutinas de
utilidad general.
putk.c Utilizado para exhibir
mensajes del fs.
56
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.
57
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.
58
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.
59
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.
60
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.
61
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:
62
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”.
63
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.
64
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.
65
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 >”.
66
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…”.
67
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.
68
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 >”.
69
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”.
70
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:
71
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.
72
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.
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 >”.
73
Damos un nombre a nuestra maquina donde instalaremos el MINIX, en nuestro caso digitamos “MINIX 3”, en el tipo de OS seleccionamos Other/Unknown, luego “Next >”.
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...”.
74
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”.
75
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.
76
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:
77
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”.
78
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.
79
Con esto, todo estará configurado, solamente hacemos clic en “Aceptar”.
Con esto, ya estamos listos para instalar MINIX en nuestra maquina virtual.
80
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.
81
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.
82
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).
83
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”.
84
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”.
85
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.
86
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.
87
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.
88
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 >”.
89
Aceptamos la licencia y luego clic en “Next >”.
Clic en “Next >”.
90
Clic en “Install”.
Aparecerá lo siguiente.
91
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”.
92
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.
93
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.
94
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.
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 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”.
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.
95
Una vez instalada la maquina virtual, ingresamos a esta por medio de Menu Inicio – Todos los programas – Sun xVM VirtualBox – VirtualBox.
Ya dentro de este, nos aparecerá la siguiente pantalla:
96
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 >”.
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.
97
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”.
98
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”.
99
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”.
100
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.
101
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.
102
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.
Ya dentro de este, nos aparecerá la siguiente pantalla:
103
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 3”, en el tipo de OS seleccionamos Other/Unknown, luego “Next >”.
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 >”.
104
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”.
105
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 >”.
106
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”.
107
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.
108
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.
Con esto, todo estará configurado, solamente hacemos clic en “Aceptar”.
Con esto, ya estamos listos para instalar MINIX en nuestra maquina virtual.
109
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”.
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”.
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.
110
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.
111
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).
112
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”.
113
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”.
114
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.
115
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.
116
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.
117
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.
118
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 >”.
119
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”.
120
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.
121
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.
122
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.
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 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”.
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.
123
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”).
124
Seleccionar la opción “Take Ownership”.
Esperamos a que cargue el archivo.
Seleccionar “I copied it” y luego “OK”.
125
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.
126
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”.
127
Clic en “Siguiente”
Seleccionar en “Typical” y “Siguiente”
Seleccionar “Other”, versión “Other” y “Siguiente:
128
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”
129
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”
130
Ya acá, nos vamos a la opción “CD-ROM (IDE 1:0). 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. 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.
131
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.
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”.
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.
132
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.
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).
133
Esperamos a que cargue, luego digitamos “root”, después “setup”.
Presionamos “Enter”
Ingresamos el tipo de teclado, si seleccionamos por defecto presionar “Enter”.
134
Seleccionamos la tarjeta de red, por medio del número correspondiente a la tarjeta mencionada, por defecto con “Enter”.
Seleccionamos el tipo de instalación: con la letra F significa Full y con la letra M Minimal.
135
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”.
136
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 Ctr-C.
137
Ahora hay que esperar a que se copien los archivos del sistema a la partición seleccionada.
Después de un rato, se habrán copiado todos los archivos y volveremos al prompt, donde debemos digitar “shutdown” y “Enter”.
138
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.
139
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.
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”.
Obtendremos una imagen ISO con el nombre “minix3_1_2a_ide_build2.iso”.
140
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.
141
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).
Esperamos a que cargue, luego digitamos “root”, después “setup”.
142
Presionamos “Enter”
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”.
143
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”.
144
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”.
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”.
145
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 Ctr-C.
Ahora hay que esperar a que se copien los archivos del sistema a la partición seleccionada.
146
Después de un rato, se habrán copiado todos los archivos y volveremos al prompt, donde debemos digitar “shutdown” y “Enter”.
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.
147
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:
148
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.
149
¡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:
150
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á.
151
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!
152
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
153
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.
154
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]. . .
155
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
156
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.
157
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
158
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
159
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
160
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.
161
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]
162
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
163
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.
164
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.
165
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.
166
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”.
167
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.
168
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”.
169
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.
170
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
171
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.
172
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.
173
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).
174
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:
175
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:
176
Nos vamos hasta sección correspondiente a func_key:
Después del case F5, agregamos lo siguiente:
177
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.