FLISOL Habana, Cuba …

26 04 2010

El día 24 de Abril del 2010 se celebró una edición más del Festival Latinoamericano de Instalación de SOftware Libre. El evento se llevó a cabo en todo el país con distintas sedes en las provincias. En Ciudad de la Habana tuvo 2 sedes. La principal, el Palacio Central de Computación sita en Habana Vieja.

Palacio de ComputaciónPalacio Central de ComputaciónFLISOL 2010

La sede abrió sus puertas a las 9:30am para dar entrada a los invitados y comenzar un cargado programa de actividades con dos locales en paralelo sesionando ininterrumpidamente hasta las 5:00pm.   Se hicieron 24 presentaciones en los locales de sesión y en el salón general se expusieron diversas distribuciones de software libre usadas en Cuba y en el Mundo.  Entre los invitados al evento estuvieron la comunidad de usuarios de Linux Cuba que distribuyeron diferentes sistemas operativos por toda la sala además de ser uno de los organizadores del evento.  La comunidad PostgreSQL Cuba tuvo su espacio para exponer el avance obtenido hasta el momento con el uso de ese gestor de BD.   Los niños encontraron lugar en las máquinas del Palacio pudiendo probar juegos educativos y de entretenimiento en los sistemas operativos libres que les permitió degustar de una tarde de diversión.

Salón presentacionesSalón comúnSalón común

La Universidad de Ciencias Informáticas hizo exposición tanto en los locales de trabajo como en el salón de los proyectos que lleva a Cabo destacándose la presentación de NOVA, el sistema operativo cubano.  Su equipo de desarrolló informó a los participantes de la estrategia de trabajo que los llevará a la difusión e implantación del sistema operativo en los próximos meses a un ritmo acelerado.   Entre los nuevos planes: inclusión de la comunidad de usuarios de Cuba y rediseño del sistema para facilitar más su proceso de desarrollo.

NOVA Sistema Operativo Cubano Equipo de desarrollo de NOVA

Muchos usuarios asistieron además para copiar información que se ofrecía en un servicio de almacenamiento por la red aportado por un usuario y organizador del evento.  Aquí se ofrecían 500Gb de información catalogada en ISOS, Documentación, Software variado, repositorios de distribuciones, herramientas de rescate y diagnóstico entre otras.  Se intentó además hacer una muestra en tiempo real de los eventos a nivel nacional con el envío de imágenes desde otras provincias y desde esta sede con el fin de que pudieran ser enseñadas a los participantes.

Las distribuciones que rondaron el  lugar: Debian, Ubuntu, openSuse, Nova, freeBSD, incluso la muestra de MS-Windows controlado desde un servidor  ( OS-Plugger ) de clientes remotos traido por el equipo Nova.

DistrosDistrosJoven Club

Esperamos que el evento el año próximo cuente con la asistencia e interés de este y que para entonces podamos tener un país ya más migrado e inmerso en el uso de las tecnologías libres.

Felicitaciones al software libre por este día y a los organizadores y patrocinadores de este evento que hicieron de este sábado un día memorable.





Servidor de música ampache + openLDAP + extensiones …

14 03 2010

Este servicio se centra en proveer a sus usuarios de una manera para comunicarse a un servidor que brinde la posibilidad de escuchar archivos de audio ya sea música o voz desde las estaciones de trabajo.  El servicio permite hacer streaming utilizando interfaces conocidas que no sólo permiten escuchar música desde navegadores preestablecidos, sino que además permite extender esta funcionalidad.  Es reconocido además por su integración con los reproductores más usados por parte de la comunidad así como por su fácil configuración y mantenimiento.

# apt-get install ampache mysql

Una vez instalado debemos configurarlo. Debemos para ello acceder a http://localhost/ampache de la máquina donde se instaló. Entre sus pasos más notable se encuentran los datos del servidor mysql que utilizaremos. Debemos cerciorarnos que tenemos acceso de administración para mysql. Una vez que tengamos el sistema listo pasamos a configurarlo para poder utilizarlo desde un cliente. Existen alternativas en cuanto a la forma que utilizaremos este servicio. Se puede emplear directamente desde su interfaz web y mediante el stream desde un cliente. Para comenzar agregaremos a los usuarios que nos interesa que accedan al servicio. Nos podemos para esto auxiliar de la misma interfaz web en la sección User Tools de la interfaz web. Mostraremos aquí además cómo agregar a un grupo de usuarios definidos en un directorio de usuarios definido anteriormente, en este caso openldap. Editaremos el archivo config/ampache.cfg.php ubicado en la ruta del sitio en el sistema. Debemos tener las siguientes directivas fijadas:

auth_methods = "mysql,ldap"
;#########################################################
; LDAP login info (optional)                             #
;#########################################################

auto_create = "true"
ldap_filter = "uid"
ldap_objectclass = "organizationalPerson"
ldap_username = "xxxx"
ldap_password = "yyyy"
ldap_search_dn = "ou=A,dc=a,dc=b,dc=c"
ldap_url = "mmm.mmm.mmm.mmm"
ldap_name_field  = "cn"

Algunos campos deben ser sustituidos por los valores que emplearemos en nuestra configuración. Lo primero a notar es auth_methods que debe contener la directiva ldap. Los atributos ldap_filter, ldap_objectclass, ldap_search_dn, ldap_name_field y ldap_url dependen de cómo esté organizado el directorio que utilicemos. Los campos ldap_username y ldap_password los emplearemos sólo si para acceder al directorio se necesita de un usuario específico, en muchos casos no es necesaria esta configuración.

Una vez que tengamos esto pasaremos a la declaración de las subredes que podrán acceder al servidor. En nuestro entorno por razones de ancho de banda, es aconsejable restringir el servicio solamente a las máquinas de los laboratorios. Para ello debemos modificar las ACL’s del servicio.

A través de la interfaz web pasamos a la sección Admin/Access Control y seleccionamos la opción “Add ACL”. Debemos especificar los siguientes datos.

Name:  	 // Nombre de la regla
Start IP Address: 	(255.255.255.255)
End IP Address: 	(255.255.255.255)
User: 	 // Usuarios que accederán
Level: 	 // Permisos
ACL Type: 	// Tipo de acceso
Remote Key: 	// Clave de acceso

Los que más apremian son los rangos de ip para la subred donde nos encontremos por ejemplo: 10.7.21.0 – 10.7.21.255, los usuarios que pueden acceder, su nivel de acceso y la llave o clave de acceso.

Con esto configurado debemos asegurarnos por último que en el archivo de configuración del servidor esté habilitado un atributo determinado:

config/ampache.cfg.php

access_control = "true"

Si al habilitar este parámetros obtenemos algún error para acceder a la interfaz web se debe a que está mal configurado la regla de acceso para donde estamos accediendo.

El último paso sería ya configurar el catálogo musical que disponemos. Para hacerlo pasamos a Admin/Catalogs y creamos uno nuevo. Los parámetros esenciales son:

Catalog Name:
Path:
Catalog Type:

Cliente

Ya en el cliente podemos acceder de varias formas. Aquí expondremos solamente cómo conectarnos desde algún cliente de escritorio. El servidor exporta una interfaz llamada RPC-XML que permite la conexión de un reproductor independiente de la aplicación que almacena los archivos de audio. Este enlace nos permite desde nuestro reproductor preferido ( siempre que implemente esta funcionalidad ) escuchar música a distancia. Primeramente para conectarnos debemos asegurar que existan dos reglas ACL en el servidor para la subred donde nos encontramos, una para hacer stream y otra para rpc o que permita conexiones rpc. Sin ellas no podremos hacer la conexión.

Entre los reproductores que permiten integrarse con el servidor se encuentran el Amarok 2.0 y el Rhythmbox mediante una extensión.

Rhythmbox

Para instalar el plugin de Rhythmbox lo podemos descargar desde : rb-ampache-003.tar.gz

Este paquete se debe descompactar en $HOME/.gnome2/rhythmbox/plugins. Luego una vez que arranquemos el rhythmbox, en la sección de Edit/Plugins pasaremos a configurar el plugin del Ampache. Debemos especificar para ello la misma información de autenticación que especificamos en los ACL’s del servidor:

Server URL: http://10.7.25.200/music/server/xml.server.php
Username: xxxxx
Password (Key): yyyy
Con estos datos ya nos podremos conectar. Buscamos en el listado de extensiones a la izquierda del reproductor una sección llamada Ampache. Al pinchar sobre ella comenzará a descargar el listado.




Cómo crear una red Ad-Hoc inalámbrica …

19 02 2010

Las redes inalámbricas operan de modo similar a las redes cableadas.  Los modos en que pueden operar son diversos entre los que se destacan Master, Slave, Ad-Hoc y Observer.  El modo Master ó AP ( Access Point ) brinda la posibilidad de poder interconectar varios puntos clientes a través de un enrutador.  El modo Slave brinda la posibilidad a un cliente de asociarse a un punto de red en modo Master para establecer sus comunicaciones.  Este es el modo más utilizado hoy en día para enlazar redes inalámbricas Master-Slave.  El modo Ad-Hoc brinda la posibilidad de un enlace P2P ( punto a punto ) aunque con algunos beneficios sobre el método tradicional cableado.  Por último el modo Observer es un modo de conexión donde no hay transferencia de datos desde el cliente.  Se emplea meramente con fines de prueba y monitoreo donde la estación juega un rol pasivo en las transmisiones.

En este artículo veremos cómo crear enlaces Ad-Hoc entre redes inalámbricas en sistemas GNU/Linux.  Antes de comenzar es necesario verificar si el controlador que utilizamos para nuestro dispositivo de red inalámbrico brinda soporte para este tipo de enlaces.  En ocasiones la versión libre o propietaria que existe hasta el momento no lo brinda, y por tanto no permite realizar este tipo de conexiones.  El mejor sitio que he podido ver es este LinuxWireless.  Pueden consultar el sitio para ver si en su controlador está soportado este modo.

Configuración del servidor

Primero hay que dar de baja a la interfaz de red.  En dependencia del dispositivo que utilicemos habrá que especificar la entrada correcta.

# ifconfig wlan0 down

Ahora procedemos a a la configuración de la interface, pasando a modo ad-hoc el wireless tengan en cuenta que no todas las tarjetas inalámbricas pueden hacer esto, debido a que no todas tienen drivers nativos o completos para linux, para pasarla a modo ad-hoc ejecutamos lo siguiente:

# iwconfig wlan0 mode ad-hoc

Continuamos dándole un nombre a la red que vamos a crear, este nombre es el que se podrá ver al detectar la red ya sea por medio de un #iwlist o algún software para wifi (ejemplo wicd). Para ello ejecutamos el siguiente comando:

# iwconfig wlan0 essid "miRed"

Luego de ello procedemos a configurar el canal y es por medio del cual fluirán los datos. Si existen más redes en el área les recomendaría utilizar un canal que este libre.

# iwconfig wlan0 channel 6

Seguridad en la red por medio de contraseña, este paso es opcional esto dependerá de en donde vivan o los datos que manejen en la red, para ello ejecutamos el siguiente comando:

# iwconfig wlan0 key "0123456789"

Para ejecutar las instrucciones anteriores con un solo comando:

# iwconfig wlan0 mode ad-hoc essid "servidorx" channel 7 key "0123456789"

Ahora le damos una dirección ip al servidor, esto servirá para que el cliente pueda encontrar al servidor dentro de la red y viceversa, no asignaremos mascar de sub-red, dejaremos que el sistema se encargue de ello, asi que solo ejecutamos el siguiente comando:

# ifconfig wlan0 192.162.0.1

Ahora procedemos a habilitar el redireccionamiento. Ejecutamos el siguiente comando:

# echo 1 > /proc/sys/net/ipv4/ip_forward

Por último configuramos un cortafuegos ( firewall ) para redireccionar los paquetes desde una interfaz a otra. En este caso usaremos iptables que permitirá compartir la conectividad principal al cliente. Para ello ejecutamos:

# iptables -t nat -A POSTROUTING -s 192.162.0.0/24 -j MASQUERADE

Configuración del Cliente

Para configurar el cliente es de la misma manera que el servidor sólo que con algunos parámetros invertidos.  En este caso de ejemplo usaremos otra interfaz de red para que el usuario no se pierda en la explicación.  En este caso usaremos una tarjeta de red Atheros ( ath0 ).

# ifconfig ath0 down
# iwconfig ath0 mode ad-hoc essid "miRed" channel 6 key "0123456789"

Pasaremos a configurar ahora el ip de la máquina cliente. Recuerden que el servidor tenía el 192.168.0.1. Pondremos otra dirección:

# ifconfig ath0 192.162.0.2

Ahora procedemos a enrutar el servidor con el cliente, eso lo hacemos con el siguiente comando, en donde la ip que escribimos tiene que ser la del servidor:

# route add default gw 192.162.0.1

Clientes Visuales

Además del modo de configuración a nivel de línea de comandos, existen vías para configurar los enlaces utilizando clientes con interfaces visuales. De los más cómodos que existen podemos encontrar el NetworkManager y el Wicd-client.

Referencias

Compartir internet por medio de wifi sin router inalámbrico

Gracias a Lázaro Abreu Reche por sugerirme el artículo





Red inalámbrica Intel 3945 y 4965 …

3 09 2008

El proyecto que antes soportaba a este modelo de tarjetas era el ipw3945. Actualmente ya está descontinuado y le sucede el proyecto iwl3945 mantenido por el grupo de desarrollo de intel. Actualmente brindan soporte para las iw3945 e iw4965. Para configurar esta tarjeta seguiremos una filosofía similar a otras tarjetas de red inalámbricas que existen. Configuraremos un módulo que controlará el dispositivo e instalaremos un archivo que contendrá una firma del fabricante ( firmware ) para su uso.

Núcleo 2.6.24

El módulo ya viene como parte del núcleo 2.6.24. Si desea puede optar por esta variante lo que le ahorrará tener que compilar el módulo directamente y aprovechará muchas de las funcionalidades que trae esta versión del núcleo. Simplemente active los siguientes símbolos a la hora de compilar para habilitar la 3945:

CONFIG_IWL3945
CONFIG_MAC80211
CONFIG_WLAN_80211

Módulo iwl3945

Otra vía para instalar el módulo de la inalámbrica es bajándonos el código fuente del fabricante y compilándolo. Lo podemos encontrar en el sitio del proyecto así como una guía de construcción e instalación. Noten que debemos en este caso construir el subsistema Mac802111 que también viene en el sitio.

Una vez que habilitemos el módulo por alguna de las 2 vías necesitaremos instalar la firma del fabricante en una ubicación específica en el sistema. Aunque varía entre distribuciones una ubicación estándar para instalarla puede ser en /lib/firmware o en /lib/. Bajaremos de aquí el archivo firmware-iw3945. Descompactemos la carpeta y ubiquemos el fichero en la ubicación del firmware. Luego:

# modprobe -r iwl3945
# modprobe iwl3945

Para comprobar si cargó sin problemas haremos:

# iwconfig
lo        no wireless extensions.
eth1      no wireless extensions.
wmaster0  no wireless extensions.

wlan0     IEEE 802.11g  ESSID:xxxxxx
Mode:Managed  Frequency:2.452 GHz  Access Point: 00:16:01:59:DA:2A
Bit Rate=18 Mb/s   Tx-Power=27 dBm
Retry min limit:7   RTS thr:off   Fragment thr=2346 B
Encryption key:off
Link Quality=92/100  Signal level=-39 dBm  Noise level=-63 dBm
Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
Tx excessive retries:0  Invalid misc:0   Missed beacon:0

Tendremos entonces un dispositivo llamado wlan0 para nuestra inalámbrica. En caso de que no muestre información sobre un dispositivo debemos revisar los registros del sistema ( dmesg, o /var/log/syslog ) y ver si se presenta alguna anomalía con el firmware.





Cómo instalar NetworkManager en Debian …

28 08 2008

En este artículo veremos cómo instalar un asistente que nos ayudará a configurar la red automáticamente. Partiremos del punto de que el usuario tendrá configurados apropiadamente sus dispositivos de red. En caso de que no, deberá consultar una guía de cómo montar un controlador para ellos.

Lo instalamos :

# apt-get install network-manager

En caso de que usemos KDE ó Gnome/Xfce, utilizaremos estas variantes respectivamente:

# apt-get install network-manager-kde
# apt-get install network-manager-gnome

Es necesario luego que comentemos el archivo /etc/network/interfaces para que quede de la siguiente forma:

auto lo
iface lo inet loopback

Este paso no es obligatorio pero sí acelera el proceso de detección de la red por parte del NetworkManager. En Debian son necesarios algunos pasos más. Debemos añadir al usuario que usará el NetworkManager al grupo netdev:

# adduser su_usuario netdev

Luego para que funcione correctamente es necesario reiniciar la sesión ya que la modificación de la asociación grupo-usuario no quedará vigente hasta que esto ocurra.

Es posible de que nos topemos con un problemita como este:

nma_dbus_init(): could not acquire its service.  dbus_bus_acquire_service() says: 'Connection "1.38" is not allowed to own the service : "org.freedesktop.NetworkManagerInfo" due to security policies in the configuration file'

Esto ocurre pq en el archivo de configuración que maneja la permisología sobre el cliente existen problemas con el usuario especificado. El archivo /etc/dbus-1/system.d/nm-applet.conf contiene dichos permisos, simplemente añadimos nuestro usuario como una vía “rápida” para resolver el problema. De lo contrario podemos indagar más en el uso del NetworkManager de este fichero:

<policy user="teratux" allow own="org.freedesktop.NetworkManagerInfo" >
<allow send_destination="org.freedesktop.NetworkManagerInfo"/>;
<allow send_interface="org.freedesktop.NetworkManagerInfo>
</policy>
<policy user="root" >
<allow own="org.freedesktop.NetworkManagerInfo" >
<allow send_destination="org.freedesktop.NetworkManagerInfo" >
<allow send_interface="org.freedesktop.NetworkManagerInfo" >
</policy>

Notarán que las políticas para root y para teratux ( el usuario ) son las mismas. Con esto ya debe correr. Para ejecutar el applet, vamos a una consola como usuario normal:

$ nm-applet

Bibliografía





Problemas con ejemplos de Ogre que usan CEGUI …

14 08 2008

Mientras intentaba probar uno de los ejemplos que trae la biblioteca de desarrollo gráfico Ogre me topé con un problema a la hora de correrlo. Logré encontrar la solución en un blog. Fue probada en una pc usando CEGUI 0.6 y Ogre Eihort 1.4.9.

El problema surge a la hora de ejecutar algunos ejemplos de Ogre que usan CEGUI:

terminate called after throwing an instance of 'CEGUI::FileIOException'

Si utilizamos Ogre 1.4.* y Cegui 0.5.x ó 0.6.x es muy probable que ocurra. En el código de muchos ejemplos se intenta cargar un archivo xml ( TaharezLook.scheme ) el cual no puede ser interpretado correctamente por Cegui ( al menos eso parecía ). El problema no radica en Cegui sino en un intérprete externo que utiliza. Por defecto es XercesParser el que no funciona bien. Con cambiar el intérprete tenemos. Si utilizamos una versión de Cegui precompilada ( proveniente de un paquete en un repositorio, u otra fuente ) necesitamos recompilar la biblioteca. Esto servirá igual si usamos código fuente.

Desde el directorio donde está el código fuente hacemos:

./configure --with-default-xml-parser=TinyXMLParser

Recompilamos el código fuente y lo instalamos nuevamente. Según el artículo es necesario también recompilar Ogre. Me pudo funcionar sin hacerlo pero si aún persiste el problema inténtenlo.

Bibliografía

Problema con Ogre y CEGUI en ejemplos





Entrevista a Bjarne Stroustrup …

6 07 2008

¿ Qué propició el desarrollo de C++ ?

Necesitaba una herramienta para diseñar e implementar una versión distribuida del núcleo de Unix. En aquel tiempo, en 1979, no existía tal herramienta. Necesitaba algo que pudiera expresar la estructura de un programa, tratar directamente con el hardware, y ser lo suficientemente eficiente y portable para ser usado en la programación de sistemas serios.

Puede encontrar información más detallada sobre el diseño y evolución de C++ en mis papeles HOPL ( History of Programming Languages ) Historia de Lenguajes de Programación que puede encontrar en mis páginas , y en mi libro “Diseño y evolución de C++”.

¿ Había un problema en particular que intentabas resolver ?

Los dos problemas que tenía en la mente eran tratar de simular la infraestructura de comunicación entre procesos para un sistema distribuido o de memoria compartida ( determinar cuales servicios del sistema operativo podíamos ejecutar en procesadores diferentes ) y la necesidad de escribir los controladores de red para un sistema de esa magnitud. Obviamente como Unix estaba escrito en C también quería un alto nivel de compatibilidad con C. A inicios del 1980 en adelante, fue usado por otras personas ( ayudados por mi ) para simular varios algoritmos de protocolos de red y administración de tráfico.

¿ De donde proviene el nombre de C++ ?

Tal y como “C con clases” ( mi ancestro de C++ ) se volvió popular dentro de los laboratorios Bell ( Bell Labs ), algunas personas determinaron que ese nombre englobaba mucho para llamarlo C. Esto significaba que necesitaban calificar lo que ellos entendían cuando querían referirse al lenguaje de Dennis Ritchie, por eso usaron “Viejo C”, “C plano”, y otras variantes. Alguien halló esos calificativos como irrespetuosos a Dennis ( ni Dennis ni yo pensábamos así ) y un día recibí un pedido de los canales de administración de Bell Labs para encontrar un nombre mejor. Como resultado nos referimos a C++ como C84 por un tiempo. Eso no sirvió de mucho, por ello pedí sugerencias y elegí C++ de las propuestas. Todos acordamos que semánticamente ++C hubiera sido incluso mejor, pero pensé que crearía muchos problemas para aquellos “no geeks”.

¿ Había algún problema particularmente difícil o frustrante que hayas tenido que sortear en el desarrollo del lenguaje ?

¡¡ Muchos !! Para comenzar, ¿ cuales debieran ser las reglas de diseño fundamentales del lenguaje ? ¿ Qué debía estar dentro del lenguaje y qué no ? Muchas personas esperan un pequeño lenguaje que tenga todas las características útiles que hayan encontrado en cualquier otro lenguaje. Desafortunadamente, eso es imposible.

Después de un corto período dependiendo de la suerte y el buen gusto, me decidí por un juego de “reglas de oro” con la intención de asegurar que los programas en C++ pudieran ser simultáneamente tan elegantes ( como en Simula67, el lenguaje que introdujo programación orientada a objetos ) como eficientes para la programación de sistemas ( como en C ).

Obviamente, no todos los programas pueden ser las dos cosas y muchos ni son una, pero la intención era y es que un programador competente pudiera ser capaz de expresar cualquier idea directamente y ejecutarla con dificultades mínimas ( cero dificultades comparadas con una versión en C ).

Convencer a la comunidad de programación de sistemas del valor del chequeo de tipo fue sorprendentemente difícil. La idea de comprobar argumentos de funciones contra la declaración de una función fue resistida ferozmente por muchos, al menos hasta que C adoptó la idea de “C con clases”.

Hoy en día, la programación orientada a objetos está casi en todos los lugares, así que es difícil que las personas crean que simplemente fallé en convencer a las personas sobre su utilidad hasta que finalmente puse las funciones virtuales y demostré que eran lo suficientemente rápidas para su uso. La variante de C++ de POO ( Programación Orientada a Objetos ) era y es simplemente aquella de Simula con algunas simplificaciones y mejoras en rendimiento.

La compatibilidad con C era y es una fuente grande tanto para problemas como para fortalezas. Siendo compatible con C, los programas de C++ garantizaban un nivel de completamiento de funcionalidades que frecuentemente faltan en las primeras versiones de lenguajes nuevos y un acceso directo ( y eficiente ) a grandes partes de código, no sólo código en C, pero también en Fortran y más pq el mecanismo de las convenciones de llamadas en C eran simples y similares a lo que otros lenguajes soportaban. Después de todo, solía decir, reusen comienzos usando algo que ya exista, y no esperen para que alguien termine el desarrollo de componentes nuevos intencionados a la reutilización. Por otra parte, C tiene muchas rarezas sintácticas y semánticas y mantenerse acoplados con C a medida que se ha desarrollado no ha sido fácil.

¿ Cuáles son las diferencias principales entre el “C con clases” original y C++ ?

Muchas de las diferencias estaban en la técnica de implementación. C con clases fue implementado por un preprocesador, mientras que C++ requiere un compilador apropiado ( por eso creé uno ). Fue fácil transcribir programas en C con clases hacia C++, pero los lenguajes no eran 100% compatibles. Desde el punto de vista de un lenguaje, la mejora principal fue proveer funciones virtuales que habilitaron POO clásica. Sobrecarga ( incluso sobrecarga de operadores ) fue añadida también, gracias también a un mejor soporte de código en línea. Quizás sea importante notar que las características claves de C++ para manejo de recursos, constructores y destructores, estaban en la versión más temprana de C con clases. Por otra parte, las plantillas ( y excepciones ) fueron introducidas en una versión superior de C++ ( 1989 ). Antes de eso usamos macros para expresar ideas de programación genérica.

¿ Hubiera hecho algo diferente en el desarrollo de C++ si hubiera tenido la oportunidad ?

Esta pregunta común es un poco injusta porque por supuesto no tenía los beneficios de casi 30 años de experiencia con C++ en aquel entonces, y mucho de lo que sé ahora es el resultado del experimento con versiones anteriores de C++. También, tenía casi ningún recurso en ese momento ( sólo yo, a medio tiempo ) por eso sugiero que las funciones virtuales, plantillas ( con conceptos similares a lo que C++0x ofrece ), y el manejo de excepciones hubieran hecho de C++85 un lenguaje mucho mejor. Sugeriría no solamente algo que no supe diseñar a principios de los 80′ sino también algo que , si hubiera descubierto milagrosamente el diseño perfecto, no hubiera podido realizarlo en un tiempo razonable.

Creo que liberar una mejor biblioteca estándar con C++1.0 en 1985 hubiera sido casi factible y hubiera sido la mejora más significativa de su tiempo. Al referirme a una “mejor biblioteca” me refiero a una con una biblioteca de clases bases que incluyan una versión ligeramente mejorada del ( en aquel entonces disponible ) biblioteca de tareas para el soporte de concurrencia y un juego de clases contenedoras. Liberando aquellas hubieran propiciado el desarrollo de mejores versiones y hubiera establecido una cultura del uso de bibliotecas bases estándares y no aquellas de índole corporativas.

Más adelante hubiera desarrollado plantillas ( la clave del estilo de C++ de programación genérica ) antes de herencia múltiple ( no una funcionalidad tan aceptada como las personas la consideran ) y hubiera enfatizado un poco más en excepciones. Sin embargo, las excepciones nos traen nuevamente a un problema. Algunos de los conceptos más importantes subyacentes en el uso modernos de plantillas en C++ no existieron hasta un tanto después. Por ejemplo el uso de “garantías” en la descripción del uso seguro y sistemático de plantillas fue solo desarrollado durante el proceso de estandarización de C++ por Dave Abrahams.

¿ Cómo te sientes por el hecho de que C++ se haya estandarizado en 1998 y cómo estuviste involucrado en el proceso de estandarización ?

Trabajé duro para alcanzar ese estándar durante años ( 1989-1997 ) tanto como ahora que estoy trabajando en su sucesor : C++0x. Manteniendo un lenguaje de flujo principal lejos de su fragmentación en dialectos en disputa es una tarea dura y esencial. C++ no tiene dueño, ni mantenedor preferido para proveer fuerza de impulso, bibliotecas “gratis” o publicidad comercial. El comité de estándares ISO fue importante en el crecimiento de la comunidad de C++ y esa comunidad le debe un enorme monto a los muchos voluntarios que trabajaron y trabajan aún en ese comité.

¿ Cuál es el programa más interesante que ha visto escrito en C++ ?

No puedo elegir uno, y usualmente no veo a un programa como interesante. Me fijo más en sistemas completos, de los cuales sus partes están hechas en C++. Entre aquellos sistemas está el subsistema autónomo de conducción del “Mars Rovers” de NASA, el sistema de búsqueda de Google y el sistema de reservación de aerolínea de Amadeus. Mirando a un pedazo de código aislado, pienso que la STL de Alexander Stepanov ( los contenedores, los iteradores, y bibliotecas parte de la biblioteca estándar de C++ ) está entre los más interesantes, útiles y más influyentes que he visto.

Se siente a veces que un número grande de programadores nunca han usado en realidad las plantillas incluso sin programar en C++.

Puede que tengas razón al respecto, pero muchos al menos, creo que la mayoría están usando plantillas a través de la STL ( o bibliotecas bases similares ) y sospecho que el número de programadores que evitan plantillas están declinando rápidamente.

¿ Por qué crees que ocurra esto ?

Por miedo a usar algo que sea diferente a lo que usan, rumores de ineficiencias en el código, problemas de vinculación potenciales y mensajes de error espectaculares.

¿ Desearías que el compilador GNU C++ pudiera proveer errores de sintaxis del compilador más cortos para no asustar a los estudiantes ?

Por supuesto, pero no toda la culpa es de GCC. El problema fundamental es que C++98 no provee una vía para el programador especifique directa y simplemente los requerimientos de una plantilla en sus tipos. Ello es una debilidad del lenguaje, no del compilador, y sólo puede ser manejada a través de un cambio en el lenguaje que será parte de C++0x.

Me refiero a conceptos que permitirán que los programadores de C++0x especifiquen los requerimientos de los juegos de argumentos de plantilla y que se comprueben todos los puntos de llamada y de definición aislados al igual que cualquier otra comprobación de tipo del lenguaje. Para más detalles consulten cualquiera de los documentos de C++0x o “Concepts: Linguistic Support for Generic Programming in C++” ( Conceptos: Soporte lingüístico para programación genérica en C++ ) por Doug Gregor de OOPSLA ’06 ( disponible de mi página de publicaciones ). Una instrumentación experimental puede ser descargada desde el sitio de Doug Gregor .

Hasta que los “conceptos” estén universalmente disponibles, podemos usar “clases de restricción” para mejorar dramáticamente la comprobación. Vean los FAQ técnicos.

La STL son unas de los pocas ( sino las únicas ) bibliotecas de propósito general para los cuales los programadores pueden ver garantías de complejidad. ¿ Por qué crees que sea esto ?

La STL está por lo general adelantada a su tiempo. Es duro proveer las garantías correctas y muchos diseñadores de bibliotecas prefieren emplear sus esfuerzos en funcionalidades más visibles. Las garantías de complejidad son básicamente un intento entre muchos para asegurar calidad.

En los últimos años, hemos visto a la computación distribuida estar más disponible al programador promedio. ¿ Cómo esto afectará a C++ ?

Es difícil decir, pero antes de tratar con programación distribuida, un lenguaje debe soportar concurrencia y ser capaz de manejar con más de un modelo de memoria convencional “lineal/uniforme”. C++0x hace exactamente eso. El modelo de memoria, los tipos atómicos, y el almacenamiento local provee las garantías necesarias para soportar una buena biblioteca de hilos. En resumen, C++0x permite el uso básico y eficiente de varios núcleos. Necesitamos también modelos de concurrencia de mayor nivel para la explotación fácil y efectiva de la concurrencia en nuestras aplicaciones. Las características del lenguaje así como las “funciones objetos” ( disponible en C++98 ) y los lambdas ( una característica de C++0x ) ayudarán en eso, pero necesitamos proveer soporte más allá de la vista de concurrencia “dejar un montón de hilos sueltos en un espacio de memoria común“, la que considero necesaria como infraestructura y la peor vía de organizar aplicaciones concurrentes.

Como siempre, la aproximación de C++ es proveer primitivas y mecanismos de abstracción muy general ( y eficientes ), los que se usan entonces para construir abstracciones de mayor nivel como bibliotecas.

Por supuesto no tiene pq esperar por C++0x para hacer programación concurrente en C++. Muchos han estado haciendo eso durante años y mucho de lo que ofrece el nuevo estándar relacionado con concurrencia está disponible actualmente al igual que las formas antes del estándar.

¿ Vé que esto lleve a la creación de una nueva generación de lenguajes de propósito general ?

Muchos de los “lenguajes scripting” proveen mecanismos para manejar estados en un ambiente Web, y esa es su fortaleza real. Manipulación simple de texto es fácilmente igualada por bibliotecas como las nuevas bibliotecas de expresiones regulares de C++ ( disponible ahora en boost.org ) pero es difícil concebir un lenguaje que sea de propósito general y distribuido. La raíz de ese problema es que la programación conveniente distribuida cae en la simplificación y especialización. Un lenguaje de propósito general no puede simplemente proveer un modelo de distribución de alto nivel.

No veo una razón fundamental en contra de que un lenguaje de propósito general sea extendido con facilidades de distribución, sin embargo, he discutido que C++0x haga exactamente eso. Pienso que eventualmente todos los lenguajes mayores conocidos proveerán algún soporte para distribución a través de la combinación de soporte directo de lenguaje, soporte en tiempo de ejecución, o bibliotecas.

¿ Cree que los recursos como las bibliotecas de boost proveerán funcionalidad / accesibilidad para C++ ?

Algunas de las bibliotecas de boost, especialmente la biblioteca de redes, son un buen comienzo. Los hilos estándares de C++0x se parecen más a los hilos de boost. Si es posible, un programador de C++ debería comenzar con una biblioteca existente ( y, o herramienta ), y no construir directamente en características fundamentales y/o hilos del sistema.

¿ En su opinión, qué legado ha traído C++ al desarrollo informático ?

C++ trajo POO al flujo principal y está haciendo lo mismo con programación genérica. Si observa algunos de los códigos más exitosos en C++, especialmente relacionados con manejo general de recursos, encontrarás que los destructores son centrales e indispensables en el diseño. Sospecho que el destructor será visto como la contribución individual más importante. Todo lo demás recae en combinaciones de las características del lenguaje y técnicas en el soporte de un estilo de programación o combinaciones de estilos de programación.

Otra forma de mirar el legado de C++ es que hizo a la abstracción manejable y costeable en áreas de la aplicación donde antes las personas necesitaban programar directamente en términos de máquina, como bits, bytes, palabras y direcciones.

En un futuro, apunto a una mejor articulación de los ideales de generalidad, elegancia y eficiencia.

¿ Donde ves que se encuentra el futuro de C++ ?

Mucho de donde C++ ha tenido su fortaleza desde el primer día han sido aplicaciones con un componente informático crítico, especialmente para infraestructura. Hoy en día, todas las infraestructuras ( incluyendo la instrumentación de todos los lenguajes de alto nivel ) están en C++ o C y espero que así se mantenga. También, la programación en los sistemas empotrados es un área de mayor uso y crecimiento para C++, por ejemplo el software para la próxima generación de aviones de guerra de EEUU están en C++ ( vea reglas de codificación JSF++ en mi sitio web ). C++ provee más donde simultáneamente necesitas rendimiento y abstracciones de alto nivel, especialmente bajo restricciones de recursos. Curiosamente esta descripción se fija tanto para un iPod como para una aplicación científica a gran escala.

¿ Te ha sorprendido en alguna manera la evolución y popularidad del lenguaje ?

Nadie, con la posible excepción de Al Aho, previsó la escala del triunfo de C++. Supongo que durante 1980 yo estaba simplemente demasiado ocupado incluso para estar sorprendido: El uso de C++ se duplicaba cada 7.5 meses, calculé después, y eso fue hecho sin un departamento comercial dedicado, con casi nadie y con un presupuesto ajustado. Apunté a la generalidad y eficiencia y fue exitoso más allá de cualquier espectación.

Por cierto, ocasionalmente me encuentro con personas que asumen que, porque defiendo a C++ de sus detractores, debo creer que es perfecto. Eso obviamente es absurdo. C++ tiene muchas debilidades, y las conozco mejor que nadie, pero todo el propósito del diseño y ejercicio de la instrumentación no era no cometer errores ( eso es imposible a tan gran escala, y con restricciones de diseño tan draconianas ). La meta era producir una herramienta que, en manos competentes, sería efectiva para la construcción de sistemas de la vida real. En ello, sí tuve éxito más allá de mis sueños.

¿ Cómo responde ante críticas del lenguaje, como que ha heredado las fallas de C y que tiene muchas funcionalidades que lo hacen demasiado pesado ?

C++ heredó las fortalezas y debilidades de C y creo que hemos hecho un trabajo decente compensando las debilidades sin comprometer las fortalezas . C no es un lenguaje simple ( su estándar ISO son más de 500 páginas ) y muchos de los lenguajes modernos son más grandes aún. Obviamente, C++ como C está cargado comparado con lenguajes de juguete, pero no tan grande comparado con otros lenguajes modernos. Existen razones prácticas de porque todos los lenguajes usados para trabajo industrial serio hoy en día están cargados: las tareas para las cuales se usan son grandes y complejas.

Otra razón del tamaño tan incómodo de los lenguajes modernos es la necesidad de estabilidad. Escribí código de C++ hace 20 años que aún corre hoy en día y estoy confiado que aún compilará y correrá dentro de otros 20. Las personas que construyen proyectos de infraestructura grandes necesitan tal estabilidad. Sin embargo, para permanecer moderno y aceptar nuevos retos un lenguaje debe crecer ( o en funcionalidades o en clases bases ), pero si elimina algo rompe el código. Por tanto, los lenguajes que se construyen con preocupaciones serias para sus usuarios ( como C++ y C ) tienden a acometer funcionalidades en décadas y se vuelven cargados. La alternativa son bellos lenguajes para los cuales tienes que reescribir tu código cada 5 años.

Finalmente, C++ deliberadamente y desde el primer día soportó más de un estilo de programación y la interacción de esos estilos. Si cree que existe sólo un estilo de programación que se aplica mejor para todas las aplicaciones y todas las personas, por ejemplo POO, entonces tiene una oportunidad para simplificar. Sin embargo, creo firmemente, que las mejores soluciones, las más legibles, mantenibles, eficientes para grandes clases de problemas requieren más de uno de los populares estilos de programación, como por ejemplo POO y programación genérica. Así que el tamaño de C++ no puede minimizarse soportanto sólo un estilo de programación. Este uso de combinaciones de estilos de programación es una parte clave de mi vista de C++ y una gran parte de su fortaleza

¿ De qué te enorgulleces más en términos del desarrollo inicial del lenguaje y su uso continuo ?

Estoy orgulloso que C++ ha sido usado para tantas aplicaciones que han ayudado hacer al mundo un mejor lugar. A través de C++ he hecho una pequeña contribución al proyecto del genoma humano, a física de energías altas ( C++ se usa en CERN, Fermilab, SLAC, etc … ), exploración espacial, energía eólica. Puede encontrar una lista corta de aplicaciones hechas en C++ en mi sitio. Siempre me alegro cuando escucho del uso del lenguaje en pro del bien.

Estoy orgulloso que C++ ha ayudado a mejorar el nivel de la calidad del código en general, no sólo C++. Lenguajes más recientes como Java y C# han sido usados con técnicas que C++ hicieron aceptables para uso de la vida real y comparados con códigos desde hace 20 años muchos de los sistemas de los que dependemos hoy son increiblemente confiables y han sido construidos con un grado razonable de economía. Obviamente, podemos y debemos hacer algo mejor, pero podemos tener una medida de orgullo en el progreso que hemos hecho hasta ahora.

En términos de contribución personal directa, me alegró poder construir el primer compilador de C++: Cfront, de poder compilar programas de la vida real en 1MB en una máquina de 1MHz. Eso es por supuesto increiblemente pequeño por el estándar de hoy, pero eso es lo que requería para que lenguajes de alto nivel empezaran en las computadoras más tempranas. Cfront fue escrito en C con clases y luego transcribido a ( las primeras versiones de ) C++.

¿ A dónde ve que se dirigen los lengujes de programación en el futuro cercano ?

Es difícil hacer predicciones, especialmente acerca del futuro. Obviamente, no lo sé, pero espero que veremos lenguajes de programación de propósito general con mejores mecanismos de abstracción, mejor chequeo de tipos, y mejores facilidades para explotar la concurrencia. Espero que C++ sea uno de esos. Existirán también lenguajes e infraestructuras corporativas cargadas, existirán galerías de lenguajes específicos o de dominio específico, y existirán lenguajes como los conocemos hoy en día persistiendo sin cambios por separados. Note que estoy asumiendo una evolución significativa de C++ más allá de C++0x. Creo que la comunidad de C++ es muy grande y vigorosa para el lenguaje y su biblioteca estándar para que se convierta esencialmente estático.

¿ Tiene algún consejo para los programadores que están por venir ?

Conozcan los fundamentos de la ciencia de la computación: algoritmos, arquitecturas de máquina, estructura de datos, etc … No copie simplemente técnicas de aplicación en aplicación. Sepa lo que hace, que funciona y por qué funciona. No crea saber que la industria será como existe dentro de 5 años, o lo que hará en ese entonces, así que almacene un grupo de habilidades útiles y generales. Trate de escribir un código mejor y mejor fundamentado. Trabaje para que la “programación” sea una actividad profesional y menos una actividad de “hack” a bajo nivel ( programar es también un arte, pero no sólo eso ). Aprenda de los clásicos en el tema y los libros más avanzados, no esté satisfecho con los más fáciles “How to’s” ( Cómo se hace ), guías y documentaciones en línea, son superficiales.

Existe una sección en su sitio dedicada a “¿En realidad dijo eso?” ( Did you really say that ? ) ¿ Qué cita de ella regresa para perseguirle más ?

No me siento perseguido. Escribí esas citas porque las personas me preguntan mucho por ellas, así sentí que era mejor publicarlas. “C++ hace más difícil que se dispare en el pie, pero cuando lo hace le arranca la pierna entera” a veces se cita de manera hostil hacia C++. Eso sólo muestra inmadurez. Cada herramienta puede traerle problemas si la usa indebidamente y debe tener más cuidado con una más poderosa: puede hacer más daño ( a usted y los demás ) con un carro que con una bicicleta, con una sierra eléctrica que con un serrucho. Lo que dije en esa cita también se cumple para otros lenguajes modernos. Por ejemplo es trivial causar agotamiento de memoria en Java. Los lenguajes modernos son herramientas. Es una razón para tratarlos con respeto y para los programadores que se acerquen a sus tareas con una actitud profesional. No es una razón para evitarlos porque las alternativas de bajo nivel son peores.

Una pregunta obligatoria sobre recolección de basura, ya que estamos casi al final, y pareces recibir este tipo de preguntas a menudo. ¿ Por qué crees que las personas están tan interesadas en este aspecto del lenguaje ?

Porque el manejo de recursos es un tema muy importante, porque algunas personas erróneamente ven la recolección como una señal de programación sucia y derrochadora, y porque otras lo ven erróneamente también como una funcionalidad que distingue los buenos lenguajes de los demás. Mi vista al respecto es que puede ser una herramienta muy útil pero que no es esencial ni apropiada para todos los programas, y por tanto debería verse como algo que puede usar opcionalmente en C++. C++0x refleja ese concepto.

Mi opinión difiere de muchos en que lo veo como una última opción de manejo de recursos, no la primera, y lo veo como una herramienta entre muchas para diseño de sistemas y no una herramienta fundamental para la simplificación.

¿ Cómo recomienda que se haga el manejo de memoria en C++ ?

Mi consejo es que se vea la memoria sólo como un recurso entre muchos ( por ejemplo manejo de hilos, bloqueos, manejo de ficheros, conectores ) y representar cada recurso como un objeto de una clase. Por ejemplo, la memoria puede ser usada para almacenar elementos de un contenedor o caracteres de una cadena, por ello debemos usar tipos como un vector.

Donde sea posible recomiendo el uso de tales manejadores de recursos simplemente como variables en un ámbito. En ese caso, no hay manejo explícito de memoria en la que un programador pueda equivocarse. Cuando el tiempo de vida de un objeto no puede ser fácilmente declarado en un ámbito recomiendo otro esquema sencillo como usar punteros “inteligentes” o smart pointers ( declarados apropiadamente en C++0x ) o representar su dueño como miembro de alguna colección ( esa técnica se usa en sistemas empotrados con tiempo dracónico y requerimientos de espacio ). Estas técnicas tienen las virtudes de aplicarse uniformemente a todos los tipos de recursos y su fácil integración con un grupo de acercamientos de manejo de errores.

Sólo donde tales aproximaciones se vuelvan inmanejables, como un sistema sin una arquitectura de manejo de recursos o de errores o para un sistema lleno de operaciones de reserva explícitas, aplicaría la recolección de basura. Desafortunadamente tales sistemas son muy comunes, por ello considero esto un caso muy fuerte para la recolección aunque no se integre limpiamente con el manejo de recursos general. También, si un recolector puede ser instrumentado para reportar qué basura vaya encontrando, se convierte en un excelente detector de fugas.

Cuando se use un manejo de recursos y contenedores en un ámbito, se genera poca basura y el recolector se vuelve muy rápido. Tales preocupaciones apoyan mi opinión que “C++ es mi lenguaje recolectado de basura preferido porque genera poca basura”.

Esperaba que opcionalmente un recolector de basura se habilitara como parte de C++0x pero habían suficientes problemas técnicos que tengo que resolver de como se integra ese tipo de recolector con el resto del lenguaje si se provee. Tal como es el caso con casi todas las funcionalidades de C++0x, existe una instrumentación experimental.

Hay muchos aspectos de la recolección de basura más allá de lo que cubro aquí, pero después de todo, esto es una entrevista no un libro de texto.

En un tono menos serio, ¿ piensa que los vellos faciales están relacionados con el éxito de los lenguajes de programación ?

Creo que si lo llevamos a un nivel filosófico todo está relacionado, pero en este caso sólo tenemos el humor y la moda de los tiempos. Una generación más temprana de diseñadores de lenguajes exitosos no tenía barba: Backus (Fortran), Hopper (COBOL), y McCarthy (Lisp), así como Dahl y Nygaard (Simula y POO ). En mi caso sólo soy pragmático, mientras vivía en climas más fríos ( Dinamarca, Inglaterra y Nueva Jersey ), usaba barba; ahora vivo en un lugar muy cálido, Texas y elijo no sufrir bajo una barba. Interesantemente, la foto que usan para ilustrar un estado intermedio de mi barba no hace tal cosa. Me muestra visitando Noruega y revirtiendo a un estado de tipo frío por unos días. ¿ Quizás haya otras relaciones interesantes ? Quizás haya una entre la altura de los diseñadores y éxito de los lenguajes. Quizás haya una relación entre éxito de lenguajes y la apreciación de Monty Python. Alguien podría divertirse haciendo un poco de investigación al respecto.

¿ Por último hay algo más que quisiera añadir ?

Sí, creo que debemos considerar la articulación de las ideas y la educación. He tocado esos temas en algunos momentos antes, pero los problemas para que las personas entiendan lo que C++ debió ser y cómo usarlo era al menos tan difícil y costoso como diseñarlo e implementarlo. No tiene sentido hacer un buen trabajo técnico y no contarle a las personas al respecto. Por sí solos, las funcionalidades de los lenguajes son estériles y aburridas, para que sean útiles los programadores deben aprender como pueden ser usadas en combinación para servir algún ideal de la programación, como programación genérica u orientada a objetos.

He por supuesto, escrito muchos papeles técnicos pero muchos de mis escritos han estado encaminados a aumentar el nivel de abstracción de los programas, mejorar la calidad del código y ayudarle a entender a las personas qué funciona y por qué. Pedirle a los programadores que hagan algo sin darle una razón es tratarlo como niños pequeños, debieran ofenderse por ello. Las ediciones de “The C++ Programming Language”, D&E, “Teaching Standard C++ as a New Language”, y mis escritos HOPL están entre mis intentos de articular mis ideas para C++ y ayudar a la comunidad de C++ a que madure. Por supuesto, eso ha sido sólo exitoso parcialmente. todavía hay mucha programación de “corta y pega” que se continúa haciendo y hay bastante código en C++ pobre, pero me anima la cantidad de buen código y el número de sistemas de calidad que se están produciendo.

Últimamente me he movido desde la industria a la academia y veo los problemas educacionales desde otra perspectiva. Necesitamos mejorar la educación de nuestros desarrolladores de software. En los últimos 3 años he desarrollado un nuevo curso para estudiantes de primer año ( a menudo programadores principiantes ). Esto me ha dado la oportunidad de atender un público que antes no he conocido muy bien y el resultado es un libro de principiantes “Programming: Principles and Practice using C++” disponible en Octubre.





Cómo compilar un núcleo de Linux …

1 07 2008

Un núcleo ( kernel ) es el componente central de muchos sistemas operativos. Sus responsabilidades incluyen el manejo de los recursos del sistema ( la comunicación entre hardware y software ). Podemos decir que es una capa importante en la arquitectura del sistema para la compatibilidad de los componentes que tenemos como herramientas para nuestro trabajo. Existen varios núcleos los que se diferencian tanto en estructura como en rendimiento, como por ejemplo el núcleo de BSD, el de Linux de Torvalds, el Hurd de GNU, el de Windows, etc …

En ocasiones perseguimos optimizar un sistema construyéndolo con las opciones más específicas posibles. Quizás por razones de limitaciones de recursos, o la necesidad de habilitar alguna opción específica que por defecto no viene construida en la mayor parte de las distribuciones, la configuración de los núcleos se presenta como una opción viable para la personalización y conocimiento de los componentes de nuestro ordenador.

Este artículo cubrirá solamente cómo configurar y construir un núcleo de Linux para las distribuciones GNU/Linux existentes.

Veremos algunas propuestas que podemos tener en cuenta como una guía para llevar a cabo esta tarea.

Identificación de Hardware y Software

Primeramente necesitamos tener conocimiento de los componentes del sistema donde correrá nuestro núcleo. Esto puede variar tanto desde un conocimiento mínimo como hasta uno detallado de nuestro ordenador, tanto para los componentes de hardware como de software ya que existen muchas funcionalidades que necesitan ser habilitadas en el núcleo para ejecutar determinados programas en un modo de operación conocido como “espacio de núcleo” ( kernel space ). Existen programas que nos pueden ayudar para averiguar el hardware existente en nuestra pc.

$ lspci
00:00.0 Host bridge: Intel Corporation Mobile 945GM/PM/GMS/940GML  ...
00:01.0 PCI bridge: Intel Corporation Mobile 945GM/PM/GMS/940GML ...
00:1b.0 Audio device: Intel Corporation 82801G (ICH7 Family) ...
...
..
00:1f.0 ISA bridge: Intel Corporation 82801GBM (ICH7-M) LPC ...
00:1f.2 IDE interface: Intel Corporation 82801GBM/GHM ...
00:1f.3 SMBus: Intel Corporation 82801G (ICH7 Family) ...
01:00.0 VGA compatible controller: ATI Technologies Inc Radeon Mobility X1400
03:00.0 Ethernet controller: Broadcom Corporation BCM4401-B0 100Base-TX ...
03:01.0 FireWire (IEEE 1394): Ricoh Co Ltd Unknown device ...
03:01.1 Generic system peripheral [0805]: Ricoh Co Ltd R5C822 SD/SDIO/MMC/MS/MSPro ...
..
.
0b:00.0 Network controller: Broadcom Corporation Dell Wireless 1390 WLAN Mini-PCI Card (rev 01)

$ lsusb

Bus 005 Device 001: ID 1d6b:0002
Bus 004 Device 005: ID 413c:8126 Dell Computer Corp.
Bus 004 Device 007: ID 0a5c:4503 Broadcom Corp.
Bus 004 Device 004: ID 0a5c:4500 Broadcom Corp.
Bus 004 Device 006: ID 0a5c:4502 Broadcom Corp.
Bus 004 Device 001: ID 1d6b:0001
Bus 002 Device 003: ID 16d8:6803
Bus 002 Device 001: ID 1d6b:0001
Bus 003 Device 001: ID 1d6b:0001
Bus 001 Device 001: ID 1d6b:0001

Veremos los elementos más importantes para tomar en consideración y cómo podemos identificarlos en estas herramientas que usamos ( lspci y lsusb ). Necesitamos identificar el chipset de la placa madre ( Host bridge ), la tarjeta de audio que tiene ( Audio device ), la tarjeta de video ( VGA controller ), la tarjeta de red alámbrica ( Ethernet controller ), si existe alguna otra interfaz de red , en este caso es inalámbrica ( Network controller ), la capacidad de la memoria de nuestro sistema ( podemos verla con el comando free ), la capacidad del disco duro que tenemos ( con el comando fdisk -l ) y algún otro periférico específico que estemos usando ( tarjetas capturadoras de video, convertidores, etc … )

Proceso de configuración del núcleo

Una vez que conozcamos lo que tenemos en nuestra pc pasaremos a configurar el núcleo para luego poder construirlo. El mecanismo de configuración opera de forma tal que se separa el código del núcleo de su configuración considerándola un estado más del núcleo. Imagínense que pudiéramos tener varias configuraciones con solo portar los archivos de configuración tendríamos listo varios núcleos. Los archivos de configuración almacenan símbolos y estados para ellos. Los estados le dicen al núcleo cómo se debería compilar esa funcionalidad, como un módulo M, como un elemento interno Y o si no se debería construir N. Debemos tener en cuenta a la hora de construir el núcleo que si construimos alguna funcionalidad como un módulo ganaremos en espacio físico del mismo, pero perderemos en tiempo de carga ya que los módulos se demoran en cargar. Por otra parte incorporando las funcionalidades nos limita desde el punto de vista del espacio, algo que no puede ser factible en escenarios de dispositivos empotrados.

Para comenzar necesitamos elegir qué forma usaremos para configurarlo .

Forma Directa

Ya indirectamente sugerimos una, aunque es más complicada : podemos editar manualmente los archivos de configuración y habilitar las opciones que querramos. Bastará con cualquier editor de texto.

Ncurses

Tenemos otra forma de acceder a la configuración a través de una interfaz visual. Podemos usar una en modo consola basada en las bibliotecas ncurses que posibilitan hacer aplicaciones en modo texto con una alta interactividad.

# apt-get install libncurses5-dev

Para levantar la interfaz vamos al directorio donde reside el código fuente del núcleo que vayamos a compilar y ejecutamos:

# make menuconfig

Veremos una interfaz similar a esta en nuestra terminal:

Gconfig o Xconfig

Para aquellos que deseen usar interfaces visuales más interactivas existen opciones para ello. Podemos construir nuestro núcleo usando Gconfig basada en bibliotecas de GTK o con Xconfig construidas con las bibliotecas visuales de X directamente.

# make gconfig

Configuración del núcleo

En esta guía nos centraremos en las funcionalidades principales que harán que nuestro sistema corra correctamente en nuestra máquina. Nos concentraremos en los dispositivos que nombramos al principio : Procesador, memoria … etc … Existen guías dedicadas para la instalación de computadoras específicas, con configuraciones específicas. Ello no será tratado a continuación. Trataremos de brindar una guía de donde ubicar los recursos más utilizados así como de una filosofía útil de configuración y manejo de la construcción de un núcleo de linux a través de sus interfaces. Puede ser que en ocasiones se nos quede algún elemento por habilitar tras su construcción propiciando que nuestro sistema no arranque, o carezca de algunas funcionalidades. A medida que se configuren más núcleos se irá perfeccionando esta técnica y aprendiendo de sus componentes.

La configuración en las interfaces se presenta como una jerarquía de elementos por la cual podemos ir navegando y activando las funcionalidades que querramos utilizar. Existen en ocasiones interrelaciones que no podemos obviar y que en ocasiones nos pueden traer problemas si no conocemos bien el dispositivo que querramos habilitar. Trae además una ayuda contextual que nos puede asistir para decidir si incluimos o no algún recurso en nuestro núcleo.

Siempre que empecemos es aconsejable localizar los elementos críticos de nuestro sistema, habilitarlos y luego ir en busca de la optimización ( si es esto lo que queremos ). Debemos notar que algunos elementos vienen habilitados por defecto, generalmente los de uso más común. En la jerarquía están clasificados según su rol en el sistema, basta simplemente buscar los que queramos configurar y trabajar sobre ellos, por ejemplo:

Processor type and features // Procesador y memoria
Networking // Soporte para sistemas con conectividad ( redes, bluetooth, infrarojo, etc ... )
Device Drivers // Soporte para controladores de dispositivos ( discos SATA, sonido, gráficos, dispositivos I/O, etc ... )
Filesystems // Involucra los sistemas de archivos que usaremos ( ext, vfat, ntfs, nfs , etc ... )

Parches y actualizaciones

En algunas ocasiones en el proceso de desarrollo de un núcleo surgen momentos para los cuales es necesario crear elementos autocontenidos que presentan mejoras, actualizaciones, resoluciones de fallas, o adiciones de funcionalidades nuevas al código. Estos elementos se denominan parches. Básicamente contienen una estructura similar a esta:

parche.patch

Index: archivo
===================================================================
--- archivo
+++ archivo

Texto constante

- Texto a eliminar
+Texto a añadir

Como notarán trabaja mediante un proceso de eliminación y adición de elementos. Al aplicarse sobre un archivo este localizará el cambio y lo aplicará. Para aplicarlo ejecutamos el siguiente comando asumiendo que nos encontramos en la carpeta del archivo a ser aplicado:

# patch < parche.patch

Construcción

Luego de la configuración de un núcleo pasaremos a su construcción. Un núcleo termina siendo un archivo compactado que se ubica generalmente junto a los archivos de arranque del sistema y es llamado por una entrada en el listado del gestor de arranque que utilicemos. Mostraremos dos vías aquí para su construcción la vía tradicional para todas las distribuciones y la vía de Debian utilizando make-kpkg

Vía estándar

Comenzaremos con un comando que creará las interdependencias necesarias en nuestro árbol de núcleo y lo limpiará de construcciones previas:

# make dep && make clean

Luego pasaremos a construir el archivo contenido:

# make bzImage

Luego pasamos a construir los módulos del núcleo:

# make modules

Copiaremos entonces nuestro núcleo construido en el directorio de arranque ( por lo general /boot )

# cp arch/i386/boot/bzImage /boot/nuevo_nucleo

Instalamos los módulos en /lib:

# make modules install

Instalamos el núcleo:

# make install

Luego construimos una imagen initrd. Por sus siglas en inglés es un sistema de archivos temporal usado por el kernel Linux durante el inicio del sistema. Es usado típicamente para hacer los arreglos necesarios antes de que el sistema de archivos raíz pueda ser montado.

# cd /boot
# mkinitrd -o initrd.img-nuevo_nucleo nuevo_nucleo

En este caso usamos el gestor de arranque GRUB. Editamos el archivo /boot/grub/menu.lst y añadimos nuestro módulo para que sea usado en un futuro arranque:

title           Núcleo Nuevo compilado
root            (hd0,1) // Debe ir el identificador de la partición donde está la raíz del sistema
kernel          /nuevo_nucleo root=/dev/sda3 ro i386 // Debe ir el nombre del dispositivo de la raíz
initrd          /boot/initrd.img-nuevo_nucleo
savedefault
boot

Y listo …

Vía Debian

El equipo de Debian provee de un mecanismo más simple para la construcción de un núcleo con el comando make-kpkg:

# apt-get install kernel-package

Cuando tengamos configurado el núcleo simplemente ejecutamos:

# make-kpkg --initrd kernel_image

Su resultado será un archivo .deb ubicado en la carpeta padre a la actual y que al instalarlo nos ubicará el núcleo construido en su ubicación final y nos creará automáticamente su llamado desde el menu.lst. Si consultan el manual del comando verán que puede ser usado para generar cabeceras, números de revisión, versiones, etc …

Una vez instalado veremos que una copia del archivo de configuración terminará en /boot/config. Si quisiéramos aplicar esa u otra configuración para otro código de un núcleo utilizando la interfaz ncurses por ejemplo usamos:

# cp /boot/config.nucleo_nuevo /usr/src/linux-source/.config
# make oldconfig menuconfig

Debemos tener en cuenta que cualquier modificación que podamos hacer a nivel de núcleo puede traer implicaciones en el funcionamiento de nuestro sistema operativo. Los procesos que corren a este nivel son considerados críticos es por eso que debemos tener cuidado con lo que habilitemos y lo que no. La ayuda contextual sirve de mucho para ello. Veremos que con más práctica iremos dominando esta técnica.

Referencias:

Wikipedia
Guía de compilación





Guía de instalación de Debian en VIT D2010

14 05 2008

En este artículo hablaremos un poco sobre el modelo de esta laptop y sobre cómo se le puede instalar Debian con soporte para los dispositivos que trae.

CPU: Intel Core 2 Duo 2 GHz
Chipset: Intel 965M
Red inalámbrica: Intel 3945
Red: Realtek 8111/8168 Gb
Audio: Intel 8280 ICH8
Video: Intel 965
Firewire: Sí
Bluetooth: No
Lector SD: Sí
Modem: Sí

Video

Aún no se ha podido configurar.

Red Inalámbrica

La red inalámbrica que trae este modelo es una Intel Wireless 3945. Iremos a este vínculo

Audio

El audio se instala bastante fácil. Por defecto en la mayoría de los núcleos debe venir habilitado. Si no lo tenemos comprobemos que tenemos este símbolo en el núcleo:

CONFIG_SND_HDA_INTEL

Bibliografía

http://intellinuxwireless.org/Intel Wireless
Intel Graphics





Debootstrap ….

29 04 2008

Aquí veremos cómo montar un sistema auxiliar para uso o pruebas usando la herramienta que provee Debian GNU/Linux llamada debootstrap. Como reza su manual de uso debootstrap puede ser usado para instalar Debian en un sistema sin un disco de instalación al igual que puede ser usado para ejecutar variantes del sistema en un ambiente controlado por chroot. Así podremos crear una instalación mínima o completa de un sistema Debian con fines de prueba o de uso.

El comando chroot levanta una terminal interactiva para un directorio raíz específico. Más adelante veremos algunos elementos de su funcionamiento. Para comenzar instalaremos ambas herramientas:

# apt-get install debootstrap

Comenzaremos por montar el sistema en un directorio determinado. Para el ejemplo nos conectaremos a debian.org e instalaremos un sistema base estable:

# mkdir /opt/bootstrap_test
debootstrap stable /opt/bootstrap_test http://ftp.debian.org/debian

Esto comenzará a instalar el sistema base en la carpeta que especificamos. Luego que termine podremos comenzar a usar nuestro sistema:

# chroot /opt/bootstrap_test

Veremos que nos situa en una terminal. Esta terminal se encuentra dentro de nuestra máquina virtual ( por llamarla de algún modo ). Chroot lo que hace es sustituir la raíz ( / ) del sistema por la estructura de directorios que hayamos creado en alguna ubicación del sistema.

Enlace de dispositivos

Notaremos que cuando intentamos utilizar algún dispositivo del sistema anfitrión desde el sistema cliente estos no aparecen en el directorio. Como ambos sistemas se ejecutan sobre una misma máquina partiremos de la afirmación que los dispositivos para ambas serán los mismos. Por tanto simplemente crearemos enlaces entre los dispositivos en la máquina anfitriona y la cliente. La vía que usaremos será con el fstab. Haciendo un enlace simbólico con ln no es suficiente, ya que estos apuntan a direcciones relativas o absolutas que se modifican una vez que entremos en nuestra máquina cliente. Sin embargo el fstab trabaja a nivel de dispositivos y persiste de forma más conveniente para hacer este tipo de enlaces. Añadimos al fstab:

/dev /opt/bootstrap_test/dev none bind 0 0
/proc /opt/bootstrap_test/proc none bind 0 0
/tmp /opt/bootstrap_test/tmp none bind 0 0

Esto nos enlazará no solo los dispositivos sino también la carpeta temporal /tmp y la carpeta donde se muestra información sobre servicios en el sistema /proc.

Aplicaciones visuales

Otro elemento que nos puede ayudar para poder trabajar en nuestro ambiente controlado es habilitar la ejecución de aplicaciones visuales. Quizás notemos que cuando tratamos de ejecutar alguna aplicación visual recibimos este error:

Xlib: connection to ":0.0" refused by server
Xlib: No protocol specified
(:31539): Gtk-WARNING **: cannot open display:

Para poder utilizar el servidor gráfico corriendo en la máquina anfitriona podemos ejecutar un comando que habilita los permisos para la máquina cliente. En el ejemplo habilitaremos para que se puedan realizar conexiones desde todas las máquinas. Si se desea una permisología más detallada pueden consultar el manual de uso de la aplicación. Esto lo ejecutaremos en la máquina anfitriona:

# xhost +

Al ejecutarlo nos notificará que el acceso se ha habilitado para todas las máquinas.

Arranque del sistema

Cuando tengamos nuestro sistema encapsulado preparado podemos continuar utilizándolo desde su entorno controlado o podemos también ponerlo a correr en nuestro sistema. Quizás el usuario haya querido probar alguna funcionalidad nueva y cuando esté decidido a ponerla en uso quiera que su sistema anfitrión tenga esa imagen del sistema cliente. Para ello debemos ubicar nuestro sistema cliente en otro dispositivo en nuestro sistema. Por ejemplo veremos cómo puede estar estructurado nuestro sistema:

$ df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda3             19228308  16364452   1887104  90% /
tmpfs                   517412         0    517412   0% /lib/init/rw
udev                     10240       108     10132   2% /dev
tmpfs                   517412         0    517412   0% /dev/shm
/dev/sda2               139999     22850    109920  18% /boot
/dev/sda4             46878848  26403112   7586448  68% /home
/dev/sda5             10000000         0  10000000   0% /opt/bootstrap_test

Noten como la “/” está asignado a un dispositivo en este caso /dev/sda3. Podemos crear nuestro sistema debootstrap en otro dispositivo como aparece al final en el listado. Luego modificaremos el arranque de nuestro sistema y asignarle al arranque que cargue con el núcleo instalado y con esta raiz nueva. En el ejemplo usamos el gestor de arranque GRUB. Para ello iremos a /boot/grub/menu.lst:


title           Debian GNU/Linux, kernel 2.6.24.3-e1505-
root            (hd0,1)
kernel          /vmlinuz-2.6.24.3-e1505- root=/dev/sda3 ro i386
initrd          /initrd.img-2.6.24.3-e1505-
savedefault

title           Debian GNU/Linux, kernel 2.6.24.3-e1505- (single-user mode)
root            (hd0,1)
kernel          /vmlinuz-2.6.24.3-e1505- root=/dev/sda3 ro i386 single
initrd          /initrd.img-2.6.24.3-e1505-
savedefault

Noten como se especifica “root=xxxxx” como el sistema raiz a cargar. Simplemente lo modificamos para que acepte nuestro nuevo dispositivo:

.
.
.......  root=/dev/sda5
.
.
.......  root=/dev/sda5
.

Reiniciamos, y listo !!! tendremos nuestro nuevo sistema corriendo. Si por alguna razón no levanta editamos el gestor de arranque cuando arranque el sistema, modificamos la línea referente al root y restauramos los valores anteriores.