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.


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


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


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


Esquema de cabeceras NET - /usr/include/net


Dentro de este directorio esta otro llamado “gen”, el cual contiene muchas más cabeceras, sin

embargo las mencionadas anteriormente son las más principales.

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


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


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


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


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


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


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.


casi todo el manejo de

procesos y mensajes.

40

Esquema de archivos fuentes de Tareas de E/S.


main.c


el programa principal

de MINIX.

driver.c


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


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


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.


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.


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


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.

http://www.virtualbox.org/wiki/Downloads

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.

http://minix1.woodhull.com/pub/demos-2.0/VMWarePlayer/minix204vmwp01.zip

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.



73


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.

http://www.minix3.org/download/IDE-3.1.2a.iso.zip

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 >”.

http://www.virtualbox.org/wiki/Downloads

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.


PC-386-486-Pentium.

2MB de RAM.

30MB de disco duro.

Disquetera.





Ahora, lo descomprimimos, para esto, solamente hacemos uso del extractor que posee Windows, o en nuestro caso utilizando la utilidad de compresión/descompresión WinRAR, solamente hacemos clic derecho sobre el archivo y seleccionamos “Extract Here”.



95

Una vez instalada la maquina virtual, ingresamos a esta por medio de Menu Inicio – Todos los programas – Sun xVM VirtualBox – VirtualBox.


96



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.


103



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”.





110


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


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.


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


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.


115


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.


PC-386-486-Pentium.

2MB de RAM.

30MB de disco duro.

Disquetera.








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.





132


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


Presionamos “Enter”

Ingresamos el tipo de teclado, si seleccionamos por defecto presionar “Enter”.

134



135



136


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



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.




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).


142

Presionamos “Enter”

Ingresamos el tipo de teclado, si seleccionamos por defecto presionar “Enter”.


143



144



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.


146


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.

Documents

Diseño e Implementacion de MINIX