Página siguiente Página anterior Índice general

16. Varios

16.1 Como generar un disquete de arranque (boot)

Puede ser muy útil, el tener en un disquete un núcleo para arrancar desde el. Para hacerlo, toma un disquete formateado y ve a la raíz de tu disco.

Identifica tu núcleo. El debe llamarse zImage o vmlinuz.

Cópialo en el disquete :

 
          cat /zImage > /dev/fd0 

después tu haces (ejemplo) :

 
          rdev zImage /dev/hda2 
el segundo parámetro debe ser el nombre de la partición raíz Linux de tu sistema.

Este disquete te permite arrancar (prueba !).

16.2 Mi contraseña, donde esta mi contraseña?

En resumen : Has perdido tu contraseña de root... Bueno, hay varias soluciones. La primera :

  1. Tu arrancas con las disquetes arranque y root de tu distribución.
  2. Te alojas en root (allí, no hay contraseña).
  3. Montas la raíz de tu disco duro : mount
  4. t ext2 /dev/hda1 /mnt
  5. Vas al repertorio /mnt. no te queda mas que editar el archivo /mnt/etc/passwd, y suprimir la contraseña de root : root::0:0:root:/root:/bin/bash.
Arrancas Linux normalmente, y no tienes necesidad de contraseña para alojarte en root.

Bueno, pasemos a otras soluciones : Rebootar el pc en modo single-user. Para esto, en el momento de arrancar con LILO, decirle LILO: linux single. Un shell root va aparecer . Atención : el teclado esta en qwerty y la partición en lectura sola. Para remediarlo :

 
      loadkeys /usr/lib/kbd/keytables/fr.map (es.map) 
      mount -w -n -o remount / 
Y utilizas el comando passwd, o editas el archivo /etc/passwd

16.3 Como limitar el reboot en single-user ?

El problema de arrancar en single-user, es que no importa quien puede pasar por la maquina en root. Para las empresas y las universidades, se plantea un problema de seguridad. Ciertas estaciones UNIX permiten colocar una contraseña en el EPROM de la maquina. Linux permite pedir la contraseña root en single-user.

Para esto, debes recuperar las fuentes del programa init que se lanza en el momento de iniciar el sistema. Al principio del programa init.c, modifica, la definición de la constante SOME_USER para que ella tenga el valor 2, recompilas init, y lo re-instalas.

Esta primera solución puede resultar de todas maneras insuficiente ya que una persona puede siempre arrancar sobre otro periférico (utilizando la opción root = MiLinux).

Utilizando Lilo, no hay problema ! basta agregar las lineas siguientes para cada una de las imágenes en el archivo /etc/lilo.conf:

 
  password = la contraseña  en claro 
  restricted 

(piensa en colocar este archivo en solo lectura para el super-utilisador sin ningún derecho para los otros !)

El arranque normal de cada imagen pasa sin problema y sin pedir la contraseña (importante si uno quiere que la maquina se reinicie sola en caso de lío : electricidad, reboot a distancia, ...) pero si uno quiere pasarle parámetros al núcleo en el momento del arranque, Lilo pide en este momento la contraseña

16.4 Consolas virtuales

Linux te permite trabajar al mismo tiempo en varias ventanas texto. Para pasar de una a otra, haz Alt + Fn donde n es el numero de la ventana virtual y Fn una tecla de función (por ejemplo F1, F2 ...). Tu puedes configurar el numero de ventanas en el archivo /etc/inittab.

Cuando estas bajo X, la combinación se vuelve Ctrl + Alt + Fn. es entonces posible regresar bajo X accediendo así a la consola que es empleada (la primera "libre", es decir no manejada por un getty). Si tienes 6 consolas virtuales (de Alt F1 hasta Alt F6 ); usa Alt-F7, por ejemplo.

Utiliza maj + paginas (teclas "SHIFT" y "pagina precedente" o "pagina siguiente") para "pasearse". Esto funciona también bajo xterm.

16.5 Francisación

locale // nls

Los "locales" son un sistema que permite gestionar lo mas apropiadamente posible las diferencias de lenguaje y de estilo de los utilizadores. Por ejemplo, los francófonos prefieren escribir 3,14 mejor que 3.14, no anotan las fechas como los Australianos (quienes no lo hacen como los Estados-Unidos), etc. Cada utilizador debe entonces poder escoger un local que le convenga y las aplicaciones bien hechas (raros son aquellos que gestionan completamente los locales pero numerosos son aquellos que les utilizan al menos un poco) se adaptan sin recompilación. En resumen, se trata de dejar las preferencias nacionales fuera de la aplicación, como con el sistema de recursos del Machinetoc.

Si eres programador, puedes consultar el locale-tutorial (distributions/jurix/source/libc/nls o sunsite/utils/nls) o el Mini- HOWTO sobre los Locales. Si tu eres simple utilizador, puedes conocer los locales instalados en tu sistema con local -a (los nombres parecen estar poco estandarizados, tendrás trucos del genero "fr_FR" o "fr_FR.ISO8859-1") y selecciona uno con las variables de entorno como LANG o LC_CTYPE (man local dará tal vez algo).

Si eres el administrador de una maquina, y los locales no funcionan como tu quieres, puedes leer el Mini-HOWTO sobre los Locales y/o este modesto texto.

Si tu Linux no llego con una instalación correcta de los locales ( no creo que exista una buena distribución de este punto de vista), tienes dos soluciones. Yo solo teste la primera y ella solo funciona bien con un núcleo superior o igual a 2.0 y una libc versión 5.2.18 o superior.

Primera solución : compilar los programas de la libc y utilizar el paquete WG15-collection.

Para esto, debes recuperar las fuentes de la libc. no es necesario compilarla completa, solo los programas de gestión de los locales, que permiten especialmente producir un archivo binario a partir de la fuente de un local. Para resumir la instalación :

Recuperar libc (aquí 5.2.18), por ejemplo en ftp://ftp.ibp.fr/pub/linux/GCC.

 
  (pasar root) 
  cd /usr/src 
  mkdir libc-5.2.18 
  chown <USERNAME libc-5.2.18 
  (salir de root) 
  cd libc-5.2.18 
  tar -xzvf /usr/tmp/libc-5.2.18.tar.gz 
  cd include 
  ln -s /usr/src/linux/include/asm . 
  ln -s /usr/src/linux/include/linux . 
  cd ../libc 

Y allí puedes leer las instrucciones en el README y hacer "./configure" ("make depend" es largo y no parece necesario si quieres solo los locales)

Si no quieres compilar toda la libc, te paras allí y :

 
  cd locale 
  make SHARED= programs 
  (pasar root) 
  mv localedef /usr/local/bin 
  mv locale /usr/local/bin 
  (salir de root) 

Tienes ahora los dos programas importantes. Ahora puedes generar los locales binarios a partir de las fuentes.

Una buena colección de fuentes se encuentra en el archivo WG15-collection.linux.tar.gz que se encuentra por ejemplo en ftp://ftp.ibp.fr/pub/linux/GCC ( debe su nombre a un "working group" Posix).

En este archivo, una vez destarado(?-)), hay una buena documentación (Intro). Si no quieres leerla, lo que hay que hacer es :

 
  (pasar root) 
  cd charmaps 
  mkdirhier /usr/share/nls/charmap 
  cp ISO_* /usr/share/nls/charmap 
  cd ../locales 
  mkdirhier /usr/share/nls/locale 
  cp POSIX ??_* /usr/share/nls/locale 
  mkdirhier /usr/share/locale 
  (la linea siguiente es lo que parece ser un bogue(error) en la 
  distribución) 
  localedef -c -i /usr/share/nls/locale/en_DK -f ISO_8859-1:1987 en_DK 
  (lleno de mensajes de errores del genero "item `yesstr' of category 
  `LC_MESSAGES' undefined" a ignorar) 
  localedef -c -i /usr/share/nls/locale/fr_FR -f ISO_8859-1:1987 fr_FR 
  (salir  de root) 

Tu puedes testar con local -a que el nuevo local es conocido desde ahora. Es todo. Los utilizadores pueden utilizar ya las variables de entorno de los locales como LANG o LC_CTYPE.

Segundo método, que no he podido hacer funcionar :

Recuperar nslutils (hoy nlsutils-0.5.tar.gz) por ejemplo (parece necesario recuperar los archivos de encabezados como localeinfo.h en la libc).

 
  make 
  make install 

Para testar tu instalación de los locales, puedes servirte de Perl 5.003 (es la primera versión de Perl que prueba que la instalación es correcta y si no produce un mensaje de error) o este programa:

 
 # include <stdio.h> 
 #include <ctype.h> 
 #include <string.h> 
 #include <locale.h> 
 #include <sys/types.h> 
 #define STRING  "bétö\b" 
  void main () 
  { 
      int i; 
      u_char c; 
      printf ("Setting locale: %s\n", setlocale(LC_ALL, "")); 
      for (i=0; i<strlen(STRING); i++)  { 
         c = STRING[i]; 
         printf ("%c (%d) is %s\n", c, (int)c, isprint((int)c)?"printable":"non-printable"); 
       } 
  } 

No debe imprimir en la pantalla Setting locale: (null) y, con el buen locale francés, debe encontrar que todos los caracteres, excepto el ultimo, son "printables".

Ciertos útiles GNU comienzan a ser francesados. Para tener esta posibilidad, añade en tu .bashrc las lineas siguientes :

 
  export LC_CTYPE=ISO-8859-1 
  export LANG=fr 

ispell

ispell es un corrector ortográfico, en francés. Tu puedes recuperarlo en ftp.ibp.fr en /pub/ispell. Es igualmente posible recuperar un diccionario francés para ispell en el mismo sitio en el repertorio /pub/ispell/francais.

Les acentos bajo bash

agrega en el archivo .inputrc las lineas siguientes :

 
  set meta-flag on 
  set convert-meta off 
  set output-meta on 

less

Es muy desagradable no tener los acentos cuando se hace un less o un more de un archivo. Para que este problema no aparezca, añade :

 
  export LESSCHARSET=latin1 

en el archivo /etc/profile.

less permite también examinar el contenido de diversos tipos de archivos (less toto.tar.gz...) :

 
  export LESSOPEN="|lesspipe.sh %s" 

Colocar el script siguiente en un repertorio cuyo nombre figura en el PATH :

 
  #!/bin/sh 
 
  lesspipe() { 
    case "$1" in 
    *.tar) tar tvvf $1 2>/dev/null ;; # View contents of .tar and .tgz files 
    *.tgz) tar tzvvf $1 2>/dev/null ;; 
    *.tar.gz) tar tzvvf $1 2>/dev/null ;; 
    *.tar.Z) tar tzvvf $1 2>/dev/null ;; 
    *.tar.z) tar tzvvf $1 2>/dev/null ;; 
    *.Z) gzip -dc $1  2>/dev/null ;; # View compressed files correctly 
    *.z) gzip -dc $1  2>/dev/null ;; 
    *.gz) gzip -dc $1  2>/dev/null ;; 
    *.zip) unzip - l $1 2>/dev/null ;; 
    *.lha) lha -v $1 2>/dev/null ;; 
    *.arj) arj l $1 2>/dev/null ;; 
    *.1|*.2|*.3|*.4|*.5|*.6|*.7|*.8|*.9|*.n|*.man) FILE=`file -L $1` ; #groff src 
      FILE=`echo $FILE | cut -d ' ' -f 2` 
      if [ "$FILE" = "troff" ]; then 
        groff -s -p -t -e -Tascii -mandoc $1 
      fi ;; 
    esac 
  } 
 
  lesspipe $1 

Formato de textos

Para gs y xdvi, hay que utilizar unas opciones especiales (en mi maquina, son los alias). Efectivamente, con frecuencia son configurados para un papel de tamaño anglo-saxon.

Estas opciones son las siguientes :

 
  gs -sPAPERSIZE=a4 
  xdvi -paper a4 
  ghostview -a4 

Para que dvips convierta los documentos en un formato papel a4, hay que especificar en el archivo config.ps (el camino varia en función de las versiones de LaTeX) :

 
  @ a4 210mm 297mm 
  @+ ! %%DocumentPaperSizes: a4 
  @+ %%PaperSize: a4 
  @+ %%BeginPaperSize: a4 
  @+ a4 

elm

Para que tu correo este en 8 bits (con acentos) sin necesidad de encapsularlo vía MIME u otra, agrega estas tres lineas en tu archivo ~/.elm/elmrc :

 
  charset = iso-8859-1 
  displaycharset = iso-8859-1 
  textencoding = 8bit 

16.6 TeX y los tipos de caracteres (police)

Ciertos personajes indelicados se permitieron modificar los tipos de caracteres Computer Modern sin cambiar el nombre Y ESTO ES CONTRARIO A TODOS LOS COPYRIGHTS de Knuth. Esto es EXTREMADAMENTE grave porque todo documento tipografiado con los tipos de caracteres no tendrá el mismo look que con los VERDADEROS Computar Moderan. Desafortunadamente, estos tipos de caracteres defectuosos fueron puestos sobre varios CDs Linux. Como trabajamos casi todos con los CDs slackware, conviene tener extremada atención.

Es por esto que debes verificar tu sistema. Para ello, es fácil, un buen viejo terminal y dos minutos de tiempo :

listo!, tienes los buenos tipos de caracteres (el valor clave a retener, es el 10.55559). Es suficiente ahora de responder `x' para que TeX se termine.

En caso contrario, tu sistema esta infectado. Basta recuperar las actualizaciones y el ciclo se completa.

16.7 Une tarjeta de sonido bien configurada

Cuando uno compila y se sirve de una tarjeta sonido en Linux, la gran pregunta es saber si la tarjeta esta correctamente configurada. Para esto, existe un archivo (/dev/sndstat) que da todas las informaciones sobre la configuración de la tarjeta :

 
  Sound Driver:3.5.4-960630 (Mon Nov 11 14:50:52 MET 1996 root, 
  Linux gandalf 2.0.25 #3 Mon Nov 11 11:44:54 MET 1996 i486) 
  Kernel: Linux gandalf 2.0.25 #3 Mon Nov 11 11:44:54 MET 1996 i486 
  Config options: 0 
 
  Installed drivers: 
  Type 1: OPL-2/OPL-3 FM 
  Type 2: Sound Blaster 
  Type 7: SB MPU-401 
 
  Card config: 
  Sound Blaster at 0x260 irq 5 drq 1,5 
  SB MPU-401 at 0x330 irq 5 drq 0 
  OPL-2/OPL-3 FM at 0x388 drq 0 
 
  Audio devices: 
  0: Sound Blaster 16 (4.11) 
 
  Synth devices: 
  0: Yamaha OPL-3 
 
  Midi devices: 
  0: Sound Blaster 16 
 
  Timers: 
  0: System clock 
 
  Mixers: 
  0: Sound Blaster 
 

Para ensayar la buena marcha de la tarjeta sonido, es suficiente enviar algunos archivos audio (.au) sur /dev/audio, etc.

16.8 Bug gcc

Ciertas versiones de gcc (2.7.0 a 2.7.2 comprendidos, pero no 2.7.2.1 y posteriores) tienen un bug con la opción -O2. Para identificarlo, ensaya este programa :

 
  /* sr_bug.c 
   * 
   * este programa hace un test  para un gcc bug. 
   * Para compilar este test program:  gcc -O2 sr_bug.c 
   * 
   * Algunas veces gcc para Intel CPUs genera codigos errados  en optimizacion 
   * nivel 2.  el codigo errado es 'almost right' y esta oculto dentro del 
    * programa que parece trabajar - incluyendo el Linux kernel. 
   * el bug es muy viejo y ya ha sido reportado.Desde el 19-Dec-95, 
   * el bug no ha sido fijado. 
   * 
   * Si cambias este código deberías testarlo, porque aun un 
   * mínimo cambio puede esconder  este elusivo bug. Si crees que  
   * fijaste el bug, por favor corre el test original  hasta 
   * estar seguro. Puedes encontrar el  test original abajo, despues de #if 0. 
   * Escribi esta versión del test en Ingles para hacerla convivial, y 
   * puede no ser tan solida  como el original. 
   * 
   * Algunas personas que conocen mas que yo: 
   * davis@space.mit.edu (John E. Davis) 
   * anlauf@crunch.ikp.physik.th-darmstadt.de (Harald Anlauf) 
   * craigs@iii2.iii.net (Craig Shrimpton) 
   * 
   * User-friendly versión by Albert Cahalan 
   * 
   */ 
 
  #include <stdio.h> 
 
  int gcc_sr_bug(void){ 
    static int Array[3]; /* must be static (or global) */ 
    unsigned int B = 3;  /* must be unsigned 32-bit */ 
    int i; 
    for(i=0; i<B; i++) Array[i] = i<item> 3; 
    for(i=0; i<B; i++) printf(<sq> %d,%d<sq>, i, Array[i]); 
    return !Array[1]; 
  } 
 
  int main(){ 
    printf(<sq>Testing for gcc bug...<sq>); 
    if(gcc_sr_bug()){ 
      printf(<sq>\n\nBad code! Your compiler generates bad output.\n\n<sq>); 
      printf(<sq>Add<item>fno-strength-reduce to your gcc command line\n<sq>); 
      printf(<sq>or put it into your gcc config file, such as in\n<sq>); 
      printf(<sq>/usr/lib/gcc-lib/i486-linux/2.7.0/specs.\n<sq>); 
      exit(1); 
    }else{ 
      printf(<sq>\nOK, no problem.\n<sq>); 
      exit(0); 
    } 
  } 

16.9 Emacs

Emacs es un editor de texte muy potente ya que es coherente y extensible pero consume muchos recursos (procesador y memoria). La mayor parte de quienes comienzan a emplearlo seriamente, explorando las documentaciones, no podrán dejarlo después.

Aquí esta un archivo de configuración de base :

 
  ;; 
  ;; Archivo .emacs: inicialización de emacs 
  ;;   Archivo de base : Guide du Rootard 
  ;; 
 
  (display-time)                     ;;Para tener la hora en la barre de estado 
  (setq display-time-24hr-format t)  ;; Formato 24 horas 
 
  ;; Nuevos modes 
  (autoload 'c++-mode   "cplus-md" "C++ Editing Mode" t) 
  (autoload 'perl-mode   "perl-mode" "Perl Editing Mode" t) 
  (autoload 'c-mode "c-mode" "C Editing Mode" t) 
  ; mejor  utilizar el "cc-mode" 
 
  ;; Auto-Mode Settings : posiciona el modo de acuerdo a  la extensión 
  (setq auto-mode-alist 
  (append '(("\.c$"  . c-mode)    ;; utiliza el modo C++ lo mismo para C 
  ("\.h$"  . c-mode) 
  ("\.C$"  . c++-mode) 
  ("\.H$"  . c++-mode) 
  ("\.cc$" . c++-mode) 
  ("\.C$"  . c++-mode) 
  ("\.pl$" . perl-mode)           ;; Perl 
  ("/tmp/snd\.[0-9]* " . text-mode);; Text (para el mail) 
  "[Rr][Ee][0-9]* " . text-mode) 
  ("\.ada$"  . ada-mode)          ;; Ada 
  ("\.spec$"  . ada-mode) 
  ("\.body$"  . ada-mode) 
  ("makefile$" . makefile-mode)  ;; Makefile 
  ("Makefile$" . makefile-mode) 
  ("Imakefile$" . makefile-mode)) 
  auto-mode-alist)) 
 
  # Remapes varies 
  (global-set-key "\eg" 'goto-line)       ;; ESC G = Goto line 
  (global-set-key "\eo" 'overwrite-mode) 
 
  (put 'eval-expression 'disabled nil) 
 
  ;; Accents... 
  (standard-display-european 1) 
  (load-library "iso-syntax") 
 
  ;; Sous X-Window, textos en colores (C/C++/Shell/Makefile,etc) 
  (cond (window-system 
  (setq hilit-mode-enable-list  '(not text-mode) 
  hilit-background-mode   'light 
  hilit-inhibit-hooks     nil 
  hilit-inhibit-rebinding nil) 
  (require 'hilit19) 
  )) 
  (if (not (equal window-system <sq><sq>)) 
  (global-set-key "\C-?" 'delete-char)) 
  )) 

Este archivo puede ser ampliamente mejorado. Para saber mas, consulta la documentación de Emacs (apoyar sobre "control-H" luego "i"), que esta bien hecha pero es un poco grande.

Anotación : es posible agregar las lineas siguientes para poder servirse de los acentos en el momento de la edición de los archivos en modo texto :

 
  (set-input-mode (car (current-input-mode)) 
                (nth 1 (current-input-mode)) 
                0) 
 

16.10 Protección de puertos en serie

La utilización de puertos en serie plantea un problema de protección : hay que evitar que dos procesos concurrentes accedan a un puerto en serie dado al mismo tiempo. Pero de otra parte, si se tiene un puerto en serie sobre el cual gira un getty para tratar llamadas de entrada, nos gustaria también poder utilizar el puerto serie para pasar las llamadas que salen.

Para resolver este problema, hay dos enfoques. El primero, es la protección por el núcleo. Utiliza dos dispositivos diferentes para acceder a un puerto serie : /dev/ttySn para las llamadas de entrada (le getty), y /dev/cuan para las llamadas de salida. Cuando el getty intenta abrir /dev/ttySn, esta bloqueado hasta que una llamada de entrada sea recibida y que el modem señal por la linea DCD del puerto serie.

Cuando el getty esta bloqueado en la llamada del sistema open, se puede aun utilizar el dispositivo /dev/cuan para las llamadas que salen (evidentemente, el getty esta bloqueado cuando DCD est activado para la llamada que sale...)

Por otra parte, una vez que /dev/cuan esta abierto, un proceso de otra sesión no puede abrirlo (si el sistema esta correctamente configurado -- consultar la opción sesion_lockout de setserial(8). Este evita que dos procesos intentando independientemente pasar una llamada de salida se encuentren escribiendo simultáneamente sobre el puerto serie.

La segunda técnica es la de "lock-files" (archivos-protegidos). Ella consiste, para cada proceso que utiliza un puerto serie, escribir su PID en un archivo especial. De esta manera, cuando otro proceso quiere utilizar el mismo puerto serie, verifica la presencia del archivo, lo encuentra, lee el PID en donde esta escrito, verifica que el proceso correspondiente existe, y sabe entonces que el puerto serie esta ocupado y que el no puede utilizarlo. En este caso, no se utilizan que los /dev/cuan.

Cada uno de los dos enfoques tiene sus ventajas y sus inconvenientes. El método de protección por el núcleo necesita emplear un modem en modo auto-respuesta, y autoriza la overtura del puerto serie por un proceso que quiere pasar una llamada de salida entre el momento en que el teléfono suena y el momento en que los modems han terminado de negociar (que puede tomar una decena de segundos.) El método de lock-files necesita una configuración homogénea de los programas utilizados (todos los programas deben buscar y colocar el lock-file en el mismo lugar, aceptando el formato PID en el que esta inscrito...) también necesita que el getty verifique periódicamente la existencia del lock-file, y puede entonces "fallar" una llamada que entra entre el momento en que un proceso libera el puerto serie y cuando verifica de nuevo la presencia del lock-file. Es también posible que un proceso de salida llegue a crear el lock-file entre el momento en que el getty detecta una llamada y cuando crea el lock-file para esta llamada.

La selección de un método es, finalmente, una decisión individual de cada administrador, sabiendo que el enfoque "lock-file" es mas flexible, pero menos elegante y mas delicado a establecer que la protección para el núcleo.

16.11 Minitel

Es muy agradable poder conectarse al Minitel. Recupera el programa xtel de Pierre Ficheux. Es un emulador Minitel muy simple de utilizar.

Puedes encontrarlo en ftp.ibp.fr en el repertorio /pub/X11/videotext/xtel.

16.12 Fax

Enviar documentos por FAX es perfectamente posible. Para hacerlo, puedes utilizar por ejemplo Hylafax.

Se encuentra en el sitio ftp.funet.fi en el repertorio /pub/mirrors/sgi.com/sgi/fax/source.

16.13 Módulos Cargables Esta parte se inspira completamente del articulo que escribí en el periódico "Les echos de Linux", en el mes de Julio 96.

Estructura del núcleo

El núcleo de un sistema UNIX puede ser representado bajo la forma de un objeto monolítico. Sin embargo, tal objeto posee el inconveniente de ser grande y estático. Cada vez que se desee agregar un nuevo dispositivo, es necesario recompilar el núcleo. Ademas, si uno utiliza ciertos gestionarios particulares raramente, se esta obligado a tenerlo en el núcleo, y hay tendencia a consumir memoria.

Que es un modulo cargable ?

Los módulos cargables, permiten reunir lo útil a lo agradable teniendo un núcleo más pequeño que posible, carga a la demanda si lo deseas de una manera manual por el super utilizador de la maquina, o de une manera automática. De esta manera, la ganancia de recursos no es despreciable.

La primera pregunta que uno puede hacerse, es : " Porque dos técnicas de cargamento ?"

La primera técnica es manual : hay que cargar o descargar los módulos a mano. La segunda es automática, gracias a la utilización de un demon especialista que es el esclavo del núcleo y que carga y descarga los módulos por él. De hecho, la versión 1.2 de Linux no ofrece la posibilidad de un cargamento manual que esta limitado al super-utilizador de la maquina y que es bastante pesado de manipular. En el desarrollo de la versión 2.0, un nuevo sistema implementado por Bjorn Ekwall permite efectuar un cargamento dinámico y automático de los módulos.

Compilación del núcleo

En el momento de la compilación del núcleo, es necesario especificar las opciones particulares para activar la utilización de los modulo cargables :


 
  gandalf# make config 
  * 
  * Loadable module support 
  * 
  Enable loadable module support (CONFIG_MODULES) [Y/n/?] 
  Set version information on all symbols for modules (CONFIG_MODVERSIONS) 
[N/y/?] 
  Kernel daemon support (e.g. autoload of modules) (CONFIG_KERNELD) [Y/n/?] 
  

He aquí el detalle de estas tres opciones :

Una vez configurado, es suficiente lanzar la compilación al igual que la instalación :


 
gandalf# make dep ; make clean 
  gandalf# make zImage 
  gandalf# make modules ; make modules_install 

Una vez que estas operaciones han sido efectuadas, los módulos se encuentran en el repertorio /lib/modules/x.y.z donde x.y.z que corresponde al numero de versión del núcleo. No nos queda sino mirar el cargamento.

Nota importante : todos los útiles de manipulación de los módulos son archivados en un archivo modules-2.0.0.tar.gz en el repertorio v2.0. EIlos son instalados, por defecto, por las distribuciones standards, pero es importante utilizar la buena versión.

Cargamento : método manual

El cargamento manual esta basado en tres comandos :

Su utilización te obliga ser super-utilisador. He aquí un ejemplo de utilización :
 
gandalf# insmod nfs.o 
  gandalf# lsmod 
  Module:        #pages:  Used by: 
  nfs               12            4 
  gandalf# mount -t nfs /truc /mnt 
  gandalf# lsmod 
  Module:        #pages:  Used by: 
  nfs               12            5 
  gandalf# cd /mnt 
  gandalf# cd / 
  gandalf# umount /mnt 
  Module:        #pages:  Used by: 
  nfs               12            4 
  gandalf# ps axu | grep nfs 
  root      5535  0.0  0.0     0     0  q2 SW  17:15   0:00 (nfsiod) 
  root      5536  0.0  0.0     0     0  q2 SW  17:15   0:00 (nfsiod) 
  root      5537  0.0  0.0     0     0  q2 SW  17:15   0:00 (nfsiod) 
  root      5538  0.0  0.0     0     0  q2 SW  17:15   0:00 (nfsiod) 
  root      5557  0.0  0.4   864   300  q2 S   17:16   0:00 grep nfs 
  gandalf# kill -9 5535 5536 5537 5538 
  gandalf# lsmod 
  gandalf# rmmod nfs.o 

Es necesario "matar"(killar) los 4 demons nfsiod porque ellos son lanzados cuando NFS es activado. Como puedes verlo, estas operaciones se vuelven relativamente difíciles. es por esta razón que el sistema de cargamento automático ha sido creado.

Cargamento automático : kerneld

Introducción

El sistema de cargamento automático de módulos permite reducir al mínimo la talla de su núcleo. El principio de funcionamiento es particularmente simple : un demon en modo usuario esta a la escucha de las ordenes del núcleo (vía un archivo de mensaje de tipo IPC Sistema V). Cuando un proceso intenta acceder a un recurso sistema (vía un llamado sistema open, etc...), el núcleo envía la orden de cargamento del modulo a kerneld. Una vez el mensaje es recibido, kerneld ejecuta un modprobe para cargar los módulos necesarios : Esquemas del cargamento/descargue de los módulos con kerneld

Consejos para la compilación del núcleo

En cambio, en el momento de la compilación del núcleo, es necesario colocar al menos el soporte para permitir el inicio de la maquina y el montaje de la raíz de tu sistema de archivo (por ejemplo, support IDE + ext2fs). Tu puedes tener todo el resto en modulo (tarjeta sonido, sistemas de archivos, tarjeta SCSI, etc).

Puesta en marcha

Esta parte, de modificacion, solo es valida si tu maquina no esta dotada de kerneld. Las nuevas distribuciones efectuan una instalacion correcta.

Para realizar la puesta en marcha del sistema de carga de módulos, es necesario efectuar ciertas modificaciones al nivel de tu configuración. En efecto, es necesario que en el momento de iniciar la maquina, el demon kerneld sea lanzado y realizar una especie de lista de dependencias de los módulos : ciertos módulos no pueden ser lanzados antes que otros no l sean. En un primer momento, hay que crear el archivo /etc/rc.d/rc.modules en el cual, tu colocas :


 
# Modules 
  # 
  # Creación de un enlace lógico para el núcleo corriente 
  # 
  # 
  /bin/rm -f /lib/modules/current 
  ln -sf /lib/modules/`uname -r` /lib/modules/current 
  # 
  # Creación de las dependencias 
  if [ \! -r /lib/modules/current/modules.dep ] 
  then 
          echo "Creating module dependencies" 
          /sbin/depmod -a 
  fi 
  # 
  # Carga de los módulos de arranque... 
  # 
  if [-x /sbin/kerneld ] 
  then 
          if find /lib/modules/boot -type f -o type l > /dev/null 2>&1 
          then 
                  echo "Loading boot-time modules" 
                  /sbin/modprobe -a -t boot \* 
          fi 
  else 
          echo "Loading modules" 
          /sbin/modprobe -a \* 
  fi 
  # 
  # Si usted posee otros tipos de demons kerneld a lanzar... 
  # 
  if [-x /sbin/kdsound ] 
  then 
          echo "Starting sound daemon" 
          /sbin/kdsound & 
  fi 

Esto permite generar las dependencias de tus módulos cada vez que inicias tu maquina. Enseguida, en el archivo /etc/rd.d/rc.S (puede depender de tu distribución...), conviene agregar :


 
# Start update. 
  /sbin/update & 
 
  # *** A AGREGAR *** 
  # Lanzamiento de kerneld lo mas pronto posible, de tal manera 
  # que los módulos de sistemas de archivos puedan ser cargados 
  if [ -x /sbin/kerneld ] 
  then 
          echo "kerneld running" 
          /sbin/kerneld 
  fi 
 
 
  # Un poco de limpieza 
  cat /dev/null > /var/adm/utmp 
 
  # Lanzamiento del script de los  módulos 
  if [ -f /etc/rc.d/rc.modules ]; then 
          /etc/rc.d/rc.modules 
  fi 

Una vez que estas modificaciones son efectuadas y la maquina reinicializada, todo debe quedar en su lugar. Si kerneld permite cargar automáticamente los módulos, permite igualmente descargarlos luego de cierto tiempo sin utilizarlos. Por defecto, si ningún proceso accede al modulo durante mas de 60 segundos, es automáticamente descargado. Es posible modificar este valor agregando el parámetro delay=Nb_Segundos a kerneld donde Nb_Secondes es la prolongación en segundos.

El archivo /etc/conf.modules

puede suceder que sea necesario configurar un ultimo archivo: el archivo /etc/conf.modules. este archivo contiene los caminos donde se encuentran los módulos que deben ser cargados y enseguida los alias para los módulos. Si tu no tienes este archivo, puedes crearlo con :


 
gandalf# /sbin/modprobe<item>c | grep<item>v '^path' >/etc/conf.modules 

puede suceder que en el momento del primer arranque obtengas este mensaje :

 
  Cannot locate module for net-pf-3 
  Cannot locate module for net-pf-4 
  Cannot locate module for net-pf-5 
Que no cunda el panico ! Este mensaje no es malo y para no tenerlo mas, añade en el archivo /etc/conf.modules :
 
  alias net-pf-3 off 
  alias net-pf-4 off 
  alias net-pf-5 off 

puede suceder que ciertos dispositivos tengan necesidad de ciertos parámetros particulares. Consulta el documento Kernel HowTo.

Algunas referencias

Tu puedes consultar estas referencias para mas información :


Página siguiente Página anterior Índice general