Si has intentado instalar VMware 7 sobre una máquina Linux corriendo el kernel 2.6.32 tal vez hayas tenido problemas. También, como en mi caso, tener VMware instalado con el kernel 2.6.31 y actualizar a 2.6.32 resulta en problemas al recompilar los módulos (específicamente el vmnet y el vmci).

Los errores que arroja VMware al momento de tratar de recompilar los módulos son similares a esto:

Errores con el vmnet que se muestran en consola:

Errores con el vmci (Virtual Machine Communication Interface) que se muestran en consola:

La solución la comentan en Chmouel Blog y me la a sugerido Cortex, aunque hablan solamente de errores en el vmnet y no en el vmci. De cualquier forma, la solución prácticamente la misma:

• cd /tmp
• tar xf /usr/lib/vmware/modules/source/vmnet.tar
• Entramos al directorio (cd vmnet-only)
• Abrimos el archivo vnetUserListener.c con un editor de texto
• Añadimos esto al final de todos los includes:
  

  add this line #include "compat_sched.h"

• Salimos del directorio (cd /tmp)
• Reemplazamos el arvhivo vmnet de vmware con el que hemos editado:
  sudo tar cf /usr/lib/vmware/modules/source/vmnet.tar vmnet-only

Lo anterior es para evitar el problema con vmnet… con esto puedes intentar correr de nuevo VMWare. Si lo que ahora falla es el vmci puedes hacer lo mismo pero con el archivo /usr/lib/vmware/modules/source/vmci.tar.
Luego de esto, intentamos iniciar VMware o VMplayer los cuales recompilarán los módulos esta vez sin problemas:

SEO thing XD…

Pongo los errores como salen en inglés por si alguien los busca así

Contribuyendo a la excelente labor de mi amigo Cortex, vamos con este pequeño artículo.

Una de las tareas más dispendiosas a la hora de configurar el kernel es determinar qué opción/driver activar para determinado dispositivo. La idea de este artículo es dar a conocer una excelente herramienta online que nos permitirá conocer mejor nuestro sistema, y de paso saber los nombres de los drivers que podemos usar por cada dispositivo.

La página en cuestión es http://kmuto.jp/debian/hcl/ y contiene una base de datos de IDs de dispositivos PCI, que nos permite consultar información acerca de nuestros dispositivos y los drivers que los controlan.

Uso

Para usarlo debemos ejecutar el siguiente comando:

y copiamos la salida en el area de texto que aparece al entrar a http://kmuto.jp/debian/hcl/; hacemos clic en el botón Comprobar y obtendremos un listado de dispositivos vs. nombre del driver.

Por ejemplo, mi laptop tiene una ranura para insertar memorias SD; el nombre de dicho dispositivo es R5C822 SD/SDIO/MMC/MS/MSPro Host Adapter y el driver es sdhci-pci.

Con dicha información, podemos hacer una búsqueda (presionando la tecla /) en la configuración del kernel (cuando hacemos un make menuconfig):

El resultado es la ubicación exacta de la opción que debes habilitar para tener tu dispositivo funcionando:

Eso es todo. Ahora podemos estar seguros de escoger el driver adecuado y podemos compilar nuestro kernel normalmente.

Anterior artículo…

Continuando con la serie de posts dedicados al Kernel, hoy vamos a hablar sobre las cámaras web y la herramienta sysctl.

Cámaras Web

En la actualidad, el kernel tiene muy buen soporte para las cámaras web, tanto las integradas como las externas. Basado en mi experiencia, nunca he tenido ningún problema con dispositivos de captura de video en Linux aunque me imaginó que en algún hardware habrá incompatibilidades. La ventaja es que los desarrolladores del kernel cada día trabajan por mejorarlo y desarrollando controladores para maximizar el soporte en la mayor cantidad de máquinas posibles.

Lo primero que debemos hacer es identificar la referencia del dispositivo. Si tienes un portatil y lo que buscas es hacer funcionar la cámara integrada que trae, usando el driver UVC sería suficiente:

Device Drivers  --->
     <*> Multimedia support  --->
          [*]   Video capture adapters  --->
               [*]   Autoselect pertinent encoders/decoders and other helper chips
               [*]   V4L USB devices  --->
                    <*>   USB Video Class (UVC)
                          [*]     UVC input events device support

Ahora, en caso de que la cámara sea externa debes conectarla y hacer un lsusb. Hay tantos modelos disponibles que sería difícil hacer una guía definitiva, además de que ya existe un completo HOWTO que explica esto. Lo que haré, será mostrar un ejemplo haciendo uso de una vieja cámara Genius que tengo. Si la conecto y hago un dmesg puedo ver la información del dispositivo:

Ahora lsusb:

Teniendo el ID, debemos buscar cuál es el módulo necesario para esta cámara. Aquí tienes una larga lista de IDs con su respectivo módulo. Si buscamos también en la base de datos de drivers del kernel veremos la configuración que debemos hacer y el módulo a activar. El driver en cuestión es: gspca_pac207.

<*>   GSPCA based webcams  --->
     <M>   Pixart PAC207 USB Camera Driver

Si compilaste como módulo no olvides agregarlo al inicio del sistema (si es lo que deseas). En Gentoo con OpenRC y Baselayout 2:

Para esta cámara es necesario tener instalada la librería v4l (Video 4 Linux).

Y listo. Reiniciamos con el nuevo kernel y usamos cualquier programa como cheese para comprobar que todo funciona bien.

Sysctl

A raíz de un comentario de arpunk, he decidido posponer uno de los temas que iba a tocar en este artículo y hablar sobre sysctl.

El kernel Linux es tan flexible que te permite modificar la manera en que trabaja, dinámicamente, a través del comando sysctl. Sysctl provee de una interfaz que permite examinar y cambiar cientos de parámetros en núcleos Linux y BSD. Gracias a esta herramienta podemos modificar y optimizar el kernel sin tener que recompilarlo. Los cambios son realizados inmediatamente e incluso pueden ser definidos como persistentes, de manera que continúen después de reiniciar.

Para ver los parámetros actuales del kernel en ejecución:

Con el segundo lo que hacemos es ver el valor de un determinado parámetro, en este caso vm.swappiness. Suponiendo que quisiéramos decirle al kernel que use más la memoria RAM que la swap ó habilitar el forwarding en IPv4, bastaría con cambiar el valor de estas variables:

Recuerda que las modificaciones que hagas con este comando serán temporales, y la próxima vez que reinicies el sistema se cargarán los valores por defecto. Para cambiar este comportamiento, hay que editar el archivo /etc/sysctl.conf

Básicamente eso es sysctl. El tema podría tornarse más extenso pero la idea de estos artículos, es tan sólo, recopilar conceptos en torno al kernel Linux. Para más información man sysctl.

Hasta aquí por hoy. En el próximo artículo hablaremos un poco de optimizaciones para el procesador y de otras buenas prácticas a la hora de compilar el núcleo.

Hola a todos! Otra vez yo, Cortex, que hace un buen rato no me pasaba por aquí.

Hoy me gustaría hablar sobre un tema en el que seguro todos tenemos muchas lagunas, configurar el kernel. Si alguna vez has instalado ó intentando instalar Gentoo te habrás dado cuenta que en el ritual de instalación debes de compilar tu propio núcleo, incluyendo también la configuración del mismo. Desde mi experiencia, este suele ser un punto en el que la mayoría de usuarios se quedan; es cierto que también existe genkernel, una herramienta que facilita por completo este proceso pero que también, entre otras cosas, ralentiza mucho el arranque.

Casi la totalidad de distribuciones Linux, incluyen en su sistema un kernel con soporte para la mayor cantidad de hardware posible y en el booteo hay un script que se encarga de identificar el perfil del equipo en cuestión y cargar los módulos respectivos (sonido, disco, sistemas de archivos, etc.). Este sistema me parece excelente, puesto que sobretodo al usuario nuevo le ahorra mucho trabajo a la hora de poner a funcionar su distribución, pero como dije anteriormente no es lo más óptimo, sobretodo si queremos el mejor rendimiento posible.

No pretendo con esta entrada crear una guía completa de configuración del kernel. Primero, porque mis conocimientos en este tema son limitados, o sino que lo diga Javi, que siempre le toca aguantarse mis quejas porque no me funcionan bien las cosas Y segundo, porque todos tenemos necesidades diferentes y puede que algunos necesiten soporte para determinadas cosas que otros no. Lo que sí me gustaría es hablar sobre buenas prácticas a la hora de trabajar con el núcleo y sobre problemas muy comunes que surgen cuando hacemos una configuración desde 0, como dispositivos que no funcionan, entre otras cosas. El post está abierto a cualquier aporte/mejora/correción que quieran hacer.

Brillo en pantallas LCD

Son varias las personas que alguna vez me han preguntado como pueden hacer funcionar las teclas para definir la intensidad del brillo de la pantalla. Si usas portatil, habrás notado que es una funcionalidad demasiado útil y que además es muy maluco tener que trabajar únicamente con el brillo que el laptop haya decidido definir al ser encendido.

• Lo primer es activar el controlador:

Device Drivers  --->
     Graphics Support --->
          [*] Lowlevel video output switch controls
          [*] Backlight & LCD device support  --->
               <*>   Lowlevel LCD controls
               <*>     Platform LCD controls
               -*-   Lowlevel Backlight controls
               <*>     Generic (aka Sharp Corgi) Backlight Drive
      Display device support  --->
           <*> Display panel/monitor support

• Ahora nos dirigimos a las opciones de ACPI y activamos el manejo de video:

Power management and ACPI options  --->
     [*] ACPI (Advanced Configuration and Power Interface) Support  --->
          <*>   Video

Y con esto bastaría recompilar para disfrutar del brillo

/proc/config.gz

Una opción que quizás muchos no conocen es la de poder acceder a la configuración del kernel en ejecución a través del archivo /proc/config.gz. Actívemosla y curémosnos en salud ante la pérdida del preciado .config.

General setup  --->
     <*> Kernel .config support
     [*]   Enable access to .config through /proc/config.gz

Para disponer del archivo de configuración:

Sonido como módulo

Entre los problemas más comunes en Linux está el sonido. Sobretodo si trabajamos con versiones de ALSA muy viejas ya que nos toca recurir a hacks ó pasar parámetros a la hora de cargar los módulos. Por si no está claro para alguien, ALSA (Advanced Linux Sound Architecture) a grosso modo, es el encargado de la gestión del sonido en Linux, reemplazando al obsoleto OSS. No es la única opción, pero sí la mejor en la mayoría de los casos.

Existen 3 formas de instalar ALSA:

• Desde los drivers del kernel (estáticamente)
• Desde los drivers del kernel (módulo)
• Drivers externos (alsa-drivers)

La más recomendada es la segunda. Las ventaja de compilar el sonido como módulo es que no tenemos que preocuparnos de identificar cual es el controlador apropiado para nuestra tarjeta, sino, simplemente dejar hacer su trabajo a alsaconf y usar alsamixer para definir el volumen. Aparte de que también se obtiene un mejor rendimiento.

Si quieres profundizar un poco en el tema puedes leer este artículo.

No pondré aquí las opciones que se necesitan activar en el núcleo, puesto que en la documentación de Gentoo está todo perfectamente explicado. Más bien hablemos sobre los micrófonos integrados, esos que a veces resulta tan difícil hacer funcionar.

Abrimos en una shell alsamixer y presionando la tecla Tabulador nos movemos a los dispositivos de Captura. Debemos cambiar en Input Source, Mic por Front Mic y también verificar que los dispositivos Capture y Digital no están mudos y además que tengan el volumen al 100%.

Guardamos la configuración

Ahora abrimos cualquier aplicación para captura de audio y probamos con los dispositivos disponibles a ver cual funciona. Eso es todo.

No quiero alargar más el post, de momento es suficiente. Más adelante veremos como podemos hacer funcionar las cámaras web en Linux y algunas otras cosas.

Cualquier comentario será bien recibido, ¡Hasta pronto!

Esta entrada pretende profundizar los temas aprendidos en el anterior artículo (Tu primer módulo cargable para el Linux kernel), con el fin de clarificar dudas, atar algunos cabos que dejamos sueltos y prepararnos para los siguientes artículos.

¿Puedo usar directamente el árbol del código fuente del kernel?

Sí, por supuesto. Como ya sabes, no es posible compilar un módulo cargable sin al menos parte del código fuente del kernel – esto es, la parte que contiene la infraestructura de construcción general y los archivos de cabecera esenciales. Solo por recordar, un archivo header (con extensión .h), contiene, normalmente, una declaración directa de clases, subrutinas, variables, u otros identificadores; sin la definición de estas, no es posible compilar código que las use.

En cualquier caso, es siempre útil tener una copia completa del código del kernel, y la manera más fácil de obtenerla es usando git:

Además que puedes actualizarlo fácilmente:

Nótese que, al contrario de instalar el paquete oficial de desarrollo del kernel como hicimos en el anterior artículo, usando git no es necesario tener privilegios administrativos para poner todo el código en algún lugar de tu directorio home. Además, si por alguna razón no puedes usarlo, puedes descargarte un archivo tar y funcionará igual; claro, usar git es mucho más cool

Urgando en el código fuente: examinando los archivos de cabecera (Header Files)

Recordemos que en el ejemplo del artículo anterior, nuestro código contiene referencias a archivos de cabecera del kernel:

#include <linux/module.h>      // para todos los módulos
#include <linux/init.h>        // para entrada y salida de macros
#include <linux/kernel.h>      // para los macros de prioridad de printk
#include <asm/current.h>       // procesar información, solo por diversión
#include <linux/sched.h>       // para usa la estructura task_struct

Tales referencias son siempre relativas al nivel superior del directorio include/ en el código fuente del kernel, así que un include de, por ejemplo, <linux/module.h>, se refiere al archivo de cabecera include/linux/module.h, y así sucecivamente.

Sin embargo, si miras un poco más de cerca, notarás que no hay un directorio include/asm/, lo cual es bastante fácil solucionar. Incluso si no planeas construir algo contra el código fuente que descargaste, deberías prepararlo de tal manera que refleje de una manera más precisa lo que piensas hacer con él:

Los comandos anteriores hacen bastantes cosas, aunque lo único que nos interesa en este momento es que crea algunos enlaces simbólicos en el directorio include/, que reflejan la arquitectura de nuestro sistema.

Antes de ejecutar los comandos:

Después de ejecutarlos:

Una vez que esto es hecho, los includes de preprocesador tendrán sentido, y podemos usar los nombres genéricos para referirnos al archivo de cabecera apropiado de ahora en adelante. Por supuesto, esto que hicimos no es necesario hacerlo con los paquetes oficiales de desarrollo del kernel, puesto que ya vienen preparados.

¿Es posible generar mensajes de salida con un módulo?

No, no lo es. Bueno, no realmente. Como un autor de módulos novato, es necesario que entiendas que tu módulo será ejecutado en el kernel space, no en el user space, así que debes dejar de pensar en impresiones de mensajes en la consola. Olvídate de ello. La manera canónica de generar mensajes de depuración desde tu módulo es con llamadas printk:

printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
printk(KERN_INFO "El user space del proceso es '%s'\n", current->comm);
printk(KERN_INFO "El PID es  %i\n", current->pid);  

Corriendo el riesgo de sobre-simplificar el asunto, la salida que genera printk acabará en el archivo /var/log/messages así que, si estás insertando y removiendo tu módulo, es útil tener una terminal aparte mostrando en tiempo real todo lo que sea escrito en dicho archivo (para lo cual necesitas privilegios administrativos):

Para los más ambiciosos, es útil fijarse en la definición de los niveles de log en el archivo de cabecera <linux/kernel.h>:

#define KERN_EMERG    "<0>"  /* system is unusable                 */
#define KERN_ALERT    "<1>"  /* action must be taken immediately   */
#define KERN_CRIT     "<2>"  /* critical conditions                */
#define KERN_ERR      "<3>"  /* error conditions                   */
#define KERN_WARNING  "<4>"  /* warning conditions                 */
#define KERN_NOTICE   "<5>"  /* normal but significant condition   */
#define KERN_INFO     "<6>"  /* informational                      */
#define KERN_DEBUG    "<7>"  /* debug-level messages               */

Si algunos de ellos lucen vagamente familiares, no es de sorprenderse – son los niveles de depuración (debugging) soportados por syslog, así que eres libre de personalizar el syslog si quieres redireccionar la salida de tu módulo a donde quieras basado en los niveles de log, lo cual está más allá del objetivo de este artículo.

printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
printk("<6>" "Hola, el modulo esta siendo cargado.\n");
printk("<6>Hola, el modulo esta siendo cargado.\n");

Aun así, es mejor hacerlo como se muestra en la primera línea. Incluso programando cosas del kernel, la estética importa.

Cargando tu módulo lleno de información

Como te diste cuenta la última vez, puedes cargar tu módulo con información bastante útil como:

MODULE_AUTHOR("Robert P. J. Day");
MODULE_AUTHOR("Cristian Castiblanco [solo lo puse en castellano]");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Aqui puedes poner una descripcion de tu modulo");

que puede examinarse con el comando modinfo:

$ sudo modinfo hola.ko
filename: hola.ko
description: Aqui puedes poner una descripcion de tu modulo
license: Dual BSD/GPL
author: Cristian Castiblanco [solo lo puse en castellano ]
author: Robert P. J. Day
depends:
vermagic: 2.6.29-gentoo-r5 SMP mod_unload CORE2

Algunas cosas útiles acerca de esta característica:

• El conjunto completo de estos macros está definido en el archivo de cabecera <linux/module.h>, en donde verás macros relacionados con firmware, tablas de dispositivos y más.
• Además de esos macros en específico, está el menos conocido macro genérico MODULE_INFO, el cual puedes usar dentro del módulo en el lugar que quieras. Curiosamente, muy pocos programadores toman ventaja de este.
• La única macro que realmente debes poner es la licencia. Si no especificas alguna de las variaciones de la licencia GPL, entonces el módulo “contaminará” el kernel, un tema que trataremos en otro artículo. El conjunto completo de licencias válidas está definido en el mismo archivo de cabecera.

Compilando contra el código fuente del kernel

Finalmente, podrías querer construir tu módulo, no contra el código instalado por el paquete de desarrollo, sino contra el código que descargaste tú mismo. Si ese es tu plan, es bastante simple.

Primero, como decíamos arriba, necesitas preparar tu código fuente para construir el módulo:

Todo lo que falta es configurar el Makefile de tal manera que compile el módulo contra nuestro código fuente. Recordemos parte del archivo Makefile del artículo anterior:

ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

Lo que hace la segunda línea es asignar la ubicación del código fuente del kernel a ser usado. Para cambiar esta variable, podemos asignarle el valor deseado con este comando:

y aquí es donde comienzas a notar algunas diferencias. Asumiendo que la versión del código que descargué es 2.6.31-rc1, esto es lo que sucede en mi sistema:

Puesto que estoy compilando contra un código fuente que no concuerda con el que estoy corriendo actualmente, pierdo la tabla de símbolos actual, pero la compilación funciona.

El comando modinfo también muestra el árbol contra el cual el módulo fue compilado:

$ sudo modinfo hola.ko
filename: hola.ko
description: Aqui puedes poner una descripcion de tu modulo
license: Dual BSD/GPL
author: Cristian Castiblanco [solo lo puse en castellano ]
author: Robert P. J. Day
depends:
vermagic: 2.6.31-rc1 SMP mod_unload 686

Ahora algunas preguntas capciosas – ¿es posible cargarlo? ¿no dará problemas por la versión? Eso depende de si el kernel que se está ejecutando fue configurado para permitir diferencias de versiones, y hay una manera rápida de comprobarlo. En mi Gentoo por ejemplo:

Mala suerte. Tal parece que el kernel no fue compilado con las opciones necesarias. Si miramos en el archivo /var/log/messages:

Por lo pronto entonces, de ahora en adelante, jugaremos un poco dentro de la seguridad que nos ofrece compilar contra el kernel que concuerda con la versión que corremos. No hay motivo para hacerlo más difícil de lo que debe ser. En el próximo artículo veremos algo acerca de las rutinas entry y exit.

Este how-to está basado en el artículo The Kernel Newbie Corner: Your First Loadable Kernel Module escrito por Rob Day en Linux.com. En él se enseñan las bases de la programación de módulos para el kernel de Linux. Este primer artículo pretende ilustrar de manera clara los conceptos básicos y espero que, a medida que Rob vaya escribiendo más artículos, pueda ir traduciéndolos para ofrecer este excelente contenido en español. Además, funciona para cualquier distro, aunque en este caso lo hice todo sobre Gentoo. Sin más, ¡vamos al grano!

¿Es necesario tener privilegios de root?

Mientras desarrollamos el módulo, no. Pero al momento de cargar el módulo necesitaremos privilegios administrativos. Por supuesto, es recomendable que el desarrollo lo hagamos con un usuario normal, y solo al final usemos un usuario root para cargar o remover los módulos.

Prerrequisitos

Antes de comenzar es necesario saber/tener algunas cosas:

• La versión del kernel con la que vamos a trabajar (usualmente la que estamos corriendo). Esto lo hacemos con el comando uname -r:
  $ uname -r
  2.6.29-gentoo-r5
• El uso de herramientas de desarrollo, como gcc, binutils, etc.
• Tener instalados las utilidades para trabajar con módulos (insmod, rmmod, etc.), el cual se encuentra en el paquete module-init-tools.
• El código del kernel de Linux, de tal manera que puedas compilar tu módulo contra este.

¿Para qué el código del kernel?

Esto es realmente importante, así que echaremos un vistazo un poco más profundo. Cuando compilamos un módulo para Linux es necesario tener el código fuente de algunas partes del kernel, puesto que muchas instrucciones de preprocesador usadas no se encuentran en los headers estándar de desarrollo. En vez de ello, se encuentran en los headers de kernel.

Podrías simplemente descargar el código del kernel directamente de la página oficial, aunque lo más sencillo es instalar el paquete que corresponda a la versión del kernel que estemos ejecutando. Por lo general, este tipo de paquetes instala el código en /usr/src o /usr/src/kernels. Por ejemplo, en Fedora el paquete que debes instalar se llama kernel-dev, mientras que en Gentoo es gentoo-sources.

Una vez tengas el código instalado, es necesario saber exactamente en donde se encuentra, de tal manera que podamos referenciarlo al momento de compilar el módulo. Podrías revisar eso manualmente o, mejor aún, buscar el enlace simbólico hacia el kernel, que por lo general se encuentra en /lib/modules:

El enlace simbólico que buscamos es build, y como puedes ver en el ejemplo, apunta a la raíz del código del kernel. Esto significa que, cada vez que quieras hacer referencia al kernel en el momento de compilar el módulo, basta con usar dicho enlace.

“Hola, kernel!”

Bien, es hora de crear nuestro primer módulo. Sin más rodeos, el código sería el siguiente:

/* El nombre del archivo es 'hola.c'. */
#include <linux/module.h>      // para todos los modulos
#include <linux/init.h>        // para las macros entry/exit
#include <linux/kernel.h>      // para usar la macro printk
#include <asm/current.h>       // informacion del proceso (solo por diversion)
#include <linux/sched.h>       // para usar la estructura "task_struct"
static int hola(void)
{
     printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
     printk(KERN_INFO "El user space del proceso es '%s'\n", current->comm);
     printk(KERN_INFO "El PID es  %i\n", current->pid);
     return 0;       // para indicar que todo ha salido bien
}
static void adios(void)
{
     printk(KERN_INFO "Chao, el modulo esta siendo removido.\n");
}
module_init(hola);     // lo que se debe llamar al cargar un modulo
module_exit(adios);    // lo que se debe llamar al remover un modulo

MODULE_AUTHOR("Robert P. J. Day");
MODULE_AUTHOR("Cristian Castiblanco [solo lo puse en castellano]");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Aqui puedes poner una descripcion de tu modulo");

Algunas observaciones acerca del código de arriba:

• Técnicamente, no es necesario imprimir cosas cada vez que se carga o remueve un módulo (con printk). Pero puesto que es nuestro primer módulo, y aún no hace nada especial, es más divertido si lo dejamos así.
• Es necesario hacer que la función de inicio retorne 0, si queremos indicar que la carga fue satisfactoria.
• No, no es necesario poner una coma después de indicar el nivel de logs (KERN_INFO). Es un error común hacerlo.

Eso es todo… ¡vamos a compilarlo!

El archivo Makefile

Este es el archivo Makefile que necesitaremos:

ifeq ($(KERNELRELEASE),)  

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)  

.PHONY: build clean

build:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules  

clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c
else  

$(info Building with KERNELRELEASE = ${KERNELRELEASE})
obj-m :=    hola.o

endif

Como has de saber, los archivos Makefile indican las reglas necesarias para compilar código. En este caso, explicándolo a groso modo, lo que hace el Makefile es detectar que aún nos encontramos en el directorio de desarrollo de nuestro módulo, y por lo tanto se dirige al directorio del kernel, compila el módulo desde ahí y se devuelve. Para probarlo basta con ejecutar el comando make:

Examinar el módulo

Una vez compiles el módulo obtendrás un archivo con extensión .ko. Si quieres echarle un ojo a dicho archivo, puedes usar el comando modinfo así:

$ sudo modinfo hola.ko
filename:       hola.ko
description:    Aqui puedes poner una descripcion de tu modulo
license:        Dual BSD/GPL
author:         Cristian Castiblanco [solo lo puse en castellano ]
author:         Robert P. J. Day
depends:
vermagic:       2.6.29-gentoo-r5 SMP mod_unload CORE2

En Gentoo es necesario ejecutarlo con privilegios; en otras distros puedes ejecutarlo normalmente.

Cargar o remover el módulo

Llego la hora de cargar nuestro módulo. Para ello, como comenté anteriormente, es necesario poseer privilegios administrativos. Al grano:

¿Y donde está lo que imprimimos con printk? Bien, no es común imprimir en consola cosas mientras un módulo es cargado o removido; en este caso, la salida va a dar al archivo de logs principal de Linux (/var/log/messages); puedes ver la salida con el comando dmesg o directamente en dicho archivo:

Conclusión

Estas son apenas las bases que deberíamos tener para comenzar con la construcción de un módulo para el kernel de Linux. Es de valiosa ayuda jugar un poco con este ejemplo, de tal manera que podamos estar seguros que todo irá bien cuando hagamos algo un poco más complejo.

Descargar código fuente del ejemplo

Este es un pequeño how-to en donde explico cómo activar el soporte para el sistema de archivos ext4 en Gentoo.  El tutorial está enfocado hacia distribuciones que, como Gentoo, no tengan activado dicho soporte y en donde es necesario recompilar el kernel para hacerlo funcionar.

Espero que sirva de paso para mostrar un poco el proceso de recompilación del kernel, que a primera vista puede sonar difícil, pero que en realidad es algo muy sencillo y saludable

0. Prerequisitos

Es necesario tener el paquete e2fsprogs y las fuentes del kernel de linux. Para ello, basta con ejecutar este comando:

1. Configurando nuestro kernel

Lo que haremos a continuación será configurar el kernel para activar el soporte al sistema de archivos ext4. Para ello, abrimos una consola y entramos en el directorio donde se encuentren las fuentes, por ejemplo /usr/src/linux-2.6.30-gentoo-r5. Estando allí, iniciamos el configurador gráfico del kernel con este comando:

Una vez hayamos hecho esto, debemos navegar y dar enter en la opción File systems, y seleccionar (con la tecla espacio) The Extended 4 (ext4) filesystem. Debería quedar así:

File systems  --->
     <*> The Extended 4 (ext4) filesystem
     [ ]   Enable ext4dev compatibility
     [ ]   Ext4 extended attributes
     [ ]     Ext4 POSIX Access Control Lists
     [ ]     Ext4 Security Labels

Además, por defecto las particiones que se crean con ext4 tienen activada la opción huge_file, lo cual permite que se manejen ficheros de un gran tamaño. Por ello, es necesario activar la opción Support for Large single files del kernel. Dicha opción se encuentra en Enable the block layer y debería lucir así:

Enable the block layer --->
     --- Enable the block layer
     [*]   Support for Large single files

Una vez hayamos configurado el kernel, salimos de la configuración presionando el botón exit, compilamos e instalamos:

2. Crear y montar particiones con el sistema de archivos ext4

Para ello basta con usar el comando mkfs.ext4, por ejemplo:

Para montar la partición:

3. Convirtiendo ext3 a ext4

Ten en cuenta que puedes montar una partición ext3 con la opción -t ext4 y todo funcionará bien, aunque no tendrás disponibles las características de ext4. Si deseas, puedes convertir una partición que se encuentra en ext3 a ext4. Para ello puedes ejecutar el siguiente comando:

Es recomendable hacer un chequeo de la partición para verificar que todo haya salido bien:

Más información:

http://fr.gentoo-wiki.com/wiki/Ext4

Nota: de nuevo un tutorial raro, que tal vez a pocos le importa. Lo siento.

Esta receta la aprendí configurando mi Gentoo pero bien podría aplicarse a cualquier otra distribución. La idea es activar el soporte para Framebuffer, el cual permite al kernel mostrar gráficos en consolas de texto. Además sirve para otras cosas, como ejecutar servidores X sin aceleración o reproducir videos en la consola (en ASCII, por supuesto).

El tutorial tiene además un valor didáctico que me gusta, ya que vamos a tocar cosas en el Kernel, algo bastante interesante.

Ventajas

Las ventajas de hacer esto, y por lo que yo lo hice, son:

• Te proporciona una muy bonita consola (de hasta 128 colores + más de 48 líneas con 1280×800, al menos en mi laptop) cuando estás trabajando sobre las TTY (sin entornos gráficos).
• Te pone el logo de Linux mientras carga el sistema, una maravilla. Los que usen usplash se reirán de mi, pero bueno, prefiero el pingüino y saber que está pasando cuando mi sistema inicia.

Compilando el kernel con las opciones adecuadas

En este punto, he de suponer que tienes algo de experiencia con el kernel. Sino, estás de suerte porque me gusta explicar todo muy bien. Lo primero es abrir una consola y situarnos en el directorio donde tengamos las fuentes de Linux, y posteriormente ejecutamos la herramienta de configuración del Kernel:

Una vez hecho esto, debemos activar algunas opciones (dentro de Device Drivers):

(*) Graphics Support
    (*) Enable firmware EDID
    (*) Support for Frame buffer devices
        (*) VESA VGA graphics support
    (*) Console display support
        (*) Video mode selection support
        (*) Frame buffer console support
    (*) Logo Configuration
        (*) Bootup logo

Ten en cuenta que deben estar compilados dentro del kernel (*) y no como módulos (M). Una vez que hayamos configurado correctamente nuestro kernel, lo compilamos y copiamos al directorio /boot, por ejemplo:

Identificar qué resoluciones podemos usar con Framebuffer

Para identificar qué resolución es la más adecuada para nuestro equipo, lo más sencillo es instalar la herramienta hwinfo (si no la tienes ya instalada):

En Ubuntu/Debian:

En Gentoo:

En Arch:

En Fedora:

Una vez instalado, ejecutas el comando:

Lo que tienes que hacer es identificar el valor del Mode; en mi caso es 0×0361…

Configurando el GRUB

Una vez identificado el valor del Mode, no queda más que pasarle a nuestro kernel las opciones adecuadas. Abrimos con nuestro editor de texto favorito el archivo /boot/grub/menu.lst, y añadimos el parámetro vga=modo al final de la línea del kernel. Por ejemplo, en mi caso luce así:

title Gentoo
root (hd0,9)
kernel /boot/kernel root=/dev/sda10 vga=0x0361

¡Reiniciamos, y listo!

• Linux tiene 9,2 Millones de líneas de código, se incrementa 10% cada año.
• El Kernel en sí mismo es el 5%, y los drivers son aproximadamente el 55%.
• 4500 líneas son agregadas, 1800 removidas y 1500 modificadastodos los días.
• Es un sistema jerárquico pero no depende de las personas individuales.
• Una nueva versión cada 2 o 3 meses.
• 2399 desarrolladores, la mitad de ellos contribuye con sólo 1 o 2 parches.
• Ya no hay un Kernel estable (con mumeración par, como el 2.4) y otro inestable (con numeración impar, como el 2.3); este proceso ha sido discontinuado.
• Las actualizaciones de seguridad de una versión vienen numeradas como x.x.x. Por ejemplo, las correcciones para el 2.6.19 se numeran como 2.6.19.1, 2.6.19.2, etc.
• El Kernel es activamente desarrollado las 24 horas del día, los 7 días de la semana, los 365 días del año.

Visto en Linux Hispano | Fuente Píllate un Linux

Se trata de un documental en donde explica los inicios del proyecto Linux (el kernel [aqui explican que es el kernel linux]). Sin duda un gran material para cualquier tipo de usuario de Gnu/Linux: