MINIX - SISTEMAS OPERATIVOS

FACULTAD DE INGENIERIA ELECTRONICA SISTEMAS OPERATIVOSIng. Eduardo Abanto Lopez

FACULTAD DE INGENIERIAELECTRONICA E INFORMATICA

SISTEMAS OPERATIVOS

Ing. Eduardo Abanto Lopez


MINIXEs un sistema operativo educacional, diseñado por Tanembaum con dos propósitos

básicos:

fácil de comprender

fácil de modificar

A nivel de usuario es muy parecido a UNIX(V7), si bien su realización interna es distinta.

MINIX = MINIUNIX

Sacrifica eficiencia por modularidad y comprensión

Soporta: MULTIPROCESO y MULTIUSUARIO

Funcionamiento MINIX es muy parecido a UNIX en cuanto a:

El procesador de comandos (SHELL BOURNE)

Los comandos

Las llamadas al sistema

Como todo sistema operativo MINIX se divide en cuatro partes

El administrador del procesador

El administrador de entrada/salida (manejadores de dispositivos)

El administrador de la memoria

El sistema de ficheros

El sistema está construido con módulos separados que comunican por un sistema de

mensajes


CARACTERISTICAS DE MINIX 2.0

* Este sistema operativo está diseñado para IBM PC o compatible (con los mismos chips

de I/O), no utiliza la BIOS), XT, AT, 360, PS/2 (8088, 80286, 80386, PENTIUM).

Existen versiones para ATARI, AMIGA, y MACINTOSH

Emuladores sobre UNIX y SUN

Precisa una partición de 30 MB

Contiene drivers para monocromo, CGA, HERCULES, EGA

Soporta hasta 16 MB de memoria (286) y 4GB en 386 y superior

Puertos: 2 RS232 (terminal adicional o modem)

Puerto CENTRONICS (impresora).

Controladores de disco duro: XT, AT, BIOS

Manejadores de red TCP/IP

Se distribuye como un CD

Llamadas al sistema compatibles con POSIX

Licencia libre para educación e investigación

Está escrito en C (ANSI y IEEE POSIX) basándose en el compilador Amsterdam

Compiler Kit, (Kernighan y Ritchie C), admite flags como:

-o la salida de la compilación es un fichero especificado en vez de a.out.

-D define una macro.

-I busca en un directorio determinado para los ficheros include.

Tiene un preprocesador para #define, #include, #ifdef

Linus Tovard, deció convertirlo en un sistema operativo competitivo con abundantes

herramientas de desarrollo y creo LINUX.


INSTALACION DE MINIXLos ficheros de MINIX se pueden obtener en las siguientes direcciones:

- De los creadores en la Universidad Libre de Amterdam

http://www.cs.vu.nl/~ast/minix.html

- Una copia de la misma en el web de la asignatura en

http://labsopa.dis.ulpgc.es

En el CD ROM que viene con el libro "Sistemas Operativos Diseño e implementación".

Segunda Edición. Tanenbaum. Prentice Hall.

CONTENIDO DEL CD ROM

BOCHS - Interprete 386 para simular MINIX sobre UNIX

COMPILER - Compiladores

DEBUGGER - El debugger de MINIX

DOSUTILS - Programas de MSDOS de ayuda para instalar MINIX

LISTING - Codigo fuente

MINIX - Directorio donde se encuentran los ficheros de MINIX

NETUTILS - Utilidades para instalar MINIX en red

SMX - Simulador de MINIX sobre SPARC - Solaris

DIRECTORIO /MINX

El directorio MINIX contiene la version 2.0 de MINIX en los siguientes ficheros y

directorios:

i386\ROOT - La imagen de boot y sistema de ficheros /ROOT

i386\USR - Parte basica del sistema de ficheros /USR para instalar

i386\USR.TAZ - Todos los programas de MINIX, librerias, resto de /USR

i86 - Directorio con version antigua de MINIX para PCs 286

SYS.TAZ - Fuentes de MINIX y manuales

CMD.TAZ - Fuentes de los comandos

INSTALL - Guia de instalación (ASCII text y PostScript)

MANUALS - Paginas de manuales

EXAMPLE.TXT - Un listado de pantalla ejemplo de instalación

NETINSTL.TXT - Comentarios para instalar MINIX en red

XT640K.TXT - Notas para ejecutar MINIX en PCs antiguos 286

fdvol.exe - Transiere desde el CD ROM a floppy

http://www.cs.vu.nl/~ast/minix.html

http://labsopa.dis.ulpgc.es


MÍNIMO HARDWARE REQUERIDO MINIX 2.0 (versión 32 bits)

PC 386-486-PENTIUM

2MB RAM

30 MB Disco

disquetera 3.5"

Video CGA, EGA, VGA

Antes de comenzar la instalación de MINIX hay que leer en el siguiente orden los

ficheros:

Readme.txt en el directorio raiz del CD ROM

Readme.txt en el directorio MINIX

Install en el directorio MINIX

Para instalar MINIX en un disco duro, desde un CD ROM hay que ralizar los siguientes

pasos:

1 Pasar los ficheros de distribución de MINIX (xxx.TAZ, archivos tar comprimidos) en el

CD a floppies

El programa fdvol.exe transfieren ficheros del CD ROM a floppies ya formateados

fdvol 1440 A: i386\ROOT i386\USR

- Crea el disco de arranque boot con

el sector de arranque, mas el kernel del s.o.

dos particiones sobre el floppy fd0a para el sistema de fichero ROOT y fd0c para el

sistema básico de fichero /USR

fdvol 1440 A: i386\USR.TAZ - sistema basico 3 floppies

fdvol 1440 A: SYS.TAZ - fuentes del sistema 2 floppies

fdvol 1440 A: CMD.TAT - fuentes de los comandos 3 floppies

2 Crear una partición primaria en el disco duro para MINIX > 30 MB

El programa part (MINIX), maneja las particiones.

El programa fdisk (MSDOS), maneja las particiones.

3 Transferir los ficheros desde los floppies a la partición MINIX

Arrancar MINIX desde floppy con el disco BOOT

Pulsar la tecla = en las opciones del menu


Escribir fdoc para indicar desde donde cargar /USR

Entrar en el sistema log in como root

Ejecutar setup

Introducir el tipo de teclado spanish

Si necesita crear una partición para MINIX, ejecute part

Introduzca el nombre de la partición creada por ejemplo /dev/hd2

Se crearan dos particiones /dev/hd2a de 1440 kb para /ROOT, y

/devhd2c con el resto para /USR

Se copian ficheros desde floppy a la partición

Si la memoria RAM >= 4MB se crea una memoria cache de segundo nivel en RAM de

1MB para transferencia de ficheros

En este punto la imagen del sistema operativo, y un sitema de ficheros mínimo ya estan

cargados en la partición por lo que el sistema ya es operativo. Se puede rearrancar el

sistema con halt

Ejecutar setup /usr para copiar los 3 floppies /USR

Si se desea instalar los fuentes:

Ejecutar setup /usr para copiar los 2 floppies /SYS

Ejecutar setup /usr para copiar los 3 floppies /CMD

ARRANCAR MINIX* No utiliza la ROM BIOS ya que la BIOS no está manejada por interrupciones lo que lahace inservible para sistemas en tiempo compartido.

* Programa directamente todos los circuitos de I/O.

- PASOS A SEGUIR.

1) Encienda el computador

Cuando el computador se enciende, se ejecuta un programa "BIOS", cargado en la ROMdel sistema, este busca un fichero ejecutable "MASTER BOOTSTRAP" en el primer sectordel floppy o del disco duro, el código se encuentra en el fichero masterboot.s, lo carga enmemoria en la posición 0x7C00 y le da control, contiene la tabla de particiones del disco;este busca el programa "BOOTSTRAP" o "BOOTSECTOR" en el primer sector de lapartición activa, su código se encuentra en el fichero bootblock.s, y le da control; estebusca el programa "BOOT MONITOR", en el directorio raiz, cuyo fuente se encuentra enboot.c, lo carga en memoria 0x10000 y le da control, este carga en memoria 0x00800 laimagen ejecutable del sistema operativo "MINIX", que se encuentra en el directorio/MINIX, y contiene las partes del sistema operativo kernel, mm, fs, init. Posteriormente se


ejecuta el S.O. en el punto de entrada MINIX de mpx.s

2. Aparece en pantalla el mensaje

Minix boot monitor 2.5

Pres ESC to enter the monitor

Hit a key as follows:

= Start Minix

al presionar la tecla " = "

3. MINIX borra la pantalla y presenta una linea en la parte superior con

Minix 2.0.0 Copyright 1997 Prentice Hall


Executin in 32-bit protect mode

Memory size=8010K MINIX=295K RAM disk=480K Available=7236K

- Memoria total del micro.

- Memoria ocupada por el S.O. MINIX (incluyendo tablas y buffers).

- Tamaño del disco virtual RAM.

- Memoria disponible para los usuarios, esta no debe ser negativa y se necesitanal menos 200k para trabajar.

4. El sistema de ficheros ROOT se copia en el disco virtual RAM.

5. El sitema de ficheros en la partición MINIX (hd2c) se monta en /USR

/dev/hd2c is read-write mounted on /usr

6. Se ejecuta el fichero de iniciación del sistema /etc/rc

# Inicializa de algunos ficheros del administrador como:

/etc/mtab - fichero con los mounts realizados

/etc/utmp - guarda los logins realizados

7. Lanza en modo tanda varios comandos update (sync cada cierto tiempo)

Starting standard daemons: update

Minix Release 2.0 version 0

8. Presenta en pantalla login:

teclee el nombre root

cuidado MINIX distingue entre mayúsculas y minúsculas

9. Si ha entrado en el sistema, se ejecuta el procesador de comandos SHELL y nospresenta su símbolo (# para el root $ un usuario normal) indicando que esta listo para:

- Aceptar un comando.

- Editar un fichero.

- Montar un sistema de ficheros. (/etc/mount /dev/fd0 /user)


10. Para despedirse del sistema.

- Si existen procesos ejecutandose en modo tanda debe terminarlos con el comando kill.

- Ejecutar el comando sync, (almacena en disco cualquier buffer pendiente).

CTRL-d. Despide la sesión y aparece el mensaje

login: y se puede entrar otra vez

Para apagar el computador, escriba shutdown

The system will shutdown NOW

COMO USAR MINIXA nivel de usuario MINIX trabaja como UNIX estándar POSIX

- El procesador de comandos SHELL funcionalmente es el mismo que (V7).

- Redirecciona los ficheros estandar de entrada salida > <.

- Ampersand (&) para lanzar un proceso en modo tanda.

- Tiene pipe |. ejem. cat aaa bbb ccc | sort > ddd &- Caracter mágico en nombres de ficheros (*,?) .

- Dos puntos para separar varios comandos en una línea :.- Admite ficheros de comandos "script" con las estructuras if, for, while, case.

- CTRL-h borra caracter izquierdo del cursor.

- @ borra la línea.

- CTRL-s, CTRL-q bloquea y desbloquea la pantalla.

- CTRL-d indica el fin de fichero desde el teclado.

La función de estas teclas puede cambiarse utilizando:

La llamada al sistema IOCTL. - El comando stty

Una de las mayores diferencias entre MINIX y UNIX son los editores:

editores de UNIX editor de MINIX

ed ed

emacs mined

elle

vi elvis


ed editor de linea muy sencillo.

mined es un editor de pantalla, pequeño, rápido y fácil de aprender.

elle editor de ventanas, multifichero, con la filosofia de emacs.

elvis funcionalmente igual al vi, y ex de UNIX Berkeley.

LA ESTRUCTURA DE FICHEROS EN MINIXMinix utiliza para el directorio una estrucutra en árbol.

El directorio ROOT siempre está ubicado en memoria RAM y contiene los

siguientes subdirectorios:

/bin - contiene los programas binarios (ejecutables) más utilizados. (resto en

/usr/bin).

/dev - contiene ficheros especiales para los dispositivos de I/O

/etc - contiene ficheros y programas para la administración del sistema y

miscelaneos

/fd0 - directorio vacio para ubicar un FS del usuario

/fd1 - directorio vacio para ubicar un FS del usuario

/minix - contiene la imagen ejecutable del sistema operativo

/mnt - directorio vacio

/root - directorio para el root

/tmp - utilizado para contener ficheros temporales

/usr - el disco del sistema se monta aquí

contiene ficheros de inicialización

.ellepro.b1

.exrc


.profiley boot el Boot Monitor

SUBDIRECTORIO /bindebe contener los programas utilizados más frecuentemente, ya que se encuentra

en RAM.

cat, date, echo, expr, false, fsck, halt, loadkeys, mount, printroot, pwd, readclock,

reboot, sh, sync, test, true, umount

SUBDIRECTORIO /dev contiene ficheros especiales para los dispositivos de I/O

Mayor dev, menor dev

Memoria 1

/dev/ram 1,0 - el disco virtual RAM

/dev/mem 1,1 - memoria absoluta, leer de este fichero es leer desde el byte 0 (el

vector de interrupciones)

/dev/kmem1,2 - memoria del núcleo, comienza en la posición 0x600

/dev/null 1,3 - equipo nulo (los datos escritos en el se pierden)

/dev/port 1,4 - acceso a los puertos I/O en modo protegido.

Floppy 2

/dev/fd0 2,0 - lee o escribe en el disco floppy 0, 5.25", 360K

/dev/fd0a 2,

/dev/fd0b 2,

/dev/fd0c 2,

/dev/fd0d 2,

/dev/fd1 2,1 - disco 1, 5.25", 360K

/dev/pc0 2,4 - disco 0, 5.25", 360K

/dev/pc1 2,5 - disco 1, 5.25", 360K

/dev/at0 2,8 - disco 0, 5.25", 1.2M

/dev/at1 2,9 - disco 1, 5.25", 1.2M

/dev/ps0 2,16 - disco 0, 3.5" , 720K

/dev/ps1 2,17 - disco 1, 3.5" , 720K


/dev/pat0 2,20 - disco 0, 5.25 , 1.2M

/dev/pat1 2,21 - disco 1, 5.25 , 1.2M

/dev/PS0 2,28 - disco 0, 3.5" , 1.44M

/dev/PS1 2,29 - disco 1, 3.5" , 1.44M

Disco duro3

/dev/hd0 3,0 - manejador del disco duro 0, todo el disco

/dev/hd1 3,1 - manejador del disco duro 1 todo el disco

/dev/hd1a 3, - manejador del disco duro 1 partición 1

/dev/hd1b 3,

/dev/hd1c 3,

/dev/hd1d 3,

/dev/hd2 3,2 -

/dev/hd3 3,3 -

/dev/hd4 3,4 -

/dev/hd5 3,5 - manejador del disco duro 1, todo el disco

/dev/hd6 3,6 - " " " " partición 1

/dev/hd7 3,7 - " " " " " 2

/dev/hd8 3,8 - " " " " " 3

/dev/hd9 3,9 - " " " " " 4

Terminales 4

/dev/console 4,0 - terminal 0 (principal)

/dev/log 4

/dev/ptyp0 4,0 - terminal 0 (consola) igual que /console

/dev/ptyp1 4,1 - RS232-C puerto 1

/dev/ptyp2 4,2 - RS232-C puerto 2

/dev/ptyp3

/dev/tty00 4

/dev/tty01 4

/dev/ttyc1 4

/dev/ttyp0 4

/dev/ttyp3 4


Terminal anónimo 5

/dev/tty 5,0 - terminal actual, en monousuario coincide con la consola

Impresora 6

/dev/lp 6,0 - es un fichero solo de escritura, escribe los byts en la impresora sin

modificarlos. Tipo Centronics.

TCP/IP 7

/dev/eth 7,0 - Ethernet

/dev/ip 7,

/dev/tcp 7

/dev/udp 7

CD-ROM 8

/dev/cd0 8,0

/dev/cd1 8,1

/dev/cd1

[a,b,c,d]

/dev/cd2 8,6

/dev/cd3 8,

/dev/cd4 8,

Discos SCSI 10

/dev/rst4 10

/dev/sd0 10

/dev/sd0a 10

/dev/sd0b 10

/dev/sd0c 10

/dev/sd0d 10

/dev/sd1 10

/dev/sd2 10

/dev/sd3 10

/dev/sd4 10

/dev/sd9 10

Audio 13


Mixer 14

mknod - crea un fichero especial ejem. mknod /dev/pc2 b 2 6 360

/dev/pc2 - fichero especial, b - transferencias por bloque 2 - numero Mayor, 6 -

numero menor, 360 - tamaño 360K

Tipos de ficheros-device para floppys

Nombre MINOR

dev

Pulg Drive Floppy Tamaño Parámetros

/dev/fd0 0 5.25 360K 360K/1.2M Todo Variable

/dev/fd1 1 5.25 360K 360K/1.2M Todo Variable

/dev/pc0 4 5.25 360K 360K 360K Fijo

/dev/pc1 5 5.25 360K 360K 360K Fijo

/dev/at0 8 5.25 1.2M 1.2M 1.2M Fijo

/dev/at1 9 5.25 1.2M 1.2M 1.2M Fijo

/dev/qd0 12 5.25 720K 360K 360K Fijo

/dev/qd1 13 5.25 720K 360K 360K Fijo

/dev/ps0 16 3.5 720K 720K 720K Fijo

/dev/ps1 17 3.5 720K 720K 720K Fijo

/dev/pat0 20 5.25 1.2M 360K 360K Fijo


/dev/pat1 21 5.25 1.2M 360K 360K Fijo

/dev/qh0 24 5.25 1.2M 720K 720K Fijo

/dev/qh1 25 5.25 1.2M 720K 720K Fijo

/dev/PS0 28 3.5 1.44M 1.44M 1.44M Fijo

/dev/PS1 29 3.5 1.44M 1.44M 1.44M Fijo

SUBDIRECTORIO /etc

Contiene parte de los ficheros de datos y configuración del sistema,

otros se encuentran en /usr/etc.

/etc/ethers - fichero con datos de direcciones ethernet

/etc/fstab - tabla del sistema de ficheros

/etc/group - contiene nombres de los grupos de usuarios

/etc/hostname.file - nombre del sistema local

/etc/hosts - fichero de datos de direcciones TCP/IP

/etc/hosts.equiv - dirección equivalente para la red

/etc/keymap - mapa de teclas para el teclado

/etc/motd - mensaje de inicio en el login.

/etc/mtab - creado al iniciarse para base de datos de los mounts

/etc/passwd - fichero con los usuarios del sistema

/etc/psdatabase - información del núcleo para el comando ps

/etc/profile - fichero de inicio para el shell

/etc/rc - fichero script para inicio del sistema

/etc/resolv.conf - nobre del sistema para el dominio TCP/IP

/etc/services - nombres para los servicios TCP/IP

/etc/shadow - fichero con las paswords encriptadas


/etc/termcap - secuencias de escapes para el terminal de Berkeley

termcap

/etc/ttys - activa o desactiva lineas RS232 para usarse por un terminal.

Contiene una línea por cada terminal en el sistema, inicialmente un

terminal de consola, contiene el valor 100. Cuando el sistema arranca,

el programa init lee este fichero y lanza un proceso para cada terminal.

/etc/ttytype - configuración del terminal

/etc/umount - desmonta un sistema de ficheros.

/etc/utmp - creado al iniciarse para almacenar los logins

SUBDIRECTORIO /fd0 y SUBDIRECTORIO /fd1

Directorios vacios para que el usuario monte su sistema de ficheros.

SUBDIRECTORIO /minix

Contiene la imagen ejecutable del sistema operativo minix

SUBDIRECTORIO /mnt

Directorio vacio

SUBDIRECTORIO /root

Directorio para el usuario root.

SUBDIRECTORIO /tmp

Lo utilizan los programas para situar ficheros temporales, se situa en

RAM para que los programas sean más rápidos. Existe otro en /usr/tmp

SUBDIRECTORIO /usr - ficheros del sistema

/usr/adm - el fichero /usr/adm/wtmp contiene record de login y logout

/usr/ast - home directorio para el usuario Andrew S. Tanenbaum

/usr/bin - contiene los ejecutables binarios, cc, cp, ls, man,...


/usr/etc - directorio del administrador

/usr/include - ficheros cabecera para el sistema

/usr/include/minix - ficheros cabecera especificos para MINIX

/usr/include/sys - mas ficheros cabecera

/usr/lib - librerias para el compilador y otros soportes

/usr/lib/cawf - ficheros para formatear texto

/usr/lib/tmac - macros para nroff

/usr/lib/dict - lista de palabras American English

/usr/lib/libc.a - librería compilada solo para minix 1.5 (8086)

/usr/local - software local

/usr/local/bin - utilidades locales

/usr/local/man - paginas locales del manual

/usr/local/src - fuentes locales

/usr/man - directorio con las paginas del manual

/usr/man/cat* - paginas del manual preformateadas

/usr/man/man0 - sección 0, libro de estilos de los comandos de usuario

/usr/man/man1 - comandos de usuario

/usr/man/man2 - llamadas al sistema

/usr/man/man3 - librería con rutinas

/usr/man/man4 - ficheros asociados a equipos

/usr/man/man5 - formatos de los ficheros

/usr/man/man6 - juegos

/usr/man/man7 - misceláneos

/usr/man/man8 - utilidades del sistema

/usr/man/whatis - tabla de paginas del manual

/usr/mdec - código del bootstrap

/usr/preserve - buffers para el editor elvis

/usr/spool - directorios especiales de spool

/usr/spool/at - directorio de spool para at

/usr/spool/lpd - directorio spool para impresora (futuro)


/usr/spool/mail - directorio spool para mail

/usr/spool/uucp - directorio spool para kermit y uucp (futuro)

/usr/src - raiz del arbol de los fuentes del sistema y comandos

/usr/src/boot - Monitor Boot

/usr/src/LICENCE - licencia para utilizar MINIX

/usr/src/commands - fuentes de los comandos

/usr/src/inet - fuentes para la red TCP/IP

/usr/src/fs - fuentes del manejador de ficheros fs

/usr/src/lib - directorio de fuentes de librerias

/usr/src/lib/amiga - fuentes de librerias para amiga

/usr/src/lib/ansi - fuentes de librerias para procedimientos C

/usr/src/lib/atari - fuentes de librerias para atari

/usr/src/lib/ibm - fuentes de librerias para ibm-pc

/usr/src/lib/mac - fentes de librerias para macintosh

/usr/src/lib/other - fuentes de otras librerias

/usr/src/lib/posix - fuentes de librerias para POSIX

/usr/src/lib/string - fuentes para manejo de strings

/usr/src/kernel - fuentes del nucleo kernel

/usr/src/mm - fuentes del manejador de memoria mm

/usr/src/user - directorio para colocar a los usuarios

.ashrc - para el arranque del Ash (shell)

.ellepro.b1 - para el arranque del editor Elle (compilado)

.ellepro.e - para el arranque del editor Elle (texto)

.exrc - para el arranque del editor Ex/vi

.profile - para el arranque del shell de un usuario

.rhosts - fichero de permisos para usuarios remotos

/usr/src/test - fuentes y binarios para hacer test

/usr/src/tools - utilidades para construir disco boot de MINIX

/usr/src/tmp - directorio para ficheros temporales


FICHEROS .profile

Cuando se hace un logín, se ejecuta el SHELL y este mira si en el

directorio del usuario existe un fichero .profile y si lo encuentra lo

ejecuta, este fichero contiene comandos y variables para el SHELL y

parámetros para stty.

Ejemplo /usr/ast/.profile

HOME= /usr/ast

PATH=:/bin:/usr/bin:user/bin: HOME/bin:

m= "/etc/mount /dev/fd0/user"

n= "/etc/umount /dev/fd0"

m1="/etc/mount /dev/fd1/user"

n1="/etc/umount /dev/fd1"

export PATH HOME PS1 PS2

Las teclas de función F1 y F2 hacen que aparezcan algunas tablas del

sistema sobre la pantalla.

F1 muestra la tabla de procesos, los valores que aparecen en la

columna user y sys son el número de pulsos de reloj cargados a

cada proceso.

MONTAR UN SISTEMA DE FICHEROS

El comando montar /etc/mount ó la llamada al sistema

MOUNT, permiten enganchar un sistema de ficheros en disco con elárbol principal, situado en memoria RAM.

Dada la situación de la figura.


Si ejecutamos el comando /etc/mount /dev/fd0 /b la situación finales:

Si se desea quitar el disco, hay que realizar la operación inversadesmontar el disco o bien con la llamada al sistema UMOUNT ó con elcomando:

desmontar disco 1 /etc/umount /dev/fd0


SUPER USUARIO

Los super usuarios tienen mayor capacidad que los usuarios normales.

Pueden cambiar todas las protecciones.Tienen un indicador de SHELL especial #.

Para entrar como super usuario haga un logín como root,

O bien utilice el comando su.

El comando su, crea otra sesion de shell, por lo que se consume memoria.

Algunos comandos como mkfs, chown, mknod solo pueden ejecutarse por elsuper usuario.

HACER UN NUEVO SISTEMA DE FICHEROS

El sistema de ficheros en MINIX incluye.

root/usr

La única diferencia entre estos sistemas de ficheros (a parte de su contenido)es su tamaño.

El tamaño del disco virtual RAM se calcula dinámicamente cuando el sistemaarranca, leyendo el superbloque de root.

Una vez formateado el floppy o la partición del disco, una de las cosas que elsuper usuario hace es crear un nuevo sistema de ficheros con el comando

mkfs

y luego copiar ficheros en él.

Cuando se crea un sistema de ficheros nuevo se escribe en el superbloque, elnúmero de bloques (1k) y el número de nodos.

El comando df /dev/fd0 muestra bloques y nodos libres del disco

Ejemplo: Hacer un sistema de ficheros vacio de 360 bloques en el disco 1.

mkfs /dev/fd0 360


Se puede construir un sistema de ficheros inicializado con directorios yficheros.

mkfs /dev/fd0 proto

donde proto es un fichero prototipo que contiene las inicializaciones delsistema de fichero a crear.

PROBAR UN SISTEMA DE FICHEROSPara probar un sistema de ficheros: se utiliza el comando

fscklee los i-nodos, el mapa de bits, el directorio y comprueba si el sistema de ficheros es

consistente y presenta un mensaje.

ejemplo para reparar /dev/hd1

cd/

cp /usr/bin/fsck /fsck

/etc/umount /dev/hd1

fsck -a /dev/hd1 -a reparación automática

/etc/mount /dev/hd1 /usr

EL FICHERO ETC/PASSWORDEste fichero es utilizado por el super usuario, editando este fichero se pueden introducir

nuevos usuarios, añadiendo nuevas líneas del tipo:

1 2 3 4 5 6 7

SANTIAGO

::

15

:

3

:

SANTIAGO

CANDELA :/user/CANDELA: / bin/sh

1 nombre

2 password inicialmente nula

3 uid

4 gid

5 nombre completo

6 directorio asociado

7 SHELL asociado

Cuando se crea un nuevo usuario dos pasos más hay que seguir.

Crear su directorio (en el ejemplo /user/Juan) con el comando mkdir.


mkdir(directorio,04777)

Colocar su propietario correctamente con el comando chown.

chown(directorio,uid,gid)

Cada usuario tiene que tener un uid único. Pueden existir varios usuarios con

el mismo grupo. Cuando el nuevo usuario entra en el sistema deberá crearse

una clave con el comando passwd.

MODIFICAR EL SISTEMA DE FICHEROS ROOT

MINIX viene con los sistemas de ficheros.

root /usr

Cuando el sistema se arranca el sistema de ficheros root se copia en memoria principalen el disco virtud RAM.

Cualquier modificación en los ficheros o directorios del árbol principal (root) en memoriaRAM, hay que guardarla en disco con el comando cp si no se quiere perder al apagarse elsistema.

Los contenidos de los sistemas de ficheros pueden ser reorganizados,realizando mount y cp secuencialmente y conseguir que los programas más utilizados seencuentren el el root, si bien hay que guardar la precaución de guardar al menos 100kpara /tmp.

COMANDOS DE MINIX

Los comandos de MINIX a nivel de usuario tienen el mismo nombre y sintaxis que susequivalentes a UNIX, por lo que se puede consultar cualquier manual de este último paraobetener una mayor información.

ar.- Archivador.

Mantiene archivos y librerías.

* añade ficheros al archivo

* borra ficheros del archivo

* lista de contenido del archivo

* reemplaza ficheros

* extrae ficheros del archivo


asld.- Ensamblador cargador. Es el ensamblador cargador combinado de MINIX.

basename.- quita sufijos y prefijos de un fichero.

cat.- Concatena ficheros y los visualiza en la salida estándar.

cc.- El compilador de C.

Ejecuta cinco pasadas.

Programa entrada salida operación efectuada

/lib/cpp prog.c prog.i Preprocesador de C: #include, #define, #ifdef.

/lib/cem prog.i prog.k Análisis semántico

/usr/lib/opt prog.k prog.m Optimización del código intermedio

/usr/lib/cg prog.m prog.s Generación de código

/usr/bin/asld prog.s a.out Ensamblado y lincado

chmem.- Cambia la asignación de memoria.

chmod.- Cambia las protecciones de un fichero.

chwn.- Cambia el propietario.

clr.- Borra la pantalla.

cmp.- Compara dos ficheros.

comm.- Presenta las líneas comunes a dos ficheros.

cp.- Copia ficheros.

date.- Presenta la fecha y la hora.

dd.- Volcado de disco.

df.- Presenta el número de bloques y nodos libres.

dosdir.- Lista el directorio de un disco MS.DOS.

dosdir 0


dosread.- Lee un fichero de un disco MS.DOS.

dosread 0 -a prog.c > /user/nomina/prog.c

doswrite.- Escribe un fichero en un disco MS.DOS.

doswrite -a 0 prog.c < /user/nomina/prog.c

echo.- Presenta la string continuación de este comando.

getlf.- Espera hasta que se pulse return.

grep.- Busca una string dentro de un fichero.

gres.- Busca una string y la sustituye por otra.

head.- Presenta las primeras líneas de un fichero.

kill.- Envia una señal a un proceso.

libpack.- Empaqueta un fichero ASCII.

libupack.- Desempaqueta un fichero a ASCII.

ln.- Crea un enlace (sinónimo) a un fichero.

lpr.- Imprime fichero por impresora.

ls.- Lista el contenido del directorio.

make.- Mantiene actualizado un conjunto de programas.

mined.- Editor del MINIX.

mkdir.- Crear un directorio.

mkfs.- Crea un sistema de ficheros.

mknod.- Crea un fichero especial.

mount.- Monta un sistema de ficheros.

mv.- Mueve o renombra un archivo.

od.- Presenta el contenido de un fichero en varios formatos.

passwd.- Cambia la palabra clave de acceso.


pr.- Presenta el contenido de un fichero.

pwd.- Presenta el directorio actual de trabajo.

rev.- Lista un fichero invirtiendo los caracteres de las líneas.

rm.- Borra un fichero.

rmdir.- Borra un directorio.

roff.- Formateador de texto.

sh.- El procesador de comandos shell.

shar.- Archivo shell.

size.- Presenta el tamaño del código, datos y bss de un programa.

sleep.- Duerme un proceso durante un tiempo.

sort.- Ordena un fichero ASCII.

split.- Trocea un fichero en varios ficheros pequeños.

stty.- Coloca parámetros para el terminal.

su.- Para entrar temporalmente como otro usuario.

sum.- Calcula los bloques y la prueba de suma de un fichero.

sync.- Escribe buffer a disco.

tail.- Escribe las últimas líneas de un fichero.

tar.- Archivo con formato de cinta.

tee.- Copia la entrada estándar a la salida estándar y en uno o más ficheros.

time.- Presenta cuanto tiempo gasta un comando.

touch.- Actualiza la fecha de modificación de un fichero.

tr.- Traduce códigos de caracteres.

true.- Devuelve el valor verdadero.

umount.- Desmonta un sistema de ficheros.


uniq.- Borra líneas iguales consecutivas de un fichero.

update.- Periódicamente escribe el buffer a disco.

wc.- Cuenta, líneas, palabras y caracteres de un fichero.

FORMATOS DE FICHEROS

MINIX tiene tres tipos de formatos para tres clases de ficheros.

ficheros ejecutables.archivos.módulos de librerias.

FORMATO DE LOS FICHEROS EJECUTABLES (a.out)

Un fichero ejecutable tiene tres partes.

ENCABEZAMIENTO

PROGRAMA

INICIALIZACION

DE DATOS

El segmento de datos no inicializados (bss) no está presente en los ficherosejecutables.

Este sistema operativo soporta dos modelos de memoria.

MODELO PEQUEÑO - 64K para programa + datos + stack.

MODELO SEPARADO ID

64K para programa64K para datos + stack

Un encabezamiento normal consiste de 8 palabras de 4 bytes (32 bytes)

0:0x04100301L (modelo pequeño), ó 0x04200301L (separado I,D)


1:0x00000020L (encabezamiento de 32 bytes) ó 0x00000030L(encabezamiento de 48 bytes)

2:tamaño del segmento de programa en bytes.

3:tamaño del segmento de inicialización de datos en bytes.

4:tamaño del segmento de datos no inicializados (bss) en bytes.

5:0x00000000L

6:Memoria total asignada al programa.

7:0x00000000L

Se admite un encabezamiento de 48 bytes que consiste:

32 bytes (encabezamiento normal) + 16 bytes (son ignorados)

EN EL MODELO PEQUEÑO

6:memoria total = programa + datos + bss + asignación dinámica

En el modelo separado ID

6:memoria total = datos + bss + asignación dinámica

Asignación dinámica.- es la memoria total reservada para el stack máscrecimientos del segmento de datos.

La asignación dinámica puede modificarse con el comando chmen queactualiza la palabra 6 del encabezamiento.

FORMATO DE UN ARCHIVO

El formato de un archivo consiste en una secuencia de pares:

(ENCABEZAMIENTO, FICHERO)

donde los ficheros vienen precedidos por el número mágico: 0177545

El encabezamiento consiste de 26 bytes con los siguientes campos:

campo tamaño especificación


name 14 nombre de fichero

time 4 fecha de la última modificación

uid 1 identificador del usuario (truncado a 1 byte)

gid 1 identificador del grupo

mode 2 bits de protección del fichero

size 4 tamaño del fichero

Si un fichero tiene un número de bytes impar se le añade un byte cero para que elencabezamiento comience en una dirección par.

Las dos palabras de 4 bytes del encabezamiento se almacenan con la palabra de mayororden primero (por compatibilidad con la versión de 7 UNIX)

FORMATO DE LIBRERIA

MINIX contiene varias librerías de procedimientos que contienen:

- procedimientos utilizados propiamente por el sistema (multiplicaciones, divisiones, etc).

- llamadas al sistema (con los mismos parámetros que UNIX).

Cada fichero contiene un procedimiento llamable, cada nombre que va a ser visible desdefuera tiene que declararse en una sentencia .define

Todas las sentencias .define ocuparán los primeros lugares dentro del fichero.

Estas sentencias se generan cuando el compilador C se llama con el flag -LIB

Los comandos libpack y libupack, compactan, (eliminan comentarios) y descompactancódigo ensamblador.

RECORRIDO POR LAS FUENTES DE MINIX

Los programas fuentes de MINIX están distribuidos en varios directorios con ficheros decódigo y de encabezamiento. Directorio /usr/src/


Directorios

boot - ficheros bootcommands - fuentes de los comandos del sistemaetc - ficheros del administradorfs - sistema de ficherosinet - redkernel - núcleolib - libreríasmm - manejador de memoriatest - test para verificar MINIXtmp - vaciotools - herramientas para construir MINIX

Ficheros .ashrc, .ellepro.b1, .ellepro.e, .exrc, .profile, LICENSE, Makefile, crclist

DIRECTORIO /usr/src/kernel

ficheros cabecera para el kernel............................

assert.h

const.h - constantes generales que utiliza el núcleo

glo.h - variables globales que se utilizan en el núcleo

kernel.h

proc.h - tabla de procesos

proto.h

sconst.h - misceláneo de constantes utilizadas por el ensamblador

type.h - definición de tipos, tasktab, stakframe_s

ficheros de la capa 1.............

mpx.s

mpx386.s - manejo de interrupciones para 386 o superior

mpx88.s - manejador de las interrupciones para 86


start.c - código de comienzo de MINIX pone un buen ambiente para main.c

i8259.c - driver para el chip i8259 controlador de interrupciones

exception.c - manejo de las excepciones, interrupciones de la CPU

protect.c

protect.h - constantes del modo protegido

klib.s

klib386.s - procedimientos utilizados por mpx386.s

klib88.s - procedimientos utilizados por mpx88.s

proc.c - mensajes

proc.h

table.c - contiene el vector de tareas

manejadores o tareas............................................

main.c - programa principal del kernel

driver.c

driver.h

drvlib.c

drvlib.h

memory.c - driver de memoria principal

floppy.c - driver de floppy

wini.c - driver de disco duro

xt_wini.c - driver de un disco duro tipo XT

at_wini.c - driver para el disco duro 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

mcd.c - manejador para un CDROM

clock.c - driver del reloj

tty.c - driver para un terminal tty

tty.h - definiciones y constantes propias del tty

pty.c - manejador para un seudo terminal

console.c - driver para el terminal consola

keymaps - directorio con tablas de teclados para varios idiomas

keyboard.c - driver para el teclado

rs232.c - driver para los puertos seriales rs232 en C

printer.c - driver para el printer

sb16.h

sb16_dsp.c

sb16_mixer.c

dmp.c - procedimientos que realizan un dmp en pantalla de la tabla de procesos

dp8390.c

dp8390.h

ne2000.c - manejador de red

ne2000.h

wdeth.c

wdeth.h

system.c - tarea del sistema


miscelaneos.................................................

misc.c

Makefile - compilar el kernel

config

DIRECTORIO /usr/src/mm

Contiene todos los programas fuentes referentes al manejo de la memoria losficheros cabecera y el fichero Makefile.

ficheros cabecera del manejador de memoria..................

const.h - constantes que utiliza el mm

glo.h - variables globales

mm.h - constantes principales e include

mproc.h - tabla de procesos

param.h - definición de sinónimos para variables mensaje

proto.h - prototipo de funciones

type.h - definición de tipos

table.c - tabla para mapear numero de llamada con rutina que la realiza.

alloc.c - libera y asigna bloques de memoria

llamadas al sistema que conforman el manejador de memoria.....

main.c - programa principal

forkexit.c - llamadas fork, exit y wait

exec.c - llamada exec

break.c - crecimiento de los segmentos de datos y pila

signal.c - manejo de señales


getset.c - coloca el uid y gid

utility.c - utilidades para el mm

putk.c - para imprimir un mensaje el mm

trace.c

DIRECTORIO /usr/src/fs

Contiene todos los ficheros que conforman el FS

buf.h - estructura buffer y hash

const.h - definición de constantes para el fs

fproc.h - tabla de procesos

fs.h - contiene los include cabecera

glo.h - variables globales para el fs

param.h - define sinónimos para mensajes

proto.h - prototipo de funciones

type.h - definición de tipos

table.c - relaciona el numero de llamada al sistema con la función que lo maneja

cache.c - mantiene un buffer para reducir acceso a disco

cache2.c -mantiene una cahe de segundo nivel en el disco RAM

inode.c - maneja la tabla de nodos i

inode.h - tabla de los nodos i

super.c - maneja la tabla de superbloque

super.h - tabla de superbloque

filedes.c - manipula los descriptores de fichero

file.h - tabla filp, intermediario entre descriptores de fichero y los nodos i


main.c - programa principal del fs

open.c - abre un fichero

read.c - lectura de un fichero

write.c - escritura en un fichero

pipe.c - realiza un pipe

path.c - busqueda de trayectorias en los directorios

mount.c - monta y desmonta un sistema de ficheros

link.c - establece un nuevo enlace para un fichero

lock.c

lock.h

stadir.c - cambio de directorio

protect.c - protección de ficheros

time.c - programa el reloj del sistema

dev.h - tabla de dispositivos enlaza el numero mayor con la rutina que lo procesa

device.c - lee bloques de disco que no están en el buffer

super.c

super.h

utility.c - miscelaneos utilizados por el fs

putk.c - para imprimir un mensaje por el fs

misc.c - realizan parte de llamadas al sistema

Makefile


DIRECTORIO /usr/src/commands

En este directorio se encuentran todos los fuentes de los comandos del sistema operativovienen separados en los siguientes directorios.

aaladventashautilawkbcbyacccawfdedis88elleelvisflex_2.3.7ftpftpdi386i86ibmicindetkermitm4makeminedpatchrebootscriptsshsimpletalktalkdtelnettelnetdyapzmode

DIRECTORIO /usr/src/boot

2.6 DIRECTORIO /usr/src/boot

Makefilemasterboot.s - boot master de arranque para el 1er sector del discoextboot.s - boot master de arranque para particiones extendidas de MSDOS


bootblock.s - bootstrap para el 1er sector de la partición activa, carga el bootboot.c - Boot Monitor, boot secundario, carga y arranca el MINIXboot.hboothead.s - Soporte de la BIOS para el boot.cedparams.c - permite modificar parámetros del sistemainstallboot.c - instala el sector de arranque (bootblock), o instala (image) elejecutable del MINIX, para crear un disco de arranque.image.h - información entre installboot y bootbootimage.c - carga y ejecuta una imagen del sistema operativorawfs.c - soporte para manejar un sistema de ficheros tipo RAWrawfs.h

El fichero Makefile de este directorio tiene las ordenes para que se compilenestos programas y se dejen en los directorios

Directorio /usr/mdec contiene los compilados:

BootBootblockExtbootMasterboot

Directorio /usr/bin contiene los compilados:

Installbootedparmas

MODIFICACIÓN DE MINIXVeamos como modificar MINIX ó sus utilidades para ello se debe utilizar un sistema de

desarrollo que puede ser:

- El propio MINIX - LINUX - MSDOS

MINIX consiste de tres partes independientes.

image - imagen ejecutable de minix

root - sistema de ficheros raíz

usr - sistema de ficheros usr

- image contiene la imagen ejecutable del núcleo del sistema operativo.

RECOMPILAR LA IMAGEN DE MINIX

* La imagen ejecutable del sistema operativo MINIX está compuesta de los

programas o trozos.

- Núcleo (kernel)

- Manejador de memoria (mm)


- Sistema de ficheros (fs)

- Inicializador (init)

- Manejador de red (inet), si hay red

* Solo se necesita recompilar la parte que se ha modificado.

Si la modificación afecta a un fichero cabecera xxx.h se debe recompilar todo

el sistema por seguridad.

COMPILAR EL KERNEL

Nos situamos en el subdirectorio /src/kernel

Compilación automática, cuando se utiliza MINIX como sistema de desarrollo la

compilación puede hacerse de una manera fácil con el comando make.

make compila todos los fuentes y los ensambla en una sola pieza que

llama kernel.

Es aconsejable realizar primero el comando make -n para ver lo que el

comando make va a realizar.

Compilar "a mano" mediante la sentencia make -n > script se genera un

fichero llamado script con todos los pasos que realiza make, y que podemos

realizar nosotros paso a paso, compilando y ensamblando cada uno de los

ficheros fuentes. Al final llamar al fichero binario simplemente kernel.

COMPILAR EL MANEJADOR DE MEMORIA MM Y EL SISTEMA DE

FICHEROS FS

Para recompilar el manejador de memoria o el sistema de ficheros:

Nos situamos en los directorios /src/mm o /src/fs Realizamos los mismos

pasos que para el kernel.

Llamamos a los resultados de la compilación y ensamblado mm y fs.

Fichero Makefile para mm

# Makefile for mm

# Directories

u = /usr

i = $u/include

s = $i/sys


h = $i/minix

# Programs, flags, etc.

CC = exec cc

CFLAGS = -I$i

LDFLAGS = -i

OBJ = main.o forkexit.o break.o exec.o \

signal.o alloc.o utility.o table.o putk.o trace.o getset.o

mm: $(OBJ)

$(CC) -o $@ $(LDFLAGS) $(OBJ)

install -S 256w $@

all install: # Nothing.

clean:

rm -f *.o *.bak mm

# Dependencies

a = mm.h $h/config.h $s/types.h $h/const.h $h/type.h \

$i/ansi.h $i/fcntl.h $i/unistd.h $h/syslib.h \

$i/limits.h $i/errno.h const.h type.h proto.h glo.h

alloc.o: $a

alloc.o: $h/com.h

break.o: $a

break.o: $i/signal.h

break.o: mproc.h

break.o: param.h

exec.o: $a

exec.o: $s/stat.h

exec.o: $h/callnr.h

exec.o: $i/a.out.h

exec.o: $i/signal.h

exec.o: $i/string.h

exec.o: mproc.h

exec.o: param.h

forkexit.o: $a


forkexit.o: $s/wait.h

forkexit.o: $h/callnr.h

forkexit.o: $i/signal.h

forkexit.o: mproc.h

forkexit.o: param.h

getset.o: $a

getset.o: $h/callnr.h

getset.o: $i/signal.h

getset.o: mproc.h

getset.o: param.h

main.o: $a

main.o: $h/callnr.h

main.o: $h/com.h

main.o: $i/signal.h

main.o: $i/fcntl.h

main.o: $s/ioctl.h

main.o: mproc.h

main.o: param.h

putk.o: $a

putk.o: $h/com.h

signal.o: $a

signal.o: $s/stat.h

signal.o: $h/callnr.h

signal.o: $h/com.h

signal.o: $i/signal.h

signal.o: $s/sigcontext.h

signal.o: $i/string.h

signal.o: mproc.h

signal.o: param.h

table.o: $a

table.o: $h/callnr.h

table.o: $i/signal.h


table.o: mproc.h

table.o: param.h

trace.o: $a

trace.o: $s/ptrace.h

trace.o: $i/signal.h

trace.o: mproc.h

trace.o: param.h

utility.o: $a

utility.o: $s/stat.h

utility.o: $h/callnr.h

utility.o: $h/com.h

utility.o: $i/fcntl.h

utility.o: $i/signal.h

utility.o: mproc.h

HACER UN DISCO O PARTICION DE ARRANQUE

2.8 HACER UN DISCO O PARTICIÓN DE ARRANQUE

Un disco o partición de arranque tiene las siguientes partes:

Bootblock - sector de arranque, situado en el 1er sector del disco o laparticiónBoot - boot monitor, situado en el directorio raiz /Image - ejecutable del s.o., situado en el directorio /minix

Un disco de arranque se construye con el programa mkboot y lasherramientas del directorio /usr/src/tools

Makefileinit.c - fuente del programa initmkboot - programa para construir el disco o partición de arranqueps.c - realiza un print del estado de todos los procesostell_config - contiene parametros, para averigura si está configurada la red

mkboot realiza los siguientes pasos:

instala el bootblock en el primer sector del disco o de la partición


installboot -device $root $mdec/bootblock /boot || exit

copia el boot monitor en el directorio raiz /

install -cs - m 644 $mdec/boot $rootdir/boot || exit

copia image, el ejecutable del s.o., y lo deja en /minix

cp -p image $rootdir/minix/$target || exit

para un floppy las instrucciones son:

installboot -d $dev $medc/bootblock boot || exitcp -p $mdec/boot /mnt/boot || exitcp -p image /mnt/minix || exit

De forma automatica se realiza con el comando make utilizando:

make

Compila las diferentes partes del sistema operativo y las combina en un ficherollamado image.

make fdboot

Construye el ejecutable del sistema operativo image y hace un floppy dearranque instalándolo con el boot y el bootblock.

make hdboot

Construye el ejecutable del sistema operativo image y los coloca en eldirectorio /minix, instala el boot en el directorio raiz /, e installaelbootblock en el primer sector de la partición minix.

# Makefile for the kernel image.

#

u=/usr

CC= exec cc

CFLAGS= -O -D_MINIX -D_POSIX_SOURCE


MDEC= /usr/mdec

MAKE= exec make -$(MAKEFLAGS)

inet=

PROGRAMS= ../kernel/kernel ../mm/mm ../fs/fs $(inet) init

programs:

cd ../kernel && $(MAKE)

cd ../mm && $(MAKE)

cd ../fs && $(MAKE)

@if [ èxec ./tell_config ENABLE_NETWORKING` = 0 ]; then \

$(MAKE) image; \

else \

echo "cd ../inet && $(MAKE)" && \

(cd ../inet && $(MAKE)) && \

$(MAKE) image inet=../inet/inet; \

fi

image: $(PROGRAMS)

installboot -image $@ $(PROGRAMS)

init: init.c

$(CC) $(CFLAGS) init.c -o $@

install -S 192w $@

ps: ps.c /usr/include/minix/config.h ../kernel/const.h \

../kernel/type.h ../kernel/proc.h ../mm/mproc.h \

../fs/fproc.h ../fs/const.h

$(CC) -i $(CFLAGS) -m -o $@ ps.c

mailto:@if


install -S 16kw $@

/usr/bin/ps: ps

install -cs -o bin -g kmem -m 2755 $? $@

bootable:

exec su root mkboot bootable

hdboot: programs

exec sh mkboot $@

fdboot: programs

exec su root mkboot $@

all install clean::

cd ../kernel && $(MAKE) $@

cd ../mm && $(MAKE) $@

cd ../fs && $(MAKE) $@

cd ../inet && $(MAKE) $@

all:: ps

install:: /usr/bin/ps

clean::

rm -f *.bak init ps image

DIRECTORIO /src/test PRUEBAS AL MINIX

2.9 DIRECTORIO /src/test PRUEBAS AL MINIX

El directorio /src/test contiene una serie de test para MINIX.

Situarse en el directorio /test.Ejecute los test individualmente, (test0, test1...) o ejecutar todos con el


programa run.

El test dura aproximadamente 10 minutos y presenta una serie de mensajes.

El comando make all compila todos los test.

LA LIBRERÍA EN MINIX

El sistema operativo y muchos de los comandos, utilizan procedimientos almacenados enuna librería. Estos procedimientos se deben lincar cuando se genera el código binario(ejecutable) de un programa.

Para aumentar la velocidad en el lincado, estos procedimientos se encuentran yaprecompilados dentro de la librería, de donde el compilador los extrae.

Las librerías para MINIX se encuentra en el directorio: /usr/lib/i386/

ascgcrtso.oend.alibc.alibcurses.alibd.alibe.alibedit.alibfp.aliby.a

Los procedimiento que contiene una librería son de dos tipos:

1. - Procedimientos utilizados por los usuarios.

Llamadas al sistema Procedimientos I/O Procedimientos varios

- open - fopen - atoi

- read - getc - isatty

- fork - printf - strcmp

) - Procedimientos utilizados por el compilador como parte del código generado.

- lmul, - ldiv, - csv, ...

Estos procedimientos internos son propios de cada compilador por lo que no sesuministran los fuentes. Hay que utilizar los que vienen con cada compilador.


En caso de utilizar otro compilador distinto del que viene con MINIX, (como turbo Cpara MS-DOS) . Asegúrese que la librería del compilador solo tiene procedimientosinternos, en caso de que existan llamadas al sistema estas deben quitarse.

FUENTES DE LAS LIBRERIAS DIRECTORIO /usr/src/lib

Los fuentes de los procedimientos de librería se encuentran distribuidos en lossubdirectorios

ansicurseseditlineendfloatfphooki386i86iplibymathotherposixstdiosyscallsyslib

Los fuentes de las librerías se encuentran como archivos para ahorrarespacio ya que un fichero ocupa como mínimo un bloque = 1k.

Para visualizarlos utilice el comando: ar tv ansi.aSolo necesitan ser compilados y puestos en la librería.Muchos ficheros vienen comprimidos ansi.a.Zcompress -d ansi.a.ZEl resultado es un fichero descomprimido ansi.a

INSTRUCCIONES PASO A PASO PARA CONSTRUIR UNA LIBRERÍA

Los fuentes de los procedidos de la librería están en variossubdirectorios en forma de archivo ansi.a, en vez de ficherosseparados, por razón de espacios.

1) Separe los procedimientos en ficheros

ar x ansi.a

borre ansi.a (ya no sirve)


rm ansi.a

Compile todos los ficheros C que hay en ansi, ensamble todos losficheros en código ensamblador en ansi pero no los linque.

Se puede realizar de forma automática con el comando make

# Makefile for the libraries

# This makefile runs make in all the subdirectories of the src/lib tree.

# See ansi/Makefile for a further explanation.

MAKE = exec make -$(MAKEFLAGS)

usage:

@echo "Usage: make all" >&2 # Compile all library functions" >&2

@echo " make install # Backup /usr/lib/*.a first!" >&2

@echo " make clean # Delete .o and .a files" >&2

@false

all:

cd ansi && $(MAKE)

cd curses && $(MAKE)

cd editline && $(MAKE)

cd end && $(MAKE)

cd float && $(MAKE)

cd fphook && $(MAKE)

cd ip && $(MAKE)

cd liby && $(MAKE)

cd math && $(MAKE)

mailto:@echo

mailto:@echo

mailto:@echo

mailto:@false


cd other && $(MAKE)

cd posix && $(MAKE)

cd stdio && $(MAKE)

cd syscall && $(MAKE)

cd syslib && $(MAKE)

cd àrch` && $(MAKE)

install: all

$(MAKE) install_àrch`

# Installation rules for PC Minix.

LIB= /usr/lib

install_i86: \

$(LIB)/ncrtso.o \

$(LIB)/libc.a \

$(LIB)/libd.a \

$(LIB)/libe.a \

$(LIB)/libfp.a \

$(LIB)/end.a \

$(LIB)/libcurses.a \

$(LIB)/libedit.a \

$(LIB)/liby.a \

$(LIB)/ncrtso.o: ncrtso.o

install -c -o bin $? $@

$(LIB)/libc.a: libc.a



$(LIB)/libd.a: libd.a


$(LIB)/libe.a: libe.a


$(LIB)/libfp.a: libfp.a


$(LIB)/end.a: end.a


$(LIB)/libcurses.a: libcurses.a


$(LIB)/libedit.a: libedit.a


$(LIB)/liby.a: liby.a


# Installation rules for Minix-386.

LIB386= /usr/lib/i386

LIB86= /usr/lib/i86

install_i386: \

$(LIB386)/crtso.o \

$(LIB386)/libc.a \

$(LIB386)/libd.a \

$(LIB386)/libe.a \

$(LIB386)/libfp.a \

$(LIB386)/end.a \


$(LIB386)/libcurses.a \

$(LIB386)/libedit.a \

$(LIB386)/liby.a \

# $(LIB86)/libc.a \

# $(LIB86)/end.a \

$(LIB386)/crtso.o: crtso.o


$(LIB386)/libc.a: libc.a


$(LIB386)/libd.a: libd.a


$(LIB386)/libe.a: libe.a


$(LIB386)/libfp.a: libfp.a


$(LIB386)/end.a: end.a


$(LIB386)/libcurses.a: libcurses.a


$(LIB386)/libedit.a: libedit.a


$(LIB386)/liby.a: liby.a


$(LIB86)/libc.a: libc86.a



$(LIB86)/end.a: end86.a


clean:

find . -name '*.[oa]' -o -name '*.bak' | xargs rm

LLAMADAS AL SISTEMA

La interfase entre los programas de usuario y el sistema operativo se define mediante un

conjunto de "instrucciones ampliadas" o llamadas al sistema.

El conjunto de llamadas que ofrece MINIX, son muy parecidas a las de UNIX y XENIX, si

bien estos tienen más.

Existe unas librerías de procedimientos en /usr/lib/ para poder realizar llamadas desde un

programa escrito en C.

Ejemplo: count = read(file, buffer, nbyte);

read -> nombre de la llamada al sistema

file -> fichero de donde leer

buffer -> zona de memoria donde colocar los dato

nbytes -> nº de bytes a leer

count -> nº de bytes leídos, si count es - 1, hay error, que se coloca en la

variable global errno


Los programas deben siempre testear después de una llamada si es correcta.

MINIX tiene un total de 53 llamadas al sistema, idénticas a UNIX V7 (estándar

POSIX). en nombre, función y parámetros.

Ejemplo de programa, del uso de la variable global errno y del

procedimiento perror()

/*

* errores.c

* lista los errores de llamadas al sistema

*/

# include <stdio.h>

main(argc,argv)

int argc;

char *argv[];

{

int i;

extern int errno;

for (i=0;i<=53;i++){

fprintf(stderr,"%3d",i);

errno=i;

perror(" ");

}

exit(0);

}

Manejo de procesos

pid = fork() - crea un proceso hijo idéntico al proceso padre.

pid = waitpid(pid, &statloc, opts) - espera a que un hijo determinado termine

y coge su condición de salida.

s = wait(&status) - espera a que un proceso hijo termine y coge su condición

de salida devuelve el pid del hijo que termina, llamada antigua.

s = execve (name, argv, envp) - sustituye la imagen en memoria de un

proceso.


exit(status) - pone fin a la ejecución del proceso y devuelve la condición de

salida.

size = brk (addr) - fija el tamaño del segmento de datos a (addr).

pid = getpid() - devuelve el id del proceso solicitante.

pid = getpgrp() - devuelve el id de grupo de procesos del proceso solicitante.

pid = setsid() - crea una nueva sesión y asigna el pid del invocador como

identificador del grupo de procesos.

s = ptrace(req, pid, addr, data) - controla un proceso para depurar.

Señales

s = sigaction(sig, &act, &oldact) - define la acción a realizar cuando se recibe

una señal.

s = sigreturn(&context) - regresa de una señal.

s = sigprocmask(how, &set, &old) - examina o cambia la mascara de las

señales.

s = sigpending(set) - obtiene el conjunto de señales bloqueadas.

s = sigsuspend(sigmask) - sustituye la mascara de señales y suspende el

proceso.

s = kill (pid, sig) - envía una señal a un proceso.

residual = alarm(seconds) - planifica o programa una señal SIGALRM después

de un cierto tiempo.

s = pause() - suspende el solicitante hasta la siguiente señal.

Manejo de ficheros

fd =creat (name, mode) - crea un nuevo fichero o trunca uno existente.

fd = mknod (name, mode, addr) - crea un nodo i normal, especial, o de

directorio.

fd = open (file, how, ...) - abre un fichero para lectura, escritura o ambos.

s = close (fd) - cierra un fichero abierto.

n = read (fd, buffer, nbytes) - lee datos de un fichero y los coloca en un

buffer.

n = write (fd, buffer, nbytes) - escribe datos a un fichero desde un buffer.

pos = lseek (fd, offset, whence) - mueve el apuntador del fichero.

s = stat (name, &buf) - lee y devuelve el estado de un fichero de su nodo i.


s = fstat (fd, buf) - lee y devuelve el estado de un fichero a partir de su nodo

i.

fd = dup (fd) - asigna otro descriptor de fichero para un fichero abierto.

s = pipe (&fd [0]) - crea una tubería.

s = ioctl(fd, request, argp) - realiza operaciones especiales en ficheros

especiales.

s = access(name,amode) - verifica los accesos a un fichero.

s = rename(old, new) - cambia el nombre de un fichero.

s = fcntl(fd, cmd, ...) - bloqueo de un fichero y otras operaciones.

Manejo del directorio y del sistema de ficheros

s = mkdir(name, mode) - crea un nuevo directorio.

s = rmdir(name) - elimina un directorio vacio.

s = link (name1, name2) - crea una entrada nueva name2 en el directorio,

que apunta al fichero name1.

s = unlink (name) - elimina una entrada del directorio.

s = mount (special, name, rwflag) - monta un sistema de ficheros.

s = unmount (special) - desmonta un sistema de ficheros.

s = sync() - escribe todos los bloques de la memoria cache en el disco.

s = chdir (dirname) - cambia el directorio de trabajo.

s = chroot (dirname) - cambia al directorio raíz.

Protección

s = chmod (name, mode) - cambia los bits de protección asociados con un

fichero.

iud = getuid() - determina el uid del solicitante.

gid = getgid() - determina el gid del solicitante.

s = setuid(uid) - fija el uid del solicitante.

s = setgid(gid) - fija el gid del solicitante.

s = chown (name, owner, group) - cambia el propietario y grupo de un

fichero.

oldmask = umask (complmode) - pone una máscara que se utiliza para fijar

los bits de protección.

Manejo de tiempo


seconds = time (&seconds) - calcula el tiempo transcurrido en segundos desde

el 1 de enero de 1970.

s = stime (tp) - pone el tiempo transcurrido desde el 1 de enero 1970.

s = utime (file, timep) - pone la hora del "último acceso" del fichero.

s = times (buffer) - determina los tiempos del usuario y del sistema gastados

hasta ahora.

LLAMADAS PARA EL MANEJO DE PROCESOS

FORK()Crea un nuevo proceso, exactamente igual al proceso original, incluyendo los descriptores

de ficheros, registros, ambiente, etc.

Una vez ejecutado el FORK, padre, e hijo se están ejecutando simultáneamente, en un

principio las variables tienen los mismos valores, después, cambios en uno no afectan al

otro.

La llamada FORK devuelve un valor después de ejecutarse, este valor es:

cero -> en el proceso hijo

pid (identificador del proceso hijo -> en el padre

Mediante este valor los procesos pueden saber cual es el padre y cual es el

hijo.


WAITPID

pid = waitpid(pid, &statloc, opts) - espera a que un hijo determinado termine,

devolviendo el pid del proceso que termina, y coge su condición de salida.

En mucho casos, el hijo creado por el FORK necesita lanzar un proceso, distinto

al del padre. Ejemplo:

El Shell, lee un comando, lanza un proceso hijo, y debe esperar hasta que el

proceso hijo ejecute el comando, posteriormente lee un nuevo comando

cuando el hijo termina.

Para esperar a que el hijo termine, el padre debe ejecutar WAITPID.

Si el parámetro pid vale -1, el padre espera por el primer hijo que termina

El segundo parámetro statloc es la dirección de una variable (estado de salida)

que es escrita por el proceso hijo para indicar terminación normal o anormal.

EXEC.


s = execve (name, argv, envp) - sustituye la imagen en memoria de un

proceso.

name - nombre del fichero que contiene el programa a ejecutar.

argv - vector de argumentos.

envp - vector ambiente

En el caso del Shell, el proceso hijo debe ejecutar el comando, esto lo hace

mediante la llamada EXEC, la cual hace que la imagen del hijo, sea

reemplazada por el fichero que hay en el primer parámetro de EXEC.

Ejemplo: Shell simplificado con FORK, WAITPID y EXEC.


While (TRUE){ /* bucle indefinido */

read_command (command, parámetro); /* lee comando */

if(fork() != 0){ /* lanza un proceso hijo */

waitpid(-1,&status,0); /* el padre espera a que hijo acabe */

}else{

execve(command, parámetros, 0); /* ejecuta el comando */

}

}

Pregunta: ¿El Shell padre podría lanzar directamente el comando?

La respuesta es NO, ya que EXEC, reemplaza el fichero por el código de quien

lo lanza, y este se pierde.

Muchas librerías, contienen varias versiones del EXEC.

execl, execv, execle, execve

que permiten omitir o especificar los parámetros de forma particular.

Utilizaremos EXEC para referirnos a cualquiera de ellos.

Consideremos el ejemplo: cp file1 file2 copiar file1 en file2

Después que el Shell a creado con el FORK una imagen hijo, este hijo ejecuta

cp mediante EXEC, le pasa al programa cp, y la información a cerca de los

ficheros a copiarse.

El programa principal main de cp contiene los argumentos: main (argc, argv,

envp)

argc -> Entero, contiene el número de parámetros (palabras) contenidos en la

línea de comandos, en nuestro ejemplo 3.

argv -> Es un puntero a un vector, cada elemento del vector contiene un

parámetro de la línea de comandos.

argv[0] = cp

argv[1] = file1

argv[2] = file2

envp -> Es un pointer o un vector ambiente, es un vector estring, conteniendo

asignaciones de la forma (nombre = valor), utilizada para pasar información

como el tipo del terminal, directorio, símbolo del Shell, etc.


EXIT().

Esta llamada la deben utilizar lo procesos cuando terminan.

Devuelve al padre un valor de estatus (0 a 255), que se carga en el byte

menos significativo de la variable estatus de WAITPID, un cero es terminación

normal, otro valor es error.

BRK(adr)

Esta llamada cambia el tamaño del segmento de datos de un programa.

El parámetro adr que indica el nuevo tamaño en bytes del segmento de datos.

Devuelve el tamaño actual del segmento de datos.

La rutina sbrk, en la librería, también cambia el tamaño del segmento de

datos, su parámetro indica el número de bytes que aumenta (positivo) o

disminuye (negativo) el segmento de datos.

GETPID

Devuelve el identificador del proceso (pid) que lo ejecuta.

En un Fork, al padre se le devuelve el pid del hijo, mientras que al hijo se le

devuelve un cero, si el hijo quiere saber su pid, deberá efectuar un GETPID.

LLAMADAS PARA SEÑALES

Las llamadas se utilizan para

manejar interrupciones por software

hacer reports de interrupciones hardware

detectar instrucciones ilegales

rebosamiento de variables

Cuando una señal se envía a un proceso, que no esté preparado para recibirla,

el proceso se mata.

SIGNAL(señal, &funcion)

int señal;

int (*función)(); función a realizar cuando se recibe una señal


Esta llamada se utiliza para indicar que se está preparado para recibir algún

tipo de señal y suministrar la dirección del procedimiento manejador de la

señal.

Después del SIGNAL, si se recibe una señal por ejemplo SIGINT (pulsar la tecla

DEL), se efectúa:

1) El estado del proceso se guarda en su propia pila.

2) Se ejecuta el manejador de la señal.

SIGRETURN (&contexto)

Es llamado por el manejador que atiende la señal cuando termina.

Recupera el estado del proceso interrumpido desde la pila y lo continúa.

Los tipos de señales son:

1 SIGHUP El modem ha detectado línea telefónica colgada

2 SIGINT La tecla DEL ha sido pulsada

3* SIGQUIT Señal Quit (desde el teclado CTRL \)

4* SIGILL Instrucción ilegal

5* SIGTRAP Traza de los traps

6* SIGABRT Abortar un programa


7* SIGUNUSED Instrucción EMT

8 SIGFPE Rebosamiento de coma flotante

9 SIGKILL Matar un proceso

10 SIGUSR1 El usuario define la señal # 1

11* SIGSEGV Violación de segmentación

12 SIGUSR2 El usuario define la señal # 2

13 SIGPIPE Escritura en pipe sin lectores

14 SIGALRM Alarma

15 SIGTERM Software genera una señal de terminación

16 no asignada

17 SIGCHLD Proceso hijo terminado o bloqueado

18 SIGCONT Si está bloqueado continuar

19 SIGSTOP Señal de paro

20 SIGTSTP Señal de paro interactiva

21 SIGTTIN Proceso en segundo plano quiere leer

22 SIGTTOU Proceso en segundo plano quiere escribir

23 SIGWINCH Cambio del tamaño de la ventana

Las señales entre paréntesis no son soportadas por MINIX.

Los asteriscos denotan aquellas señales que causan un volcado del proceso, si

no son atendidas.

Después de recibir una señal, es necesario volver a permitir recibir otra señal

con otro SIGNAL, ya que si no, puede recibirse una señal y matar el proceso

(acción por defecto).

Existen dos funciones predefinidas que el usuario puede utilizar:

LLAMADAS PARA MANEJO DE FICHEROS

CREATint creat (nombre, permisos) /* crea un fichero */

char *nombre; /* nombre camino */

int permisos; /* bits de permisos */


Crea un fichero y lo abre en modo escritura, independiente del modo. Sus parámetros son

el nombre del fichero y el permiso.

fd = CREAT("ac", 0751)Crea un fichero de nombre ac y con permiso 0751.

Permiso está escrito en octal, cada dígito tiene tres bits que se relacionan con los modos

rwx, lectura, escritura y ejecutar, un uno significa permiso, cero no permiso.

El tercer dígito (7) se refiere al propietario rwx todo.

El segundo dígito (5) a los usurarios del grupo r-x leer y ejecutar.

El primer dígito (1) al resto --x sólo ejecutar.

Si el fichero ya existe, el fichero se trunca a longitud cero, si el permiso es

correcto.

Esta llamada nos devuelve el fd (descriptor del fichero) que se utiliza para

posteriores referencias al fichero.

MKNOD

int mknod (nombre, modo, equipo) /* crea un fichero especial */

char *nombre; /* fichero a crearse */

int modo; /* modo del nuevo fichero */

int equipo; /* numero de equipo */

Crea un fichero especial, es solo llamable por el super usuario.

fd = mknod ("/dev/tty2", 020744, 0x0402);

Crea un fichero llamado /dev/tty2 (nombre usual para el terminal 2)

Modo en octal 020744, indica que es un fichero especial en modo carácter

c..rwxr--r--

El tercer parámetro expresa en el byte más significativo 04 (mayor equipo)

el tipo de equipo (disco, terminal impresora, etc) y en el byte menos

significativo (menor equipo) el número dentro de su tipo, en este caso 02.

OPEN

Abre un fichero o crea un fichero, forma moderna de creat.

int open (fichero, modo) /* abre un fichero */

char *fichero; /* nombre paso */

int modo; /* lectura escritura o ambos */


Abre un fichero, declarando un identificador y el como.

O_RDONLY (0) -> lectura

O_WRONLY (1) -> escritura

O_RDWR (2) -> ambos

Devuelve el descriptor del fichero, (fd) para posteriormente utilizarlo en

lecturas o escrituras; -1 en caso de error.

CLOSE

Cierra un fichero especificado por su descriptor.

int close (fd) /* cierra un fichero */

int fd; /* descriptor del fichero */

devuelve -1 en caso de error, y cero en caso de exito

READ

int read(fd, buffer, nbytes) /* lectura de un fichero */


char *buffer; /* dirección del buffer */

unsigned nbytes; /* numero de bytes a leer */

devuelve numero de bytes leídos, 0 un EOF, -1 error.

WRITE

int write (fd, buffer, nbytes) /* escribe en un fichero */

int fd; /* descriptor de un fichero */

char *buffer; /* dirección del buffer */

unsigned nbytes; /* numero de bytes a escribir */

devuelve el numero de bytes escritos o -1 si hay errror.

Lectura, escritura secuencial, cada vez que se lee o escribe, el pointer asociado

con el fichero es incrementado n bytes.

LSEEK

Mueve el pointer del fichero a una determinada posición, utilizado para acceso

directa. Tiene tres parámetros.


long lseek(fd, offset, de_donde) /* mueve el pointer */

int fd; /* identificador del fichero */

long offset; /* desplazamiento dentro del fichero */

int de_donde; /* si la posición es relativa al principio 0, o al final del fichero 2,

o actual 1*/

Lseek devuelve la posición absoluta del pointer después del cambio.

STAT

int stat(nombre, p) /* lee el estado de un fichero */

char *nombre; /* nombre camino */

struct stat *p; /* información del estado */

FSTAT

int fstat(fd, p) /* lee el estado de un fichero */

int fd; /* descriptor de un fichero */

struct stat *p /* información del estado */

Devuelve -1 si hay error, 0 si exito

Nos da información relativa a un fichero.

Modo, directorio, tipo de fichero, tamaño, última modificación, etc.

Estas llamadas difieren solo en la forma de especificar el fichero (nombre o

identificador).

El segundo parámetro es un pointer a una estructura donde va a colocarse la

información. La forma de esta estructura es:

struct stat {

short st_dev; /* equipo donde el nodo esta */

unsigned short st_ino; /* numero del nodo */

unsigned short st_mode; /* palabra de modo */

short st_nlink; /* numero de enlaces */

short st_uid; /* identificador del usuario */

short st_gid; /* identificador del grupo */

short st_rdev; /* mayor/menor fichero especial */

short st_size; /* tamaño del fichero */


short st_atime; /* igual que st_mtime */

short st_mtime; /* fecha de la ultima modificación */

short st_ctime; /* hora de la última modificación del nodo-i */

};

Existen tres tiempos, para compatibilizar con UNIX.

DUP

int dup(fd) /* duplica el descriptor de un fichero */

int fd; /* descriptor de un fichero abierto */

Devuelve el nuevo descriptor del fichero o -1 si hay error

Se utiliza para manejar descriptores de ficheros.

Ejemplo: Consideremos la siguiente acción a un programa.

1) Cerrar la salida standar (descriptor de fichero = 1).

2) Utilizar otro fichero como salida standar.

3) Utiliza funciones de escritura para la salida standar (printf).

4) Recuperar la situación original.

Esto se puede realizar:

- cerrando con descriptor de fichero igual a uno

- abriendo un nuevo fichero que será la nueva salida standar

pero será imposible recuperar la situación más tarde.

La solución correcta es:

-Ejecutar fd = dup(1)

El cual origina un nuevo descriptor para la salida standar, la cual ahora tiene

dos descriptores fd y 1.

-Cerrar la salida standar close(1), (se pierde el 1).

-Abrir un fichero (open) (se recupera para éste el 1).

Para recuperar la situación original.

- Cerrar con el descriptor igual a uno.

- Ejecutar n = dup(fd) para recuperar el descriptor 1 que apunta al mismo

fichero que fd.

- Cerrar con fd y volvemos a la situación original.


Esto se entiende si las asignaciones de descriptores son secuenciales, se

asigna el menor descriptor disponible.

El dup tiene una variante, que permite a un descriptor, que no ha sido

asignado, referenciar a un fichero abierto.

dup2 (fd,fd2);

fd --> es el descriptor de un fichero abierto

fd2 --> el descriptor no asignado que va a referenciar al mismo fichero que fd.

Si fd referencia a la entrada standar (0) y fd2 es 4, después de la llamada la

entrada standar se podrá referenciar como 0 y como 4.

PIPE

int pipe(pfd) /* crea un pipe */

int pfd[2]; /* descriptores de los ficheros */

La llamada Pipe, crea un pipe y devuelve dos enteros descriptores de fichero.

pfd[0] --> es el descriptor para leer

pfd[1] --> es el descriptor para escribir

devuelve -1 si hay error 0 si éxito.

La comunicación entre procesos en MINIX, utiliza pipes. Cuando ejecutamos el

comando.

cat file1 file2 | sort

El Shell crea un pipe y hace que la salida standar del primer proceso (cat) se

escriba en el pipe, y que la entrada standar del segundo proceso (sort) pueda

leer de pipe.

ejemplo: procedimiento que crea dos procesos, con la salida del primero,

escrita sobre un pipe, y leída por el segundo.

#defineSTD_INPUT 0 /*fd de la entrada estandar */

#define STD_OUTPUT 1 /* fd de la salida estandar */

pipeline(proceso1, proceso2)

char *proceso1, *proceso2; /* punteros a nombres de programa */

{

int fd[2];

pipe(&fd[0]); /* crea un pipe */


if (fork() != 0) { /* el padre ejecuta estas sentencias */

close(fd[0]); /* proceso uno no necesita leer de pipe */

close(STD_OUTPUT); /*prepara para una nueva salida estandar.*/

dup(fd[1]); /* coloca la salida estandar a fd[1] */

close(fd[1]); /* pipe no necesita ninguno más */

execl(proceso1, proceso1, 0);

} else {

/* el proceso hijo ejecuta estas sentencias */

close(fd[1]); /* proce. dos no necesita escribir en pipe */

close(STD_INPUT); /*prepara para una nueva entrada estandar.*/

dup(fd[0]); /* coloca la entrada estandar a fd[0] */

close(fd[0]); /* pipe no necesita ninguno más */

execl(proceso2, proceso2, 0);

}

}

Escritura en un PIPE

Los datos se escriben en orden de llegada.

Si el pipe se llena (tamaño finito # 4kB), el proceso que escribe se

bloquea hasta que datos son extraídos del pipe.

Lectura en un PIPE

Los datos se leen en el orden de llegada FIFO

Una vez un dato es leído, es sacado del pipe y no puede ser leído de nuevo.

Si el pipe esta vacio el proceso que lee se bloquea hasta que se introducen

datos en el pipe.

Close sobre un PIPE

Libera el descriptor del pipe y puede ser asignado

Si se cierra el descriptor para escritura close(pfd[1]); actúa como un end-of-

file (final de fichero) para el lector.

IOCTL

int ioctl(fd, comando, tbuf) /* control de un fichero especial como un terminal

*/



int comando; /* comando */

struct termio *tbuf; /* información del terminal */

Devuelve -1 si hay error, 0 si exito.

Tiene su aplicación mas común en terminales, se utiliza para:

- Cambiar el carácter de borrado.

- Cambiar el modo del terminal.

modo "cooked" (en POSIX modo canónico)

Para leer espera por una línea completa.

backspace --> trabaja normalmente

break --> trabaja normalmente

CRTL S --> Para la salida en el terminal

CTRL Q --> Reanuda la salida en el terminal

CTRL D --> fin de fichero

DEL --> señal de interrupción

CRTL \ --> señal quit para producir un volcado.

modo "raw" (en POSIX modo no canónico)

Todos las funciones anteriores son desabilitadas.

Los caracteres pasan directamente al programa, sin ningún proceso.

Para leer no espera por una línea completa.

modo "Cbreak" (en POSIX modo canónico variando ciertos

parámetros)

inhibidos: backspace, break, CTRL D

permitidos: CTRL S, CTRL Q, DEL CTRL\

Puede leer líneas parciales.

La forma de esta llamada es:

ioctl (fd, operación, &sgttyb);

fd --> especifica un fichero

operación --> específica una operación

&sgttyb --> dirección a una estructura de flags


Las operaciones soportadas por MINIX son:

TIOCSETP --> asigna los valores de la estructura a los parámetros del

terminal.

TIOCGETP --> Llena la estructura con los valores actuales del terminal.

La estructura está definida en el fichero sgtty.h

/* Estructura de datos para IOCTL llamadas TIOCGETP/TIOCSETP */

struct sgttyb {

char sg_ispeed; /* velocidad de entrada (no se usa) */

char sg_ospeed; /* velocidad de salida (no se usa) */

char sg_erase; /* carácter de borrado */

char sg_kill; /* carácter de matar */

int sg_flags; /* flags de modo */

};

/* Campos de sg_flags */

#define XTABS 0006000 /* a uno causa la expansión de tab */

#define RAW 0000040 /* a uno permite el modo raw */

#define CRMOD 0000020 /* a uno LF transforma en LF + CR */

#define ECHO 0000010 /* a uno permite el eco */

#define CBREAK 0000002 /* a uno permite el modo Cbreak */

#define COOKED 0000000 /* ni CBREAK ni RAW */

#define TIOCGETP (( 't'<<8 ) | 8 )

#define TIOCSETP (( 't'<<8 ) | 9 )

Los bits en sg_flags pueden ponerse estando en los modos "raw" o "cbreak".

XTABS debe colocarse a cero cuando utilizamos terminales que realizan la

tabulación por hardware.

XTABS puesto a uno, hace que LF se transforme en LF + CR.

ECHO puesto a uno, produce el eco de los caracteres hacia el terminal. (cero,

para palabras claves).

IOCTL puede utilizarse con otra estructura de datos, (tchars) para cambiar:

- el carácter de interrupción

- el carácter quit

- el carácter de parada


- el carácter de reanudar

- el carácter de fin de fichero

ACCESS(name,amode) - verifica los accesos de un programa a un fichero. Un

programa puede ejecutarse con el UID de otro, como el caso de comandos del

sistema.

RENAME(viejo, nuevo) - cambia el nombre viejo de un fichero por nuevo.

FCNTL(fd, cmd, ...) - bloqueo, candados, de partes de un fichero y otras

operaciones.

LLAMADAS PARA MANEJO DE DIRECTORIO

MKDIR(name, mode) - crea un nuevo directorio.

RMDIR(name) - elimina un directorio vacío.

LINK (nombre 1, nombre 2)

Permite que varios usuarios referencien a un fichero con dos o más nombres, a

menudo en diferentes directorios, el fichero no se duplica, se crea otra entrada

en el directorio. Las modificaciones afectan a todos, pues es el mismo fichero.

Ejemplo. Supongamos la siguiente situación para dos directorios.

/usr/ast /usr/jim

16

81

40

mail

juego

test

31

70

50

38

bin

nemo

fc

prog1

después de realizar la llamada link ("/usr/jim/nemo", "/usr/ast/note")

La situación es la siguiente

/usr/ast /usr/jim


16

81

40

70

mail

juego

test

note

31

70

50

38

bin

nemo

fc

prog1

Todo fichero tiene un único número identificador, entrada en la tabla de

inodos.

Existen dos entradas con el mismo identificador (70) que referencian al mismo

fichero.

UNLINK (nombre)

Quita una entrada del directorio, si existen más, las otras permanecen.

MOUNT (especial, nombre, rwflag).

Realiza la fusión entre dos sistemas de ficheros (normalmente el raíz) y un

sistema de ficheros de usuario, en otro dispositivo.

Ejemplo:

mount (/dev/fd0, /usr/home, 0);

mount (/dev/fd0, /fd0, 0);

El primer parámetro es el disco donde se encuentra el sistema de ficheros a

montar.

El segundo parámetro es el directorio donde se va a realizar el enlace.

Una vez que un fichero está montado forma parte del árbol general y se

accede independiente del disco donde está situado.

UMOUNT (/dev/fd0)

Desmonta un sistema de ficheros.

SYNC ()

MINIX mantiene los datos usado más recientemente del disco, en memoria

principal. (memoria cache, buffer).

Si se modifica un dato de esta memoria, y antes que se guarde en el disco, el

sistema cae, se puede producir un error, para prevenir esto; SYNC escribe

bloques, de datos que han sido modificados, de la memoria cache a disco.


Cuando MINIX se arranca, se ejecuta el programa update en modo tanda, y

este ejecuta un SYNC cada 30 segundos.

CHDIR (nombre de directorio).

Cambia el directorio de trabajo,después de la llamada chdir

("/usr/ast/test");

un open sobre el fichero xyz, lo abre en /usr/ast/test/xyz

CHROOT ("/usr")

Cambia el directorio raíz "/", solo el super usuarios pueden realizar esta

llamada.

LLAMADAS PARA PROTECCION

CHMOD (nombre, modo)MINIX proporciona 11 bits de modo, para protección de un fichero. La llamada CHMOD,

permite cambiar estos bits de modo para un fichero.

Los nueve primeros bits, son para el propietario, el grupo y el resto de usuarios (rwx).

Ejemplo: chmod ("file", 0644);Coloca el fichero file con acceso de solo lectura para cualquiera, excepto para el

propietario.

Los otros dos bits son:

bit (10) 02000 SETGID (pone identificador de grupo)

bit (11) 04000 SETUID (pone identificador de usuario)

Cuando un usuario, ejecuta un programa con el bit SETUID puesto a uno, el

identificador del usuario, se cambia por el identificador del dueño del fichero, y

este cambio dura la vida del proceso.

Esto se utiliza, para permitir que un usuario pueda ejecutar procesos del super

usuario como por ejemplo crear un directorio. Si a mkdir se le coloca el modo

04755, usuarios normales pueden ejecutarlo.

SETGID cuando está a uno, el usuario del fichero, cambia su identificador de

grupo, por el del propietario del fichero.


GETUID () GETGID ()

Dan al proceso que hace esta llamada, el identificado real y efectivo del

usuario, y grupo respectivamente.

Se necesitan cuatro rutinas de librería para obtener esta información.

getuid, getgid, geteuid, getegid

Las dos primeras cogen el real uid/gid y las dos últimas el efectivo uid/gid.

SETUID(uid) SETGID(gid)

Estas llamadas permiten al super usuario, cambiar el identificador real y

efectivo de un usuario y grupo.

CHOWN (nombre, propietario, grupo)

Con esta llamada, el super usuario puede cambiar el propietario de un fichero.

UMASK (modo máscara)

Pone una máscara interna de bits, en el sistema, para enmascarar los bits de

modo, cuando se crea un fichero.

Ejemplo, la llamada umask (022)

Hace que una llamada posterior para crear un fichero. creat ("file", 0777)

Su modo 0777 sea enmascarado con 022 y por tanto cambiado a 0755.

0777 = 1 1 1 1 1 1 1 1 1

mácara 0022 = 1 1 1 1 0 1 1 0 1

and 1 1 1 1 0 1 1 0 1 = 755

Los bits de máscara son heredados por los procesos hijos.

Si el Shell hace umask justo después de login, ninguno de los procesos de

usuario en esa sesión crearan ficheros que accidentalmente pueden ser

escritos por otros usuarios.

ACCESS

Esta llamada nos dice si un usuario tiene permiso de acceso para un fichero.


Si un programa del super usuario, tiene el SETUID a uno, cualquier usuario

que la ejecute tomara el identificador efectivo del super usuario y podrá

ejecutar cualquier programa.

La llamada access nos dice si un identificador real tiene permiso para acceder a

un fichero.

El parámetro modo es 4 para lectura, 2 para escritura y 1 para ejecutar, se

permiten combinaciones por ejemplo con modo 6, si la llamada no devuelve un

cero, si se permite acceso de lectura y escritura y 1 en otro caso.

Con modo cero, se testea si el fichero existe.

LLAMADAS PARA MANEJO DE RELOJTIME (&segundos)

Nos devuelve los segundos transcurridos desde el uno de enero de 1970.

STIME (segundos)

El super usuario pone el tiempo transcurrido, desde 1 de Enero de 1970, paraposteriores lecturas.

UTIME (fichero, fecha)

Permite el usuario de un fichero, escribir en el campo "última fecha de acceso delfichero", en el directorio.

Algunos programas exigen que todos sus ficheros tengan la misma fecha demodificación.

TIMES (buffer)

Devuelve información a un proceso como:

tiempo de CPU gastado por el procesotiempo de CPU gastado por el sistematiempo de CPU de los procesos hijos


ESTRUCTURA INTERNA DEL MINIX

MINIX está formado por una colección de procesos que comunican entre si y con losprocesos de usuarios. Utilizando unas primitivas de comunicación a base de mensajes.

MINIX está estructurado en cuatro capas, cada una realiza una función definida.

4 init proceso deusuario

proceso deusuario

proceso deusuario

procesosusuarios

3 Manejador de Memoria Sistema de Ficheros ServidorRed

Capa deservidores

2 tarea disco tarea terminal tarea reloj ...... tareasistema

Capa detareas I/O

1 MANEJO DE PROCESOS

CAPA 1 - Funciones:

Atiende las interrupciones, guardando y recuperando registros.Planificación de tareas y procesosManeja mecanismos de mensajes, chequeo de destinos correctos,localización de buffers en memorial real para enviar y recibir, copia de bytesdesde el que envía al que recibe.

La parte de esta capa que trata con el nivel inferior de las interrupciones estáescrita en ensamblador, el resto en C.

CAPA 2 - Contiene los procesos (tareas) de I/O, manejadores de dispositivos(device drivers).

memoriadiscosimpresoraterminalrelojsistema (no corresponde con ningún equipo)

Todas las tareas de la capa dos y todo el código de la capa uno estáncombinados juntos en un único programa binario el KERNEL.

Todas las tareas se gestionan independientemente y se comunican utilizandomensajes.

CAPA 3 - Contiene los servidores: el manejador de memoria, el sistema deficheros, el servidor de red. Se ejecuta con menor privilegio que la capa 1 y 2.


El manejador de memoria (MM) contiene todas las llamadas al sistemarelacionadas con memoria, tales como FORK, EXEC y BRK.

El sistema de ficheros (FS) contiene todas las llamadas, relativas a ficheroscomo READ, MOUNT, CHDIR, etc.

En MINIX, el manejo de recursos se realiza principalmente en el núcleo (capa 1y 2) y las llamadas al sistema en la capa 3.

CAPA 4 - Contiene todos los procesos de usuarios, Shell, editores,compiladores, etc.

Mapa de memoria RAM después que MINIX se ha cargado.

memoria libre para programas de usuarios

init init 2372k - 2383k

inet tarea inet 2198k - 2372k

fs sistema de ficheros 1077k - 2198k depende nº buffers

mm manejador de memoria 1024k - 1077k

memoria dispositivos I/O 640k - 1024k

memoria para el usuario 129k - 640k

kernel

tarea .... 129 k (depende de las tareasinstaladas)

tarea impresora

tarea terminal

tarea memoria

tarea reloj

tarea disco

manejo de interrupciones CPU y mensajes 2k (00800) comienzo del núcleo

no utilizado 1k - 2k

vector de interrupciones 0 - 1k


ARBOL DE PRECESOSUn proceso puede crear un proceso hijo, y este a su vez otros procesos, obteniéndose unárbol de procesos.

Todos los procesos de usuario son parte de un árbol cuya cabeza es el proceso init.

Veamos como arranca MINIX:

Cuando el computador se enciende, la BIOS lee el primer sector del cilindro cero deldisco, que contiene el masterboot, que se carga en memoria y se ejecuta. El masterbootcarga en memoria el bootstrap desde el primer sector de la partición activa que ejecutael boot que carga el sistema operativo con sus partes kernel, mm, fs, init el primerproceso de usuario.

El kernel se ejecuta inicializa el sistema y lanza todas las tareas de los manejadores, queuna vez inicializadas se bloquean en espera de trabajo, luego se lanza el mm, el fs, yfinalmente se ejecuta init.

Init, primeramente lee el fichero /etc/ttytab para ver cuantos terminales hay, y medianteFORK crea un proceso hijo para cada terminal. En nuestro caso solo la consola.

Cada proceso hijo ejecuta /usr/bin/getty que presenta un mensaje y espera que se tecleeun nombre.

Cuando alguien entra en el sistema, se ejecuta /usr/bin/login/ con el nombre comoargumento y se ejecuta el Shell de ese usuario, especificado en /etc/passwd,normalmente /bin/sh.

El Shell espera por un comando y luego lanza un FORK y un EXEC por cada comando.

De esta forma el Shell es el hijo de init, y los procesos de usuario los nietos, y todos losprocesos en el sistema son parte de un mismo árbol.


Cuando se ejecuta un programa, se le asigna un trozo de memoria, que la retiene a lalargo de su vida y cuyo tamaño está especificado en el encabezamiento del programa(palabra 6).

Toda la información de un proceso creado se guarda en la tabla de procesos, dividida entres partes el núcleo, manejo de memoria y sistema de ficheros.

núcleo manejador de memoria sistema deficheros


registros contadorprograma palabra estado stackpointer estado proceso t.comienzoproceso tiempo uso CPU t. uso CPUpor hijo t. próxima alarma puntero colaMensajes señales pendientes idproceso bits de flags

puntero al segmento código puntero al segmentodatos puntero al segmento bss estadosalida estado señales identificador procesoproceso padre grupo de procesos uidreal uid efectivo gidreal gid efectivo mapabits para señales bits de flags

Máscara umaskdirectorio raízdirectorio detrabajo descriptorfichero uidefectiva gidefectivaparámetrosllamadas bits deflags

Cuando un proceso se crea o se destruye, el manejador de memoria, actualiza la tabla deprocesos y envía mensajes al núcleo y al sistema de ficheros para que actualicen sutabla.

COMUNICACIÓN ENTRE PROCESOSModelo cliente servidor

Proceso

cliente

Proceso

cliente

Sevidor dememoria

Servidor deficheros

Servidor dered

...... Modo usuario

Núcleo

Modo núcleo

Los procesos de usuario (procesos clientes) mediante mensajes solicitan servicios a unservidor, el cual realiza el trabajo y envía una respuesta. El núcleo se encarga deltransporte de los mensajes.

La comunicación entre procesos se realiza, intercambiando mensajes, utilizando tresprimitivas de los procedimientos de librería en C.

- send (destino, &mensaje); Para enviar un mensaje al proceso destino

- receive (fuente, &mensaje); Para recibir un mensaje del proceso fuente (o cualquiera)

- send_rec(src_dst, &mensaje); Para enviar un mensaje a un proceso y esperar unarespuesta del mismo. La respuesta se sobrescribe en el mensaje original.

&mensaje - es la dirección local de los datos del mensaje. El tamaño del mensaje vienefijado por el tamaño de la estructura message, que es una unión de seis formatos demensajes.

m_source m_source m_source m_source m_source m_source


m_type m_type m_type m_type m_type m_type

m1_i1 m2_i1 m3_i1 m4_l1 m5_c2 m5_c1 m6_i1

m1_i2 m2_i2 m3_i2 m4_l2 m5_i1 m6_i2

m1_i3 m2_i3 m3_p1 m4_l3 m5_i2 m6_i3

m1_p1 m2_l1 m3_ca1 m4_l4 m5_l1 m6_l1

m1_p2 m2_l2 m4_l5 m5_l2 m6_f1

m1_p3 m2_p1 m5_l3

m_source - quien envia el mensaje; m_type - el tipo de función a realizar (ejem. paradisco read, write); resto son campos de datos

Los procesos se pueden comunicar por mensajes siempre que estén en la misma capa, ocontigua. Un proceso de usuario (cap4) no puede comunicar directamente con una tareade I/O (capa2).

Cuando un proceso envía un mensaje a otro proceso, se bloquea, hasta que el destinohace un receive, esto es MINIX utiliza el método RENDEZVOUS o de cita. Este métodoes más sencillo por no utilizar buffers.

PLANIFICACION DE PROCESOS

La gestión o planificación de procesos de MINIX utiliza un sistema de colas multinivel contres niveles.

Prioridades:


1. tareas de I/O tienen la máxima prioridad2. tareas del manejador de memoria y del sistema de ficheros3. tareas de usuario.

Mientras exista un proceso en una cola de prioridad alta, no se ejecutan los procesos delas demás colas de prioridad menor.

Las tareas del sistema, el manejador de memoria y el sistema de ficheros nunca sondesasignados.

El planificador de CPU, trabaja por interrupciones, cada manejador de I/O, disco, reloj,terminal, etc tiene asociada una dirección dentro del vector de interrupciones, quecontiene la dirección del procedimiento que atiende esa interrupción.

Si cuando se esta ejecutando un proceso ocurre una interrupción hardware, por ejemploel disco interrumpe, se ejecutan a grandes rasgos los siguientes pasos:

1. El hardware de interrupciones (i8259), mete el contador de programa, la palabrade estado y algún registro en la pila del proceso que se esta ejecutando.

2. El hardware carga el contador de programa con una dirección para que la CPUsalte a una dirección dentro del vector de interrupciones donde se encuentra elprocedimiento de servicio que atiende a la interrupción de disco.

3. El procedimiento de servicio de la interrupción llama a SAVE, (en ensamblador)para guardar todos los registros

4. Se prepara una nueva pila temporal con la información depositada por lainterrupción

5. Se ejecuta el servicio de esta interrupción (escrito en C)6. El planificador marca la tarea en espera , en este caso de disco, como lista7. Se llama al planificador para decidir que proceso debe ejecutarse a continuación8. El procedimiento en C regresa al código en ensamblador9. El procedimiento en ensamblador carga los registros y el mapa de memoria del

nuevo proceso actual y lo inicia.

Documents

MINIX - SISTEMAS OPERATIVOS