¿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.

¿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

• Matamarcianos
• Algoritmo Minimax
• Pong3D con Java3D
• Desarrollo de una bolera virtual
• Game Maker
• Juego de coches
• MazeRunner
• Búsqueda de soluciones basadas en IA
• El juego del trilero
• Tiro a diana
• Busca las minas
• Tragaperras
• Tetris

Entre sus nuevas funciones podemos destacar:

• La posibilidad de ver videos sin hacer uso de plugins ó reproductores externos.
• La disponibilidad del modo de navegación privado y la herramienta para limpiar el historial, la cual ha sido actualizada, permitiendo seleccionar también el rango de tiempo del cual se hará la limpieza.
• Controlar los resultados de la barra de localización haciendo uso de caracteres especiales.
• Mucho más…

Ahora bien, veamos como podemos instalarlo en Gentoo.

1. Actualizar el árbol de Portage

Lo primero es actualizar el árbol de Portage para poder hacer uso del ebuild de Firefox 3.5 RC2.

Para verificar si ya se encuentra disponible el ebuild en nuestro directorio de Portage, podríamos hacerlo de la siguiente manera:

2. Desenmascarar el paquete

Al ser una versión aún inestable el paquete viene por defecto enmascarado así que debemos primero desenmascararlo para poder hacer uso de él.

3. Instalar Firefox 3.5 RC2

De momento sólo se encuentra disponible el paquete precompilado. Para instalarlo con el idioma español podríamos editar nuestro archivo /etc/make.conf y agregarle la línea:

En caso de que sólo quieras hacerlo temporalmente y sólo para este paquete ó agregar también el soporte para otros idiomas, puedes anteponer la línea escrita anteriormente al emerger el paquete.

Ahora sí, instalemos:

4. Ejecutar Firefox

En Gnome se encuentra en el menú Aplicaciones -> Internet -> Mozilla Firefox (bin). Sí, el que tiene el ícono más colorido

Con esto terminamos. Espero les sirva, y además espero escribir más seguido

Saludos!

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

Como siempre, pueden encontrar el vídeo en Youtube o en Vimeo. Aunque creo que hay un pedazo que se ve feo y el sonido no es el mejor, espero que les guste y disculpen lo feo

Esto tiene una gran ventaja frente al típico entorno en el cual tienes máquinas virtuales instaladas ya que, cuando realmente quieras usar el otro sistema operativo, lo ejecutas directamente en tu máquina sin las limitaciones de RAM o aceleración gráfica. Es más o menos lo que explicaba en esta entrada, en donde lo hacia con Windows XP. Pero puesto que algunos han tenido problemas con eso, y otros más me han pedido algo de información más detallada, mejor dejar todo registrado en este vídeo.

Como siempre lo he subido en Blip.tv, Youtube y Vimeo. El vídeo es completamente libre, puedes darle el uso que desees; si deseas el vídeo original para cualquier propósito me contactan por correo.

También lo subí a Youtube, por si no te gusta blip.tv. No es definitivamente el mejor video que hemos hecho, pero de seguro le será útil a alguien. Si deseas necesitas el video original, me puedes escribir solicitándolo, aunque creo que es suficiente con que esté en internet; no pongo el link descarga por cuestiones de recursos

Te recomiendo además esta animación en donde se explica qué es y cómo funcionan las vulnerabilidades de buffer overflow.

Basta con crear un archivo llamado .nanorc en el directorio home (nano ~/.nanorc) de nuestro usuario, y poner algo como esto (para PHP):

syntax "php" "\.php[2345s~]?$"
color brightblue "(.*)\("
color blue "\$[a-zA-Z_0-9$]*|[=!<>]"
color green "(var|class|function|echo|case|break|default|exit|switch|if|else|elseif|@|while)\s"
color green "[.,{}();]"
color red "('[^']*')|(\"[^"]*\")"
color brightyellow "(#.*|//.*)$"
color brightyellow start="/\*" end="\*/"
color brightblue "(<\?(php)?|\?>)"
color white start="\?>" end="<\?(php)?"

Este es un listado completo de la configuración para el resaltado de sintaxis en otros lenguajes de programación. Personalmente tengo sólo los que uso (Java, C/C++, SQL, Python, HTML y PHP), pero hay muchos más. Además, como puedes ver son fáciles de crear o modificar. El resultado es algo como esto:

¡Nada mejor que nano!

En el siguiente ejemplo usaremos básicamente los siguientes métodos y clases:

• Método setUndecorated de la clase JFrame, el cual recibe un parámetro boolean. Si le enviamos true, quitará los bordes de la ventana.
• La clase GraphicsDevice nos permite manejar objetos que representan dispositivos gráficos, como la pantalla del computador. En este caso creamos el  objeto con la instrucción GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); que nos devuelve un objeto que representa la pantalla en donde se está mostrando nuestro programa.
• El método setFullScreenWindow, de la clase GraphicsDevice, nos permite poner nuestro programa en pantalla completa. Además, aunque no lo usemos en el ejemplo, contamos con el método isFullScreenSupported que nos permite saber si es posible poner la ventana en modo fullscreen o no.

Código fuente del ejemplo…

import javax.swing.*;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import java.awt.event.*;

public class EjemploFullscreen extends JFrame implements ActionListener{
        private JButton boton;
        private boolean estaFull = false;
        static GraphicsDevice grafica=
                GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
        public EjemploFullscreen() {
                super("Ejemplo pantalla completa en Java");

                boton = new JButton("Presioname");
                boton.addActionListener(this);
                getContentPane().add(boton);

                setSize(640, 400);
                setUndecorated(true);
                setVisible(true);
        }

        public static void main(String[] args) {
                new EjemploFullscreen();
        }

        public void actionPerformed(ActionEvent e) {
                if(!estaFull)
                        grafica.setFullScreenWindow(this);
                else
                        grafica.setFullScreenWindow(null);
                estaFull = !estaFull;
        }
}

Descargar código fuente

Además, estas clases proporcionan algunos métodos bastante interesantes, como las operaciones básicas o saber si el número es primo o no. Como siempre vamos con algunos ejemplos de apoyo:

Operaciones básicas con la clase BigInteger

En el siguiente ejemplo se hace uso de los métodos add, substract, multiply y divide para realizar las operaciones básicas de suma, resta, multiplicación y división:

import java.math.BigInteger;
public class PruebaOperacionesBasicas {
    public static void main(String args[]){
        BigInteger entero1 = BigInteger.valueOf(45);
        BigInteger entero2 = BigInteger.valueOf(15);
        //sumar con metodo add()
        String texto = "La suma entre "+entero1+
                " y "+entero2+" es "+entero1.add(entero2);
        //restar con metodo substract()
        texto += "\nLa resta entre "+entero1+
                " y "+entero2+" es "+entero1.subtract(entero2);
        //multiplicar con metodo multiply()
        texto += "\nEl producto de "+entero1+
                " y "+entero2+" es "+entero1.multiply(entero2);
        //dividir con metodo divide()
        texto += "\nLa división de "+entero1+
                " y "+entero2+" entre "+entero1.divide(entero2);
        System.out.println(texto);
    }
}

Números primos en Java

Este es un típico ejercicio que nos plantean en la universidad; se trata de hacer un listado de los primeros X números primos. En este caso BigInteger nos proporciona dos métodos muy interesantes: isProbablePrime y nextProbablePrime. El primero de ellos devuelve true si el número es probablemente primo (recordemos que es complejo saber si un número es o no primo cuando es demasiado grande); el segundo devuelve el próximo posible número primo a partir del valor que contenga el objeto.

La siguiente aplicación usa el método nextProbablePrime para listar los primeros 2000 números primos:

import java.math.BigInteger;
public class PruebaNumerosPrimos {
    public static void main(String args[]){
        //iniciar el entero en cero
        BigInteger entero = BigInteger.ZERO;
        StringBuffer texto = new StringBuffer();
        for(int i = 0; i<2000; i++){
            entero = entero.nextProbablePrime();
            texto.append(entero+"\n");
            entero.add(BigInteger.ONE);
        }
        System.out.println(texto);
    }
}

Otros métodos interesantes

La clase BigInteger proporciona además otros métodos que nos ahorrarán bastante tiempo y líneas de código:

• pow, nos permite elevar un número a la potencia que deseemos.
• comparteTo, nos permite comparar si un BigInteger es mayor, igual o menor que otro.
• min y max, nos permiten saber cuál de los dos BigInteger es menor o mayor.

Como mencioné al principio, también es posible usar la clase BigDecimal que funciona de manera similar pero con números de coma flotante.

Descargar código fuente de ejemplos

Los temas tratados en este primer número son:

• CentOS 5.3
• Encarta cierra
• KDE 4.2.2
• TuxInfo 15
• Linux Fundation dice no a FAT

Además, algo totalmente loable es que se distribuya con el formato libre OGG:

Descargar

Puedes encontrar videos de humor, videos deportivos, videos caseros, videos musicales, videos de amor, comerciales, capítulos, series, y todo lo que te puedas imaginar.

Visita VideosYoutube.tv: http://videosyoutube.tv

Lo primero que deberíamos hacer es identificar el nombre que el sistema le ha dado a nuestras tarjetas, en mi caso la tarjeta es le0 (que es el equivalente al típico eth0 en Linux). Para hacerlo basta con ejecutar desde una consola el comando ifconfig.

Configuración manual de la red

Para configurar manualmente nuestra red podemos ejecutar los siguientes comandos:

Explicación

• En el primero comando usamos ifconfig para configurar la interfaz de red le0, con la dirección IP 192.168.16.8 y la máscara de red 255.255.255.0. La opción up activa la interfaz de red.
• Posteriormente usamos el comando route para añadir el gateway por defecto de la red.
• El comando netstat -r nos permite verificar que el gateway fue añadido correctamente. Interesante tener en cuenta que, a diferencia de Linux, para mirar las tablas de enrutamiento no se usa route -n sino netstat -r

Configurar la interfaz de red con DHCP

Esta es la opción más sencilla y la que recomiendo. Si tienes un servidor DHCP en la red, lo mejor será configurar nuestra interfaz de red para que solicite una IP automáticamente. Para ello basta con abrir el archivo /etc/rc.conf y modificar nuestra interfaz de red de tal manera que quede así:

Además, si estás usando otro cliente DHCP diferente del que trae por defecto el sistema, o quieres ejecutarlo con alguna opción en especial, debes modificar estas variables:

¿Qué es PC-BSD?

PC-BSD es un sistema operativo basado en FreeBSD. Puesto que bajo PC-BSD se encuentra un sistema FreeBSD, cuentas con todas las ventajas de velocidad y seguridad que éste proporciona. Es importante tener en cuenta que PC-BSD NO es una distribución de Linux. Ambos están basados en UNIX, pero PC-BSD está basado en FreeBSD y no en Linux.

Existen algunas diferencias entre PC-BSD y FreeBSD. PC-BSD está pensado ser usado como sistema de escritorio, mientras que FreeBSD fue concebido sobre todo para usarse como servidor. Además PC-BSD ofrece un instalador gráfico y el escritorio KDE, tiene un gran número de aplicaciones de escritorio pre-instaladas y, aunque soporta el sistema de ports de FreeBSD, proporciona un método de instalación sencillo de paquetes precompilados.

Además, el kernel de PC-BSD ha sido recompilado con algunas modificaciones de tal manera que tenga un mejor comportamiento como sistema de escritorio. E incluso incluye los drivers para las tarjetas aceleradoras de video NVIDIA.

Instalación

Lo primero es ir a la página de descargas y bajar la ISO que deseemos. Las ISOs más importantes son:

PC-BSD 32Bit (i386)

• PC-BSD CD #1 32bit (i386) – System install CD1
• PC-BSD CD #2 32bit (i386) – System Install CD2
  
• PC-BSD CD #3 32bit (i386) – Multi-language support + Optional Components
• PC-BSD DVD 32bit (i386) – Complete install + Optional Components

PC-BSD 64Bit (amd64)

• PC-BSD CD #1 64bit (amd64) – System install CD1
• PC-BSD CD #2 64bit (amd64) – System Install CD2
  
• PC-BSD CD #3 64bit (amd64) – Multi-language support + Optional Components
• PC-BSD DVD 64bit (amd64) – Complete install + Optional Components

Una vez hayamos descargado la imagen y la hayamos quemado en un CD, es hora de insertarlo en el PC y bootear desde él. Esto cargará el instalador de  PC-BSD, siendo la primera opción la selección de nuestro idioma, la distribución del teclado y la zona horaria:

Aceptamos los términos de la licencia:

En el siguiente paso decidimos si vamos a realizar una instalación nueva, el tipo de sistema a instalar (Desktop o Server), así como la fuente de los paquetes a instalar. Yo escogí Desktop por supuesto:

Luego ponemos el password que le daremos al usuario root, y creamos un usuario con privilegios que será nuestro usuario. Es recomendable que, si eres usuario de Linux, selecciones bash como la shell por defecto del usuario:

Seleccionamos el disco sobre el cual haremos la instalación. En este caso, para propósitos de documentación lo instalé en una máquina virtual, por lo que uso todo el disco. En tu caso podrías usar el asistente de partición:

Es hora de escoger el software adicional que queremos instalar, teniendo en cuenta que el sistema de escritorio es KDE:

En este punto ya hemos configurado todo lo necesario para dar inicio a la instalación; clic en Next:

El progreso de la instalación…

¡Y eso es todo! Damos clic en Reboot, removemos el CD de instalación y ya tenemos un BSD instalado.

Una vez hemos iniciado nuestro PC-BSD configuramos la resolución de la pantalla…

Iniciamos sesión desde el KDM:

Enlaces interesantes…

• Página oficial del proyecto PC-BSD: http://pcbsd.org/
• Foros de ayuda: http://forums.pcbsd.org/
• Descarga PC-BSD