Durante el arranque, el sistema pasa por las siguientes fases
Carga e inicialización del kernel
Detección de dispositivos y con guración
Creación de procesos de inicio
Ejecución de los scripts de inicio del sistema
Creación de terminales
Los detalles de cada paso dependen de cada implementación particular de
UNIX
3.1. Carga del Kernel
Usualmente en 2 pasos:
1. La ROM del sistema carga un pequeño programa (bootstrap o gestor
de arranque) en memoria desde el disco
la localización del programa depende del sistema UNIX
en un PC, se sitúa en el MBR (Master Boot Record ), primer sector
del disco
2. El bootstrap localiza y carga en memoria el kernel
en Linux normalmente localizado en /boot (fichero
vmzlinuz-versión )
3. Los gestores de arranque más populares en Linux son LILO y GRUB
Una vez cargado, el kernel realiza los siguientes pasos:
1. inicializa sus estructuras de datos internas (colas, tabla de procesos,
etc.)
2. chequea el hardware
3. verifica la integridad del fileesystem root y lo monta
en Linux, se crea un RAM disk a partir del chero /boot/initrd.img-versión
4. se crean los procesos de inicio
en BSD, 3 procesos: swapper (0), init (1) y pagedaemon (2)
en System V: sched (0), init (1) y varios procesos de manejo del
kernel y la memoria
en Linux: init (1) y varios procesos de manejo del kernel y la
memoria (ksoftirqd, migration, events, etc., que en realidad son
parte del kernel)
init se encarga de arrancar el resto de procesos
Una vez arrancado init, este inicia los scripts de inicio, que activan los
demonios:
en BSD: ejecuta el script /etc/rc que a su vez ejecuta otros scripts
en System V: lee el fichero /etc/inittab desde el que se invocan scripts
situados en los directorios /etc/rcx.d
x es el nivel de ejecución o runlevel
3.2. Niveles de ejecución (runlevels)
El proceso init inicia el sistema en un determinado runlevel
el runlevel inicial especificado en /etc/inittab
Runlevel determinada con guración software que permite la ejecución de
una serio de procesos en la máquina
Los runlevels se identi can por números de 0 a 6
Runlevel Descripción
0 parada del sistema
1 modo monousuario; solo root puede entrar
2, 3, 4, 5 modos multiusuario
6 reiniciar el sistema
S también monousuario (usado por scripts)
La utilización de los runlevels 2-5 varía con la distribución de Linux:
en Debian los 4 son idénticos: modo multiusuario completo (con entorno
de ventanas, si disponible); por defecto se usa el 2
en RedHat y similares:
2:multiusuario sin NFS
3:multiusuario completo (sin ventanas)
4: no usado
5:multiusuario completo (con ventanas)
Es posible cambiar de runlevel en cualquier momento usando el comando
telinit o init:
Formato
telinit [-t SEC] runlevel
SEC es el número de segundos que esperará init a que un proceso se
detenga con un SIGTERM antes de antes de matarlo con un SIGKILL
(por defecto, 5)
Ejemplo: pasa al runlevel 6 en 10 segundos (reinicia la máquina)
telinit -t 10 6
Es posible hacer que init relea el chero de con guración /etc/inittab:
telinit q
podemos saber en que runlevel nos encontramos con el comando runlevel
runlevel: muestra el runlevel actual y el anterior
# runlevel
N 2
indica que nos encontramos en el nivel 2 y que no hubo nivel
anterior
El fichero /etc/inittab
Define como se ejecutan los runlevels
indica el runlevel por defecto
indica los scripts a ejecutar en cada runlevel
Formato de las líneas de inittab
identificador:runlevels:acción:proceso
identificador: nombre asociado a cada línea del chero generalmente
no superior a 4 caracteres
runlevels: lista de runlevels (todos seguidos) para los cuales esta línea
se tendrá en cuenta
acción: indica de qué forma o bajo qué condiciones se ejecuta el comando
del campo siguiente
proceso: comando que se ejecuta para esta entrada en los runlevels
especificados
Algunas de las acciones de init son (para verlas todas ver el manual de
inittab)
respawn: el proceso se reinicia si termina
wait: init inicia el proceso y espera a que termine para seguir
once: init inicia el proceso una vez, cuando se entra en el runlevel
sysinit: el proceso se ejecuta durante el arranque de la sistema
ctrlaltdel: el proceso se ejecuta si se recibe un CTRL-ALT-DEL
powerwait: el proceso se ejecuta cuando se acaba la batería
powerokwait: el proceso se ejecuta cuando se recupera la energía
powerfailnow: el proceso se ejecuta cuando la batería está casi vacía
Ejemplo de inittab
# Número de runlevel por defecto.
id:2:initdefault:
# Script que se ejecuta siempre en cada inicio
# independientemente del runlevel.
si::sysinit:/etc/init.d/rcS
# Script para cada runlevel
l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
l2:2:wait:/etc/init.d/rc 2
l3:3:wait:/etc/init.d/rc 3
l4:4:wait:/etc/init.d/rc 4
l5:5:wait:/etc/init.d/rc 5
l6:6:wait:/etc/init.d/rc 6
# Normalmente no se alcanza, sólo si falla el reinicio
z6:6:respawn:/sbin/sulogin
# Qué hacer si se presiona CTRL-ALT-DEL
ca:12345:ctrlaltdel:/sbin/shutdown -t1 -a -r now
# Qué hacer si la corriente se va/vuelve
pf::powerwait:/etc/init.d/powerfail start
pn::powerfailnow:/etc/init.d/powerfail now
po::powerokwait:/etc/init.d/powerfail stop
el script /etc/init.d/rcS se ejecuta en el arranque
este script llama a los scripts del directorio /etc/rcS.d
Por cada runlevel, se ejecuta el script /etc/init.d/rc X
este script llama a los scripts del directorio /etc/rcX.d
53
Directorios /etc/rcX.d
Los ficheros de estos directorio son de la forma:
[K|S]NN Servicio
Al entrar en un runlevel se ejecutan todos los ficheros del /etc/rcX.d correspondiente
los que empiezan por K detienen servicios
los que empiezan por S los inician
los scripts se ejecutan por orden alfabético (primero K y después S)
Todos los fi cheros son enlaces a los scripts reales, que están en el directorio
/etc/init.d
estos script admiten, al menos, uno de los siguientes parámetros:
star inicia el servicio
Stop para el servicio
Ejemplo, para y reinicia los servicios de red:
# /etc/init.d/networking stop
# /etc/init.d/networking start
Si queremos iniciar un nuevo servicio en un determinado runlevel
colocar el script de inicio en /etc/init.d
hacer un enlace de nombre Sxy Servicio en el runlevel
tener en cuenta posibles dependencias con otros servicios
hacer un enlace de nombre tipo K en el runlevel en que se quiera pararlo
un buen número de secuencia es 100-xy (el orden de matar los
procesos inverso debe ser al de iniciarlos)
existen programas que nos facilitan la labor:
update-rc.d: crea y borra enlaces a los scripts init
sysv-rc-conf: GUI para consola
ksysv: entorno grá co para KDE
Terminales
Despues de ejecutar los scripts de inicio, init crea un conjunto de terminales
virtuales, siguiendo lo que se indica en /etc/inittab
.......
# Lanzar las terminales para el login de los usuarios
# Notar que el la mayoría de los sistemas tty7 es usado por X Window,
# así, para añadir mas getty's se debe saltar tty7
1:2345:respawn:/sbin/getty 38400 tty1
2:23:respawn:/sbin/getty 38400 tty2
3:23:respawn:/sbin/getty 38400 tty3
4:23:respawn:/sbin/getty 38400 tty4
5:23:respawn:/sbin/getty 38400 tty5
6:23:respawn:/sbin/getty 38400 tty6
en esta con guración, los runlevels 2 y 3 arrancan 6 terminales y los 4
y 5 sólo 1
podemos cambiar de tty con Ctrl-Alt-F[1-6 ]
el tty7 se utiliza para pasar al entorno de ventanas
los terminales se lanzan con spawn para que se vuelvan a crear cuando
salimos de la sesión
En este momento se puede acceder al sistema:
al iniciar la sesión en un terminal:
proceso tty se convierte en un proceso login que chequea usuario
y contraseña
si se accede con éxito, el proceso login se convierte en un shell
al salir de la sesión
el proceso bash muere
init relanza (respawn) un nuevo tty
3.3. Gestores de arranque
Los gestores de arranque más populares en Linux son LILO y GRUB
LILO
LILO (LInux LOader): sistema de arranque muy extendido
no depende de un sistema de ficheros especí co
no sabe leer sistemas de ficheros: sólo entiende localizaciones físicas
dentro del disco
puede arrancar núcleos de Linux desde diskettes y discos duros
permite arrancar Linux y otros sistemas operativos instalados en el
sistema
PC/MS-DOS, DR DOS, OS/2, Windows 9*/NT/XP, 386 BSD,
SCO UNIX, Unixware,. . .
permite pasar parámetros a cada kernel
Estructura de LILO
El bootloader propiamente dicho reside normalmente en /boot/boot.b
y se divide en dos partes:
Primera etapa: de pequeño tamaño para que quepa en un sector
de arranque, localiza y carga la segunda etapa
Segunda etapa: de mayor tamaño, con el resto de la lógica, se
carga directamente desde el fichero
La primera etapa se puede guardar en varios sitios, dependiendo del
sistema y del modo de arranque preferido:
en el MBR,
en el sector de arranque de una partición o de un disco exible
Los datos que necesita el bootloader para arrancar el sistema se encuentran
el fi chero map, generalmente en /boot/map
Con guración de LILO
La con guración se encuentra generalmente en el archivo /etc/lilo.conf
cada vez que modiquemos este archivo es necesario ejecutar el comando
/sbin/lilo
Lee el fichero de con guración, construye el map, lee las posiciones
de los ficheros que necesita leer y escribe la primera etapa del
bootloader en su lugar
Problemas
LILO depende de las funciones de la BIOS para acceder al disco
Si la BIOS no soporta el acceso a discos grandes (anteriores a 1998),
la segunda etapa y todos los demás cheros que se usen, deberán estar
en sectores dentro de los 1024 primeros cilindros del disco
LILO debe saber la posición física en disco de los cheros que carga: si
esta posición cambia y LILO no se reinstala, el arranque fallará
Ejemplo de fichero/etc/lilo.conf
# Opciones globales
lba32
boot=/dev/hda
install=/boot/boot.b
map=/boot/map
prompt
timeout=50
default=linux
# imágenes del kernel:
image=/boot/vmlinuz--2.4.27-2-386
label="Linux 2.4.24"
root=/dev/hda2
initrd=/boot/initrd.img-2.4.27-2-386
read-only
image=/boot/vmlinuz-2.4.20-3-686
label="Linux 2.4.20"
root=/dev/hda2
initrd=/boot/initrd.img-2.4.27-2-386
append="single"
# otros sistemas operativos:
other=/dev/hda1
label="Windows"
table=/dev/hda
Opciones globales
lba32 permite acceso a discos de más de 8 GB
boot=/dev/hda dispositivo o partición donde se instala LILO
install=bootloader indica el bootloader a usar, modo texto (boot-text.b),
modo menú (boot.b) o modo grá co (boot-bmp.b)
map=map-file posición del chero map
prompt hace que se muestre el prompt
timeout=50 si no se recibe una entrada del usuario en 5 segundos arranca
la imagen predeterminada
default=linux la imagen predeterminada que será cargada
Opciones para las imágenes
image=/boot/vmlinuz... indica el fichero del kernel a cargar
label=... nombre como aparece en el menú
root=/dev/hda2 dispositivo que tiene la partición raíz
initrd=/boot/initrd... archivo que contiene la imagen que será cargada
en el disco RAM inicial
append=... añade la línea especi cada a los parámetros iniciales del
kernel
read-only cuando se arranca la imagen del kernel se montará el -
lesystem raíz de sólo lectura, para que pueda ser chequeado por fsck
other=... permite indicar otros SO
table=/dev/hda indica donde está la tabla de particiones de este SO
GRUB
GRUB (GRand Unified Bootloader) es un sistema de arranque más potente
que el anterior
desarrollado dentro del proyecto GNU
es el preferido en muchas de las distribuciones actuales de Linux
diseñado para uni car el arranque entre los SO para x86
implementa el estándar Multiboot, que permite cargar varias imá-
genes de arranque, necesarias para cargar kernels modulares (GNU
Hurd)
a diferencia de LILO, GRUB entiende los sistemas de cheros en tiempo
de arranque
no es necesario conocer posiciones físicas a priori
no es necesario ejecutar ningún programa cada vez que se cambia
la con guración: sólo cuando se instala o actualiza GRUB
Detecta automáticamente si el direccionamiento LBA está soportado
por la BIOS
Permite arrancar un kernel desde la línea de comandos del arranque
sin con guración previa
Arranque con GRUB
el arranque pasa por varias etapas:
en la etapa 1 se lee el MBR, que se encarga de pasar a las etapas
siguientes
en la etapa 2 se accede al filesystem y se lee el fichero de configuración
el fichero de confi guración es, normalmente, /boot/grub/menu.lst
a diferencia de LILO, si se modi ca el chero de con guración no es
necesario reinstalar el MBR
Un ejemplo de /boot/grub/menu.lst
timeout 10
default 0
# Menú para arrancar Linux
title Debian GNU/Linux, kernel 2.4.27-2-386
root (hd0,1)
kernel /vmlinuz-2.4.27-2-386 root=/dev/hda3 ro
initrd /initrd.img-2.4.27-2-386
savedefault
boot
# Menú para arrancar Linux en modo monousuario
title Debian GNU/Linux, kernel 2.4.27-2-386
root (hd0,1)
kernel /vmlinuz-2.4.27-2-386 root=/dev/hda3 ro single
initrd /initrd.img-2.4.27-2-386
savedefault
boot
# Menú para arrancar Windows
title Windows
rootnoverify (hd0,0)
makeactive
chainloader +1
Opciones generales
timeout 10 espera 10 segundos para arrancar
default 0 arranca la primera de las imágenes
si default saved arranca la última imagen salvada con savedefault
Opciones para las imágenes
title título que aparece en el menú
root (hd0,1)
indica que el kernel está en la segunda partición de hda
kernel /vmlinuz...root=/dev/hda3 ...
indica el fi chero del kernel y donde se encuentra el directorio raíz
si boot se encontrara en la misma partición que raíz (hda3) habría
que poner
root (hd0,2)
kernel /boot/vmlinuz...root=/dev/hda3...
savedefault usado con default save; salva esta entrada como entrada
por defecto para el próximo arranque
boot arranca la imagen cargada (puede no ponerse)
rootnoverify arranca desde la partición pero no intentes montarla
makeactive pon la partición como activa (para poder arrancar desde
ella)
chainloader +1 encadena con el cargador de Windows
Existen muchas más opciones
para saber más ver el manual de GRUB en
http://www.gnu.org/software/grub/manual/
Reinstalar GRUB
podemos usar grub-install para reinstalar un GRUB estropeado
Formato:
grub-install [opciones] dispositivo
Ejemplo: instala GRUB en /dev/hda
# grub-install /dev/hda
Opciones:
--root-directory DIR instala GRUB en DIR/boot en vez de en
/boot
Paso de parámetros al kernel
Al iniciar LILO o GRUB es posible pasar parámetros al kernel7
o bien indicandolos directamente en el menú inicial,
o añadiendolos en lilo.conf o menu.lst
Alguno de estos parámetros son:
Parámetro Función
init=comando haz que el comando inicial sea comando en vez
de init
root=device cambia el dispositivo del lesystem raíz
mem=valor indica al kernel la memoria del sistema, p.e.
mem=256M
ro/rw monta el lesystem raíz de sólo lectura/
escritura
single inicia en modo monousuario
acpi=[on|off] activa/desactiva el soporte ACPI (Advanced
Configuration and Power Interface )
3.4. Apagado del sistema
El apagado del sistema debería implicar los siguientes pasos:
1. envío de avisos a los posibles usuarios conectados
2. enviar una señal de TERM para terminar los procesos (si no terminan,
enviar KILL)
3. pasar a modo monousuario
4. realizar un sync para vaciar los buers al disco
El comando shutdown realiza todos estos pasos
Formas de apagar el sistema
Además del botón de apagado (poco recomendable) hay varias formas de
apagar el sistema:
Enviar una señal TERM a init
no siempre funciona
conveniente hacer varios sync antes
Cambiar al runlevel 0 (apagar) o 6 (reiniciar)
Usar el comando shutdown
forma más recomendable
Usar otros comandos como halt, reboot o poweroff
Comando shutdown
Permite apagar el sistema de forma segura
Formato
shutdown [opciones] tiempo [aviso ]
espera el tiempo indicado antes de apagar o reiniciar
puede indicarse una hora (formato hh:mm) o dentro de tantos
minutos (formato +m)
si se indica now se apaga en el momento (equivale a +0)
envía un mensaje de aviso a los usuarios
si no se indica, envía uno por defecto
5 minutos antes de apagar, shutdown crea el fichero /etc/nologin e
impide que se conecten más usuarios
Opciones:
-h apaga el sistema (halt)
-r reinicia el sistema
-c cancelar un shutdown pendiente
-f dependiendo del sistema
evita el fsck al reiniciar (fastboot), o
inicia el modo monousuario
Ejemplo: apaga el sistema en 10 minutos
# shutdown -h +10 .El sistema se va a apagar"
Ejemplo: reinicia el sistema de inmediato
# shutdown -r now
4.1. El kernel de Linux
Algunas características
Kernel de tipo monolítico, con soporte para carga/descarga de porciones
del kernel (módulos) bajo demanda
Soporte para aplicaciones multithread
Soporte para multiprocesamienrto simétrico (SMP)
Soporte de múltiples sistemas de cheros
Distribuido bajo licencia GPL
Versiones del kernel
Cada versión del kernel se identi ca con tres o cuatro números, p.e. 2.4.27
El primer número representa la versión (actualmente la 2)
El segundo representa la revisión principal (major revision); cambia
cuando se introducen nuevos drivers o características al kernel
si es un número impar, se trata de un kernel experimental (no
recomendado para instalar)
si es par, es un kernel estable o de producción (revisión actual 2.6)
el tercer número indica la revisión secundaria (minor revision); la
última versión, a 26/11/2007 es la 2.6.23
el cuarto número (opcional) indica modi caciones pequeñas en el
kernel (a fecha 26/11/2007 la última versión estable era la 2.6.23.9)
Las diferentes distribuciones pueden introducir otra numeración para
indicar parches, p.e. 2.6.22-10
Podemos obtener la última versión en www.kernel.org
Para ver la versión instalada en el sistema usar el comando uname
Actualización del kernel
La mayoría de las distribuciones incluyen versiones compiladas del kernel
¿Para qué compilarlo entonces?
tenemos un dispositivo o queremos dar soporte a un servicio no
soportado por el kernel oficial
algunas aplicaciones que queremos usar requieren soporte de un
kernel nuevo o de alguna de sus prestaciones, que no aparecen
activadas en el kernel precompilado
queremos optimizar las prestaciones de nuestros dispositivos
Si lo único que queremos es actualizar a una versión superior del kernel,
podemos bajar un paquete ya compilado:
en Debian instalar kernel-image-
linux-image-
este paquete nos instala la versión comprimida del kernel en /boot/vmlinuz-
y los módulos en
/lib/modules/
además modi ca el GRUB (o LILO) para permitir cargar el nuevo
kernel
Para compilar el kernel, tenemos que obtener los fuentes
en Debian, paquetes kernel-source-
linux-source-
Este paquete instala las fuentes comprimidas en /usr/src
1. descomprimirlo con
tar xvjf kernel-source-
2. crear un enlace simbólico de nombre linux en /usr/src
Actualización mediante parches
Podemos actualizar el kernel mediante parches incrementales
1. Descargar los parches para la nueva versión del kernel
si queremos pasar de la versión 2.4.15 a la 2.4.17 hay que aplicar
parches para pasar a la 2.4.16 y luego a la 2.4.17
2. Aplicarlos con el comando patch
# zcat parche | patch -p0
Los parches también sirven para añadir funcionalidades (p.e. nuevos drivers)
no incluidos en el kernel oficial
después de instalar el parche tenemos que recompilar el kernel
Comandos patch y diff
Permiten crear y aplicar parches
diff muestra la diferencia entre cheros de texto, línea a línea
el formato de la salida permite usarlo para crear parches
patch aplica un fichero de diferencias, creado con diff a un original
Ejemplo:
[patch]$ cat old/file.txt
Este es un fichero simple
[patch]$ cat new/file.txt
Este es un fichero algo más complicado
[patch]$ diff -uNr old new > parche
[patch]$ cat parche
diff -uNr old/file.txt new/file.txt
--- old/file.txt 2005-10-10 18:22:51.000000000 +0200
+++ new/file.txt 2005-10-10 18:19:41.000000000 +0200
@@ -1,2 +1,2 @@
Este es un
-fichero simple
+fichero algo más complicado
[patch]$ cd old
[old]$ cat ../parche | patch -p1
patching file file.txt
[old]$ cat file.txt
Este es un
fichero algo más complicado
la opción -p1 de patch quiere decir: Elimina la parte del path en el
nombre hasta la primera barra e intenta aplicar el parche con el nombre
reducido de esa forma
Con figuración del kernel
Dentro del directorio /usr/src/linux accedemos podemos acceder al menú
de con guración de distintas formas
1. make config interfaz básica en modo texto; complejo y poco recomendable
2. make menuconfig interfaz de menú para consola, fácil de usar (necesita
instalar los fi cheros de desarrollo de la librería ncurses, en Debian
paquete libncurses5-dev)
3. make xconfig interfaz grá co para entorno de ventanas; basado en la
librería QT (en Debian, instalar paquete libqt3-dev)
4. make gconfig otro interfaz grá co para entorno de ventanas; basado
en la librería GTK (en Debian, instalar paquete libglade2-dev,
libgtk2.0-dev)
Dentro de los menús se pueden con gurar las opciones que incluirá el nuevo
kernel
Algunas opciones pueden ser compiladas directamente en el kernel o
como módulos que se cargarán o no cuando el kernel esté en funcionamiento
y sean necesarios
Otras opciones activan la disponibilidad de opciones nuevas al ser marcadas
Si deseamos utilizar alguna con guración anterior copiamos su chero de
con guración, normalmente /boot/config-
dentro del directorio del kernel
make oldconfig usa la con guración del .config
make oldconfig xconfig parte de la con guración vieja para modi carla
Más detalles sobre la con guración en el Kernel HOWTO
Compilación del kernel
Varios pasos:
1. make dep (sólo kernels anteriores a 2.6) construye las dependencias
para realizar la compilación real
2. make bzImage (o make para kernels 2.6) compila y crea una imagen
comprimida
3. make modules (sólo kernels anteriores a 2.6) compila las partes que han
sido marcadas como módulos
4. make modules_install instala los módulos del kernel en el sistema
normalmente se instalan en /lib/modules/
Para kernels 2.6 make reemplaza a make dep, make bzImage y make modules
La compilación puede fallar por:
Problemas con la versión usada de gcc
Por errores al configurar el kernel, algunas de sus dependencias no se
cumplen (posible bug de la herramienta de con guración, o se terminó
mal. . . )
La versión bajada del kernel tiene errores (poco probable)
Si falla y se subsana el error, es recomendable limpiar el kernel antes de volver
a compilar:
make clean borra cheros objeto, cheros intermedios y las imágenes
generadas
make mrproper deja el kernel en el estado en el que estaba cuando se
descomprimió (borra también la con guración realizada)
Para más detalles leer los cheros README de la documentación del kernel
(directorio /usr/share/doc/)
Instalación del kernel
Ya sólo resta crear el RAMDisk inicial e instalar el kernel:
1. Crear la imagen initrd
RAM disk que contiene los módulos necesarios para iniciar el sistema
y montar la partición raíz, y cargar el resto de módulos
sólo necesario si los controladores de disco se han compilado como
módulos
para crearlo se usa:
update-initramfs -c -k kernel-version
el formato puede variar según la distribución8
2. Instalar el nuevo kernel
a) Copiar los ficheros bzImage y System.map al directorio de arranque
del kernel (/boot)
Renombrar bzImage a vmlinuz-
System.map-
b) Configurar GRUB o LILO para poder cargar la nueva imagen
IMPORTANTE: por si algo falla, permitir la posibilidad de que se cargue la
imagen anterior
Instalar el kernel en Debian
Debian tiene una utilidad para simplificar el proceso de compilar e instalar
el kernel:
make-kpkg (paquete kernel-package) compila y crea un paquete Debian
con el kernel compilado
Ejemplo:
make-kpkg --revision=custom.1.0 kernel_image
el paquete creado se instala con dpkg -i
si es necesario, crear el initrd y modi car GRUB o LILO para que
cargen este initrd9
4.2. Módulos
Cuando se solicita la ejecución de una función no disponible en el kernel
residente, el módulo correspondiente se carga dinámicamente en memoria
Después de un período especí co de inactividad, el módulo se puede
quitar de la memoria
El mecanismo que posibilita la carga dinámica de los módulos es un
subproceso del kernel denominado kmod
No todos los módulos se cargan automáticamente:
algunas aplicaciones cargan los módulos que necesitan en el arranque
(ficheros /etc/init.d)
se pueden cargar/descargar módulos a mano usando comandos
como modprobe
en algunas distribuciones (Debian), es posible cargar módulos al
inicio indicándolo en el chero /etc/modules
Los cheros de módulos se almacenan, normalmente, en el directorio /lib/modules/
si modi camos los módulos, se debe ejecutar depmod para actualizar
el fichero de dependencias
Comando modinfo permite obtener información sobre los módulos
Ejemplo:
# modinfo ext3
filename: /lib/modules/2.6.10-1-686-smp/kernel/fs/ext3/ext3.ko
author: Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore description: Second Extended Filesystem with journaling extensions
license: GPL
vermagic: 2.6.10-1-686-smp SMP preempt 686 gcc-3.3
depends: mbcache,jbd
Ficheros de con guración
Los cheros de con guración que usa modprobe dependen de los paquetes de
administración de módulos que tengamos instalados
Kernel 2.4, paquete modutils !
Fichero /etc/modules.conf + directorio /etc/modutils/
Kernel 2.6, paquete module-init-tools !
fichero /etc/modprobe.conf + directorio /etc/modprobe.d/
En estos cheros se especi can alias para los módulos, opciones para los
módulos, acciones a realizar en la carga y descarga del módulo, etc.
ver man modprobe.conf para más información
4.3. Dispositivos
Dispositivo (device) cualquier tipo de sistema físico o lógico con el que
interactúa el kernel
Dispositivo físico: p.e. discos, dispositivos serie, CD, etc.
Dispositivo lógico: p.e. terminales virtuales, memoria, puertos, etc.
Driver de dispositivos parte del kernel que se encarga de interactuar con
el dispositivo
puede estar compilado en el kernel o puede cargarse como un mó-
dulo
el fichero /proc/devices lista los drivers cargados en el kernel
Ficheros de dispositivos ficheros especiales que permiten a las aplicaciones
interactuar con los dispositivos mediante rutinas estándar de manejo
de ficheros (open, read, etc.)
están localizados en el directorio /dev
Tipos de dispositivos
Tenemos distintos tipos de dispositivos
Dispositivos terminales para comunicarnos con el sistema
Terminales virtuales: dispositivos /dev/ttyX con X de 0 a 63
asociados a las distintas consolas de texto
Pseudoterminales: pares de archivos de dispositivo que sirven como
canal de comunicación entre procesos
No controlan ningún dispositivo físico real
Lo que se escriba en cualquiera de los dos será recibido por el otro
Se utilizan en conexiones remotas y en terminales del entorno de
ventanas
Los archivos del par se llaman maestro y esclavo
Notación BSD: maestros /dev/ptyXX, esclavos /dev/ttyXX
Notación Unix98: maestro /dev/ptmx (sólo uno), esclavos /dev/pts/X
(son creados automáticamente por un sistema de archivos virtual,
devpts)
Dispositivos terminales serie: dispositivos /dev/ttySX
dispositivos asociados a los distintos puertos serie
Comandos relacionados:
tty muestra el terminal en el que estamos conectados
stty permite cambiar características del terminal
Ejemplos:
$ stty -a # muestra las características
actuales
$ stty werase ^? # cambia el backspace
para que borre palabras
Otros dispositivos
Discos
IDE: /dev/hda, /dev/hdb, /dev/hdc, /dev/hdd
SCSI: /dev/sdX con X siendo a, b, . . .
Floppy: /dev/fdX (pueden llevar un código indicando el tipo de
disco y capacidad)
Particiones: el dispositivo seguido de un número
Dispositivos de loop: /dev/loop0, /dev/loop1,. . .
permiten usar un fichero como si de un dispositivo de disco se
tratase: los datos se escriben y se leen en el fichero, en vez de en
pistas y sectores del disco real
Ejemplo: monta una imagen de un CD
# mount -o loop,ro -t iso9660 imagen.iso /mnt/iso
es posible incluso crear ficheros encriptados que nos monten una
partición del disco
ver los manuales de mount y losetup para más información
Otros:
dispositivos de memoria: /dev/mem, /dev/kmem, etc.
dispositivos de audio: /dev/audio, /dev/mixer, etc.
dispositivo /dev/zero: generador de valores nulos
dispositivo /dev/urandom: generador de valores aleatorios
estos dos últimos se suelen usar con el comando dd para crear
ficheros con valores iniciales nulos o aleatorios
Ejemplo: crea un fichero de 1K inicializado a valores aleatorios
$ dd if=/dev/urandom of=/tmp/fich bs=1 count=1K
Una lista de los dispositivos puede encontrase en:
la página www.lanana.org/docs/device-list/
el fichero Documentation/devices.txt en los fuentes de Linux
Características de los cheros de dispositivos
Un fichero de dispositivos es diferente a un fichero normal
Ejemplo
$ ls -l /dev/hda
brw-rw---- 1 root disk 3, 0 2004-09-18 13:51 /dev/hda
La primera letra (c o b) indica dispositivo de caracteres o de bloques
caracteres: lee o escribe byte a byte
bloques: lee o escribe bloque a bloque (bloques usualmente de 512
bytes)
Los dos números antes de la feche representan los números principal
(major) y secundario (minor) que identifican al dispositivo
Major number: identica el driver que maneja el dispositivo
Minor number: permite al driver identicar un dispositivo concreto
entre varios controlados por el mismo driver
Ejemplo:
$ ls -l /dev/hda /dev/hdb
brw-rw---- 1 root disk 3, 0 2004-09-18 13:51 /dev/hda
brw-rw---- 1 root disk 3, 64 2004-09-18 13:51 /dev/hdb
Creación de cheros de dispositivos
Para crear un fichero de dispositivos se usa el comando mknod
Comando mknod: crea cheros de caracteres o bloques (también puede
crear tuberías)
Formato:
mknod [opciones ] nombre tipo [major minor ]
Ejemplo:
# mknod /dev/hda b 3 0
El script MAKEDEV permite crear dispositivos de una forma fácil (sin necesidad
de conocer los números principal y secundario)
Ejemplo:
cd /dev; ./MAKEDEV -v hda
Gestión dinámica de dispositivos
Los UNIX tradicionales mantienen en /dev una lista estática de posibles
dispositivos
la mayoría de estos dispositivos no existen realmente en el sistema
esto puede suponer un problema para dispositivos que se enchufan en
caliente
En Linux existen herramientas para manejar estos dispositivos de forma dinámica:
devfs filesystem especial presente en varios UNIX, como FreeBSD y Linux
controla la creación, borrado y gestión de permisos de los cheros
de dispositivosel Linux 2.6 se ha abandonado en favor de udev
udev reemplazo de devfs en Linux 2.6, para la gestión de cheros de dispositivos
udev tiene un conjunto de ventajas respecto a devfs
se ejecuta en el espacio de usuario, y no en el del kernel, como
devfs
permite personalizar el nombre de dispositivo
esta última característica permite resolver el problema del nombre
asignado a dispositivos, que se enchufan en caliente (que puede
variar el función del orden en que se conectan)
Para más información sobre el uso de udev ver el siguiente artículo en Badopi
o este otro en Bulma
