Configurando elilo

ELILO (EFI Linux Loader) un cargador de arranque con soporte EFI para Linux. Es similar a el viejo LILO (Linux Loader). Ambos son utilizados por Slackware, generalmente LILO para la versión de 32 bits (x86) mientras que ELILO es usado por Slackware64 (x86_64). Aunque también se puede usar GRUB2 como una opción.

Por la red hay muy poca documentación para ELILO, sin embargo para su configuración en Slackware se puede consultar la documentación oficial para ciertas cosas muy específicas.

Casi toda la información, en sitios y blogs de la web, que me he encontrado buscando como configurar ELILO hacen referencia a que es prácticamente igual a configurar el viejo LILO. Sin embargo hay cosas que nadie dice y que podrían ser de ayuda.

Los siguientes ejemplos fueron hechos en dos laptops ASUS (X401A y S301L) con Windows 8 (por default) y Slackware Linux (por gusto). El archivo de configuración de ELILO de mi sistema se encuentra en:

/boot/efi/EFI/Slackware/elilo.conf

Hibernación

La hibernación se resuelve exactamente como en LILO o GRUB2, agregando la dirección de la partición swap a la que se guardará la sesión completa al hibernar el equipo y de donde se volverá a cargar una vez que no volvamos a iniciar. Esta partición debe tener como mínimo el espacio equivalente a la cantidad de memoria RAM que tenga el equipo. Así que para restaurar la sesión basta decirle al kernel de donde continuar, por lo que debemos abrir el archivo de configuración de elilo y buscar la línea append, solo hay que agregar (sin borrar) nada la opción resume=/dev/sda# donde sda# es nuestra partición de intercambio o swap.

append="quiet resume=/dev/sda5"

Primero debimos haber creado espacio de intercambio suficiente durante la instalación de Linux, sino se debe crear una partición con alguna herramienta de gestión de particiones, gdisk por ejemplo, o bien usar una herramienta externa como GParted y luego activar la swap en Slackware con mkswap y swapon.

Por otro lado, si ya hay espacio swap suficiente solo debemos localizarlo, yo por ejemplo ejecuté el comando cat en el archivo /etc/fstab y verifiqué que mi partición swap es /dev/sda5, como se muestra.

$ cat /etc/fstab 
/dev/sda5        swap             swap        defaults         0   0
/dev/sda6        /                ext4        defaults         1   1
/dev/sda7        /home            ext4        defaults         1   2
/dev/sda1        /boot/efi        vfat        defaults         1   0
/dev/sda4        /windows         ntfs-3g     fmask=111,dmask=000 1   0
#/dev/cdrom      /mnt/cdrom       auto        noauto,owner,ro,comment=x-gvfs-show 0   0
/dev/fd0         /mnt/floppy      auto        noauto,owner     0   0
devpts           /dev/pts         devpts      gid=5,mode=620   0   0
proc             /proc            proc        defaults         0   0
tmpfs            /dev/shm         tmpfs       defaults         0   0

Brillo

Para el caso de que el brillo de la pantalla no cambie bajo ninguna circunstancia, hay algunas opciones del kernel que se pueden configurar para solucionarlo. Tienen que ver con ACPI. En mi caso la solución fue agregar lo siguiente en la línea append:

append="... acpi_osi="

Dual boot

Cuando adquirí la laptop ésta traía Windows 8 instalado, sin embargo como buen linuxero hice una instalación de mi distro favorita: Slackware. Y pues como ocupo Windows por cuestiones de compatibilidad en mi trabajo y además no iba a tirar a la basura el sistema por el que me vi obligado a pagar una licencia al adquirir el equipo, pues lo conservé.

Slackware permite instalar ELILO durante la instalación como cargador de arranque de manera automática, antes había que hacer alguna configuración “a mano” sin embargo las cosas han mejorado un poco, ya que para agregar la opción de Slackware al menú de selección del sistema operativo solo hay que seguir las instrucciones del programa eliloconfig.

Elilo no es como grub, al iniciar no aparecerá un menú para seleccionar el sistema con el que se desea iniciar, simplemente cargará Slackware. Si lo que deseas es algo como grub pues instala grub. Para seleccionar entre sistemas operativos se debe usar el menú propio del sistema. Por ejemplo, en mi caso que uso laptops ASUS el menú para seleccionar el SO aparece al presionar la tecla ESC al encender el equipo, en las opciones de la pantalla puedo seleccionar Windows o Slackware. Si no presiono la tecla ESC el sistema arrancará con Slackware por default, como si fuera el único SO instalado. Esto es conveniente para mí pues son pocas las veces que inicio con Windows y además me gusta que se inicie Slackware sin ningún tipo de retraso.

eliloconfig

El programa /usr/sbin/eliloconfig es el que se ejecuta durante la instalación de Slackware Linux El sistema reconoce de manera automática si se debe instalar lilo o elilo dependiendo del hardware.

IMPORTANTE: Cuando se haga alguna actualización del kernel es necesario ejecutar este programa para tener una configuración correcta. Para hacerlo solo hay que ejecutar el comando (como root):

# eliloconfig

Aquí un ejemplo de como se ve el programa corriendo…

Instalando ELILO:
eliloconfig-01

Instalando una entrada en el menú:
eliloconfig-02

Quitar las entradas antiguas:
eliloconfig-03

Finalizando:
eliloconfig-04

Estas son algunas de las cosas que he ido descubriendo al paso del tiempo.

Saludos!

Instalar y configurar GRUB2 en Slackware 14.0 (EFI)

En una publicación anterior he descrito como instalé Slackware en mi laptop con el asqueroso Windows 8 (hardware UEFI). En este proceso utilicé el GRUB de Ubuntu (por flojera) para decidir con cual sistema operativo iniciar, pero como casi no uso esta distro decidí buscar como instalar GRUB en Slackware y usarlo para este propósito, de esta manera sería independiente de Ubuntu.

Como usuario de Slackware estoy familiarizado con LILO y mi primera experiencia usando y configurando GRUB fue en los pocos días que usé Ubuntu, no es complicado pero tampoco es tan simple como con LILO a mi parecer. Pero en fin es a lo que me vi obligado con el nuevo hardware UEFI.

Mi desición más obvia con gusto sería dejar solo Slackware en el equipo, pero como tengo que sacar para la comida usando ArcGIS, Office, AutoCAD y demás cosas, decidí dejar el Windows 8 instalado en el equipo. Además pagué por la licencia cuando comp

Instalando GRUB2

La instalación de grub la hice de la siguiente manera: usé sbopkg para instalar todas las dependencias y luego instalé grub con el SlackBuild de la manera tradicional. Las dependencias quedaron con solo hacer:

# sbopkg -i "gnu-unifont os-prober locale-gettext help2man"

Y luego descargué el SlackBuild de grub y lo edité para agregar:

--with-platform=efi \

en la parte de ./configure.

Preparando todo

Para continuar seguí las instrucciones de instalación y configuración de grub publicadas en la documentación de Slackware aquí. Estas instrucciones son para instalar grub como cargador de arranque en hardware UEFI, que es precisamente lo que quiero hacer. Consisten básicamente en lo siguiente:

  • Instalar Grub2-efi en una memoria USB
  • Una vez que funcione el arranque desde la memoria USB instalar Grub2-efi en el disco duro
  • Modificar el menú de arranque UEFI

Instalar Grub2-efi en una memoria USB

Una vez instalado el paquete de grub en Slackware 14.0, hay que montar la memoria USB en el directorio /boot/efi (si es necesario hay que crearlo primero), luego ejecutar:

# mount /dev/sdb1 -t vfat /boot/efi (donde sdb1 es mi USB, se puede identificar con fdisk -l)
# modprobe dm-mod
# grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=grub --recheck --debug
# mkdir -p /boot/grub/locale
# cp /usr/share/locale/en\@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo

Luego configurar grub.cfg haciendo:

# grub-mkconfig -o /boot/grub/grub.cfg

Este proceso debió haber creado un archivo en la memoria con la siguiente ruta:

/EFI/grub/grubx64.efi.

Instalar Grub2-efi en el disco duro

La partición efi, sda1 en mi caso, debe montarse en el disco duro (yo hice un directorio llamado ~/efi y la monté aquí para no desmontar la memoria USB todavía). La partición tendrá una estructura como esta:

/EFI/Boot/bootx64.efi

En la mía también hay /EFI/Microsoft/Boot y el archivo efi de arranque de Windows es bootmgr.efi. Elegí la manera segura que es crear un directorio llamado /EFI/Linux/ y copiar aquí el archivo llamado grubx64.EFI desde la memoria USB.

Modificar el menú de arranque UEFI

Modificar el menú de arranque nos permite conservar Windows 8. El primer paso es descargar efibootmgr desde http://linux.dell.com/efibootmgr/.

Descomprimirlo, entrar al directorio creado y ejecutar make:

# make

Copiar src/efibootmgr/efibootmgr en /usr/sbin y cambiar el propietario (con chown) a root.

# chown root /usr/bin/efibootmgr

Desmontar la memoria y montar la partición efi (la mia es sda1) del disco duro en /boot/efi:

# mount /dev/sda1 -t vfat /boot/efi 
# modprobe efivars
# efibootmgr -c -g -d /dev/sda -p 1 -w -L "Linux" -l '\EFI\Linux\grubx64.EFI' 

Al reinicar apareció e grub de Slackware y no el de Ubuntu.

Pequeño inconveniente

Resta decir que al parecer Ubuntu reemplazó el archivo EFI de Windows (bootmgr.efi) por el suyo por que cuando seleccioné la opción para iniciar Windows en el menú grub de Slackware, me apareció el menú de grub de Ubuntu. Sin embargo existe un respaldo llamado bkpbootmgfw.efi que es el arrancador EFI de Windows real. Para solucionar esto, primero encontré el UUID de la partición FAT32 donde se encuentra este archivo UEFI:

# grub-probe --target=fs_uuid /boot/efi/EFI/Microsoft/Boot/bkpbootmgfw.efi 
6C27-EC36
# grub-probe --target=hints_string /boot/efi/EFI/Microsoft/Boot/bkpbootmgfw.efi 
--hint-bios=hd0,gpt1 --hint-efi=hd0,gpt1 --hint-baremetal=ahci0,gpt1

Y edité el archivo /etc/grub.d/40_custom para agregar:

menuentry "Microsoft Windows 8 x86_64 UEFI-GPT" {
        insmod part_gpt
        insmod fat
        insmod search_fs_uuid
        insmod chain
        search --fs-uuid --set=root --hint-bios=hd0,gpt1 --hint-efi=hd0,gpt1 --hint-baremetal=ahci0,gpt1 6C27-EC36
        chainloader /efi/Microsoft/Boot/bkpbootmgfw.efi
}

Finalmente actualizar el archivo /boot/grub/grub.cfg:

# grub-mkconfig -o /boot/grub/grub.cfg

Hibernación

Para habilitar el inicio desde hibernación edité el archivo /boot/grub/grub.cfg, colocando en la entrada del menú de Slackware:

linux /boot/vmlinuz... root=... resume=/dev/sda9 quiet ro

Donde sda9 es mi partición SWAP de 8 GB, el doble que la RAM. Todo funciona perfecto ahora.

¡Saludos!

Fuentes:

SlackBuilds.org
SlackDocs
Arch Wiki

Mejorando el tiempo de inicio de Slackware

Apenas unos días atrás decidí hacer una instalación fresca de mi sistema pues sentí que la necesitaba, y me la he pasado configurando mi nuevo Slackware 14.0 estos días. Les presento unas pequeñas notas de la forma en que hago para acelerar un poco el inicio de mi sistema.
La información que presento ha sido una “recopilación” de varios sitios de internet, foros, blogs y conocimiento que he ido adquiriendo desde que me inicié en Slackware.

LILO

Por su puesto que si vamos a meternos con el inicio del sistema, el lugar más obvio para empezar es Lilo. Para editar el archivo de lilo.conf hay que abrirlo con cualquier editor de texto, yo uso nano en el terminal:

# nano /etc/lilo.conf

Agregar las opciones quiet y compact de la manera siguiente:

append=" vt.default_utf8=1 quiet"
compact

Guardar y cerrar el archivo (Ctrl+X – Yes – ENTER) y elecutar lilo para que se reconozcan los cambios.

# lilo

Usando la opción quiet se reduce la cantidad de mensajes que aparecen en el inicio del sistema y así se ganan unos segundos en el inicio del sistema.

La opción compact intenta juntar diferentes peticiones de lectura de sectores del disco adyacentes entre si, en una sola, lo que reduce el tiempo de carga. En algunos sistemas (sobre todo antiguos) puede generar errores y cuelgues.

Servicios

Gran parte de lo que se tarda un sistema en iniciar se debe a la gran cantidad de servicios que se inician. Para ver los servicios que se ejecutan al inicio hay que ir al siguiente directorio, como usuario root:

# cd /etc/rc.d/
# ls -l

Checar cuales de los servicios que tienen permisos de ejecución, no se necesitan. Yo por ejemplo no necesito un servicio de bluetooth por que mi computadora no tiene hardware de este tipo. Para deshabilitarlo hay que hacer lo siguiente:

# chmod -x rc.bluetooth

Las necesidades de cada uno son muy diferentes, este es solo un ejemplo de las cosas que yo no necesito. Hay que saber también que servicios desactivamos, es importantísimo leer el Slackbook o buscar en internet cual es la función de un servicio que desconocemos y cuales serían las consecuencias de desactivarlo, para no regarla.

Scripts de inicio

Ahora pasasmos a los scripts de inicio, que se guardan en el archivo /etc/rc.d/rc.M. Se puede abrir con cualquier editor de texto que sea de tu gusto:

# nano /etc/rc.d/rc.M

Buscar (en nano la opción de búsqueda de texto es Ctrl+W) la palabra “local” y encontrará el siguiente código:

# Start the local setup procedure.
if [ -x /etc/rc.d/rc.local ]; then
  /etc/rc.d/rc.local;
fi

Colocarle un símbolo “&” (ampersand) como se muestra, para que esto se ejecute al mismo tiempo que otras acciones y no de manera única:

# Start the local setup procedure.
if [ -x /etc/rc.d/rc.local ]; then
  /etc/rc.d/rc.local &;
fi

Encontrar el siguiente bloque y comentarlo, para que quede así:

# Update any existing icon cache files:
#if find /usr/share/icons 2> /dev/null | grep -q icon-theme.cache ; then
#  for theme_dir in /usr/share/icons/* ; do
#    if [ -r ${theme_dir}/icon-theme.cache ]; then
#      echo "Updating icon-theme.cache in ${theme_dir}..."
#      /usr/bin/gtk-update-icon-cache -t -f ${theme_dir} 1> /dev/null 2> /dev/null &
#    fi
#  done
#  # This would be a large file and probably shouldn't be there.
#  if [ -r /usr/share/icons/icon-theme.cache ]; then
#    echo "Deleting icon-theme.cache in /usr/share/icons..."
#    #/usr/bin/gtk-update-icon-cache -t -f /usr/share/icons 1> /dev/null 2> /dev/null &
#    rm -f /usr/share/icons/icon-theme.cache
#  fi
#fi

También estos otros bloques:

# Update mime database:
#if [ -x /usr/bin/update-mime-database -a -d /usr/share/mime ]; then
#  echo "Updating MIME database: /usr/bin/update-mime-database /usr/share/mime &"
#  /usr/bin/update-mime-database /usr/share/mime 1> /dev/null 2> /dev/null &
#fi
# Update all the shared library links:
#if [ -x /sbin/ldconfig ]; then
#  echo "Updating shared library links: /sbin/ldconfig &"
#  /sbin/ldconfig &
#fi
# Update the X font indexes:
#if [ -x /usr/bin/fc-cache ]; then
#  echo "Updating X font indexes: /usr/bin/fc-cache -f &"
#  /usr/bin/fc-cache -f &
#fi

De nuevo, hay que leer más para saber bien que estamos haciendo. Todo el código del script que se puso como comentario, es para dejar de ejecutar procesos o servicios que realizan tareas como actualizar cachés y prevenir errores debidos a la instalación de nuevos paquetes, así que no es necesario ejecutarlos cada vez que iniciamos el sistema, con una vez al día basta (o incluso semanalmente).
Entonces hay que crear un script que se ejecute diariamente y realice estas tareas, para crear el archivo del script hay que hacer (con nano):

# nano /etc/cron.daily/config.sh

Y pegar lo siguiente, que no es más que todos los pedazos de código que comentamos anteriormente:

#!/bin/sh
# Update any existing icon cache files:
if find /usr/share/icons 2> /dev/null | grep -q icon-theme.cache ; then
  for theme_dir in /usr/share/icons/* ; do
    if [ -r ${theme_dir}/icon-theme.cache ]; then
      echo "Updating icon-theme.cache in ${theme_dir}..."
      /usr/bin/gtk-update-icon-cache -t -f ${theme_dir} 1> /dev/null 2> /dev/null &
    fi
  done
  # This would be a large file and probably shouldn't be there.
  if [ -r /usr/share/icons/icon-theme.cache ]; then
    echo "Deleting icon-theme.cache in /usr/share/icons..."
    #/usr/bin/gtk-update-icon-cache -t -f /usr/share/icons 1> /dev/null 2> /dev/null &
    rm -f /usr/share/icons/icon-theme.cache
  fi
fi
# Update mime database:
if [ -x /usr/bin/update-mime-database -a -d /usr/share/mime ]; then
  echo "Updating MIME database: /usr/bin/update-mime-database /usr/share/mime &"
  /usr/bin/update-mime-database /usr/share/mime 1> /dev/null 2> /dev/null &
fi

# Update all the shared library links:
if [ -x /sbin/ldconfig ]; then
  echo "Updating shared library links: /sbin/ldconfig &"
  /sbin/ldconfig &
fi

# Update the X font indexes:
if [ -x /usr/bin/fc-cache ]; then
  echo "Updating X font indexes: /usr/bin/fc-cache -f &"
  /usr/bin/fc-cache -f &
fi

Darle permisos de ejecución al script anterior y listo:

# chmod +x /etc/cron.daily/config.sh

DHCP

Para solocitar una dirección IP el DHCP en Slackware toma 10 segundos al inicio, sin embargo se puede ejecutar esto en paralelo con otros servicios. Para hacerlo hay que abrir el archivo /etc/rc.d/rc.inet1 y agregar un “&” al final de las siguientes lineas:

# 10 seconds should be a reasonable default DHCP timeout. 30 was too much.
echo "/etc/rc.d/rc.inet1: /sbin/dhcpcd -t ${DHCP_TIMEOUT[$i]:-10} ${DHCP_OPTIONS} ${1}" | $LOGG$
/sbin/dhcpcd -t ${DHCP_TIMEOUT[$i]:-10} ${DHCP_OPTIONS} ${1} &

OK hasta aquí, con esto yo tengo un sistema que arranca en menos de 30 segundos. Recuerden que esto solo afecta el “verdadero” inicio del sistema, el inicio de KDE o de cualquier entorno gráfico en general sigue tardando lo mismo. Si alguien sabe como acelerar el inicio de los entornos de escritorio pues compartanos sus conocimientos.

Saludos

Fuentes:

the linux space
Human Readable
Brent W. Woodruff

Quitar tiempo de espera de LILO

Hace tiempo que decicí utilizar únicamente Slackware en mi laptop puesto que no necesitaba más, uso software libre y propietario, la mayor parte del sofware propietario la uso en el trabajo con otra laptop con Windows, ArcGIS, AutoCAD y MSOffice principalmente y desde hace tiempo he tratado de hacer el mismo trabajo que hago con ese software pero en mi plataforma de Linux y software de fuente abierta.

Así que para forzarme a ello uso únicamente Linux en la casa, solo que cuando instalé mi slackware por defecto al iniciar me aparece una pantalla con el logo de la distribución y un conteo regresivo de dos minutos para que el usuario elija el sistema operativo de su preferencia para cargarlo en la máquina pero… yo solo tengo linux instalado!! por qué me sigue dando la opción de elegir?! Esa era mi pregunta, hasta que me decidí a meterle mano al LILO, ya que en linux todo se puede configurar hay que meterle mano (aunque por esas metidas de mano he reinstalado mi sistema varias veces jejeje).

Así que me metí a leer el archivo /etc/lilo.conf:

$ kdesu kwrite /etc/lilo.conf

… y encontré lo siguiente:

# Wait until the timeout to boot (if commented out, boot the
# first entry immediately):
prompt
# Timeout before the first entry boots.
# This is given in tenths of a second, so 600 for every minute:
timeout = 1200

Aqui la parte importante que dice “si se comenta, booteará a la primera entrada inmediatamente”, es decir si se comenta prompt entonces no habrá tiempo que esperar así que edité mi archivo de la manera siguiente:

# Wait until the timeout to boot (if commented out, boot the
# first entry immediately):
#prompt
# Timeout before the first entry boots.
# This is given in tenths of a second, so 600 for every minute:
#timeout = 1200

Y  guardar los cambios. Para aplicar los cambios hay que volver a ejecutar el lilo:

# lilo

Ahora nada de esperas al iniciar el sistema…