Bitaminas - Instalación de Terminales en Linux

Instalación de Terminales Linux

Fecha de creación: 15-1-1999
Fecha de actualización: 15-1-1999

Documento creado y mantenido por: Antonio J. Herrera Navarro (ajherrera@soslinux.com)

Este documento está abierto a observaciones y ampliaciones de otros autores. Los autores no responden a preguntas personales específicas; pueden realizar dichas preguntas en http://www.soslinux.com/foros

ÍNDICE

Arranque remoto sin disco duro ni disquette
Arranque remoto con disco duro o disquette

Arranque remoto sin disco duro ni disquette

Para arranque remoto sin disco duro ni diskette se usa una tarjeta de red con memoria EPROM. En ella se graba un programa que accede al servidor y obtiene el núcleo y los directorios básicos con el protocolo tftp. El resto del proceso es igual al de la sección "Arranque remoto con disco duro o disquette". Hay que preparar un rootdir para los clientes, instalar el protocolo bootp, tftp, etc...

Arranque remoto con disco duro o disquette

Se arranca con loadlin y una imagen comprimida del núcleo y se obtiene el rootdir vía NFS desde el servidor pero se necesita que los puestos tengan un disco local si se quiere montar una unidad o fichero swap, aunque los últimos núcleos permiten montar ficheros swap sobre NFS.

Lo mejor es crear un disco de arranque msdos que contenga loadlin y una imagen comprimida del núcleo y que el cliente obtenga su directorio raíz del servidor vía NFS. (No confundir el directorio raiz del servidor con el de los clientes). Otra opción es crear en el disco duro del cliente un subdirectorio y guardar allí el loadlin y la imagen comprimida del núcleo además de un archivo de configuración.

Los pasos a seguir son los siguientes:

Compilar el núcleo para las estaciones de trabajo con soporte para tarjeta de red, TCP/IP, soporte para sistemas de ficheros ( al menos NFS), opción "Root file system on NFS", etc.

Ir al directorio /usr/src/linux/ y ejecutar lo siguiente:

    make menuconfig 
    (para seleccionar las opciones del kernel mencionadas)
    make dep
    make clean
    make zImage 
    (para crear una imagen del núcleo comprimida)

Crear un nodo para NFS:
```
        mknod /dev/nfsroot b 0 255 
```

Ir al directorio /usr/src/linux/arch/i386/boot y ejecutar las siguientes órdenes:

    rdev zImage /dev/nfsroot 
    (para que el núcleo tome como raíz un sistema de ficheros NFS)
    dd if=zImage of=/dev/fd0 
    (opcional, sirve para transferir el núcleo a un disco de arranque)
    rdev /dev/fd0 /dev/nfsroot 
    (opcional, para indicar en el disco de arranque que el rootdir 
	es un sistema de ficheros NFS)
    rdev -R /dev/fd0 0 
    (opcional, sólo para el arranque en disco)

Crear en el servidor los directorios raíz de los clientes. Hay dos opciones:

a) Instalar el Linux que vayan a usar los clientes en un puesto y luego copiar todo el rootdir a un directorio del servidor, haciendo posteriormente algunos cambios.
b) Copiar directamente del servidor los archivos necesarios ( con cp -dpR para no perder información)
Crear para cada cliente un fichero swap: (éste fichero swap hay que crearlo directamente en discos de los clientes, a menos que se disponga de un núcleo que sí permita montar ficheros swap en sistemas NFS)
Ejecutar en cada cliente:
```
    dd if=/dev/zero of=/<dispositivo local>/swap bs=1024k count=8 
    (donde <disp. local> es un disco localen formato ext2 o msdos)
    mkswap /<dispositivo local>/swap
```
Estas instrucciones crean en el disco local del cliente un fichero swap de 8MB. Se puede intentar crear este archivo en el servidor ejecutando las dos órdenes anteriores y luego copiarlo a los clientes, pero puede que el archivo swap no funcione correctamente.
También hay que añadir la siguiente línea al archivo /etc/fstab de cada cliente:
```
    /<dispositivo local>/swap swap swap defaults 0 0
```
Copiar zImage al cliente y arrancar desde los puestos. Hay dos opciones:

a) Copiar zImage y loadlin.exe a un disco (disco de arranque msdos). Crear un archivo de texto llamado linux.par que contenga:
```
    a:\zImage
    rw
    root=/dev/nfsroot
    nfsroot=197.0.0.1:/exports/horus
    nfsaddrs=197.0.0.2:197.0.0.1:197.0.0.1:255.255.255.0:horus
```
En nfsroot=197.0.0.1:/exports/horus, 197.0.0.1 es la dirección del servidor de raíces NFS y /exports/horus es la raíz exportada para el cliente horus.
En nfsaddrs=......., 197.0.0.2 es la dirección del cliente, 197.0.0.1 es la dirección del servidor NFS, 197.0.0.1 es la dirección del gateway, 255.255.255.0 es la máscara de red y horus es el nombre del cliente.
(Si se van a usar direcciones dinámicas es necesario configurar un servidor con RARP o con BOOTP)
Para obtener más información consultar el archivo /usr/src/linux/Documentation/nfsroot.txt

Para arrancar ejecutar desde el disco de arranque la órden:
```
    loadlin @linux.par
```
b) Copiar zImage y loadlin.exe en el subdirectorio c:\linux del cliente. Crear el archivo linux.par igual que en la opción a) excepto la primera línea, que hay que sustituirla por:
```
    c:\linux\zImage
```
Crear un menú en el config.sys y en una sección que podemos llamar linux poner:
```
    shell=c:\linux\loadlin @c:\linux\linux.par
```
La sección en el autoexec.bat no tiene porqué aparecer, aunque se puede poner una sección para lo que se quiera.
Cuidado con smartdrv, no hay que cargarlo puesto que interfiere con loadlin