lunes, 24 de junio de 2013

Creación de Imágenes ISO en Ubuntu con Brasero

Brasero es probablemente la aplicación para creación de discos más usada en Linux, y es además realmente sencilla. A continuación, muestro dos ejemplos de uso para la creación de imágenes (ISO en este caso).


Caso 1: ISO a partir de CD/DVD

Insertamos el disco del que queremos extraer la imagen, abrimos Brasero y seleccionamos Disc Copy. A continuación seleccionamos la unidad donde insertamos el disco y escogemos Image File.

Por omisión, Brasero graba las imágenes en formato .toc, por lo que debemos hacer click en Properties y seleccionar .iso (también acá podemos seleccionar la ruta donde se guardará el archivo).


Finalmente hacemos Create Image y esperamos que se genere nuestro archivo.





Caso 2: ISO a partir de archivos/directorios

Si lo que tenemos es un conjunto de directorios y archivos en nuestro ordenador, a partir del cual queremos hacer un archivo ISO, debemos seleccionar Data Project, y añadir todos los archivos/directores que deben ir a la imagen, tal como si fueramos a crear una copia física.

Seleccionamos Image File y luego hacemos clic en Burn (Si brasero no detecta un disco virgen en la unidad, mostrará un breve mensaje y seleccionará Image File por omisión).


Al hacer clic en Burn, Brasero nos pedirá el nombre y ubicación del archivo.


Para terminar, hacemos clic en Create Image y comenzará el proceso de creación de la imagen.



jueves, 7 de marzo de 2013

Marca de agua con GIMP

Conozco 2 opciones a la hora de crear una marca de agua para nuestras fotografías: guardarla como PNG (o nuestro formato de preferencia) y luego pegarla sobre cada fotografía, o guardarla como un pincel/brush. Guardar nuestra marca como imagen, permite que la podamos usar en prácticamente cualquier editor de imágenes, mientras que los brushes son relativos a la aplicación que usemos (generalmente). Sin embargo, si utilizamos siempre una misma herramienta de edición, es más fácil crear un brush una vez y usarlo luego utilizarlo, además de que seguramente así tendremos muchas más opciones.

Bien, la herramienta que yo uso es GIMP, y a continuación describo cómo guardar (y cómo usar luego) nuestras marcas de agua como archivos GBR (Gimp Brush).

Comenzamos creando un nuevo archivo fondo transparente, como se ve en la siguiente imagen.



Las dimensiones no tienen que ser exactamente esas, pueden ser mucho más pequeñas si va a ser una marca simple. Todo depende de la calidad de imágenes que vayamos a firmar, si son muy grandes, nuestra firma también debería serlo.

El siguiente paso es crear la firma... Allí es donde entran los gustos y la creatividad de cada quien. Bien, yo hice una simple para este ejemplo que es sólo el texto '@marcocamejo'.

Si hemos usado varias capas, antes de guardar, debemos mezclarlas (Image > Merge visible layers). También es muy recomendable eliminar el espacio que sobre (Image > Autocrop image).

Bien, una vez terminada la firma, guardamos con extensión .gbr. GIMP mostrará el siguiente cuadro.



Luego, para que GIMP reconozca el brush, debemos copiar el archivo gbr al directorio de brushes de GIMP. En esta máquina (con Ubuntu 12.10 y GIMP 2.6), ese directorio es $HOME/gimp-2.6/brushes.

Y eso es todo. Cada vez que queramos firmar una fotografía, sólo debemos usar la herramienta paintbrush y escoger nuestro pincel.



Como ven, y como comentaba al comienzo, de esta forma tenemos algunas opciones para configurar nuestra firma (escala, opacidad, etc).






martes, 12 de febrero de 2013

Creando parches para el kernel de Linux


Como parte del producto de mi trabajo de maestría en Computación, he requerido generar un parche para el kernel de Linux. El proceso es muy sencillo, y no es muy diferente al crear un parche de cualquier archivo o directorio común y corriente, utilizando el comando diff. Resumo el proceso en 3 pasos.

1. Preparar los directorios

Debes tener un directorio con el kernel vanilla y otro directorio con el kernel modificado. Por supuesto, deben corresponder a la misma versión. En mi caso, estoy trabajando con la versión 3.2.1, y he nombrado linux-3.2.1 a mi kernel modificado y linux-vanilla-3.2.1 al kernel vanilla.

Ambos kernels los tengo en el directorio /usr/src, pero esto no es necesario, pueden estar en un directorio cualquiera.

2. Limpiar ambos directorios

Asumiendo que los kernels se encuentran en /usr/src, basta con ejecutar:
cd /usr/src/linux-3.2.1
make mrproper
make clean
cd ../linux-vanilla-3.2.1
make mrproper
make clean

3. Generar el parche

Finalmente, usamos el comando diff para generar el parche:
cd /usr/src/
diff -Nur linux-vanilla-3.2.1 linux-3.2.1 > patch-3.2.1

¡Y eso es todo! El archivo patch-3-2.1 es nuestro parche.

NOTA: al usar el comando diff, el orden es importante, primero va el kernel vanilla y luego el modificado, no al revés.

lunes, 17 de septiembre de 2012

Impriendo data selectivamente con Gnuplot

Gnuplot es una muy buena herramienta (de línea de comandos) de graficado 2D/3D que funciona en los Sistemas Operativos más comunes. Me es particularmente útil para hacer gráficas de datos tabulados.

Eventualmente recibimos alguna data tabulada para graficar, pero de la que no nos interesa más que una parte. Por ejemplo, nos dan un archivo en el que cada fila representa ciertos indicadores económicos desde el año 1960 hasta 2012, y sólo queremos graficar los indicadores desde 1980 hasta 2000. Otro ejemplo podría ser que tengamos que graficar muchos archivos que tienen una o más líneas de cabecera y lógicamente debemos omitirlas. Otro caso, podría ser que, volviendo al primer ejemplo, quisieramos graficar los datos de cada 5 años y no todos (1965, 1970, 1975, etc).

Para estos casos y muchos más, tenemos la opción every, cuya sintaxis es la siguiente:

every I:J:K:L:M:N

En donde:

  • I: incremento de línea
  • J: incremento de bloque de datos
  • K: primera línea (empezando en 0)
  • L: primer bloque de datos (empezando en 1). Se consideran bloques de datos, los separados por líneas en blanco en el archivo
  • M: última línea
  • N: último bloque de datos

Por ejemplo, si tenemos un archivo con la siguiente estructura:

#year #var1 #var2 #var3
1960 120 80 90
1961 125 85 91
1962 124 79 91
1963 121 81 88
...

y queremos graficar year Vs. var3,  omitiendo la primera línea (cabecera) y sólo tomando en cuenta los primero 100 valores:

plot "archivo.in" every ::1::100 using 1:4 with lp


Observe que sólo se especifica hasta el índice que estemos utilizando (no se colocan ":"s de relleno al final). Por ejemplo, si quisieramos imprimir todos los datos, sólo omitiendo los primeros 3, sería:

plot "archivo.in" every ::3 using 1:4 with lp

Combinando los índices, tenemos muchas posibilidades.

miércoles, 12 de septiembre de 2012

ndiswrapper y Ubuntu 12.04

Hace un rato hice el upgrade a Ubuntu 12.04 (sí, ya sé que está casi listo el 12.10), desde Ubuntu 11.10, en una PC de escritorio que se conecta a Internet a través de una tarjeta wifi encore ENLWI-NX2, que como conté hace algún tiempo, no es soportada por Ubuntu, así que uso ndiswrapper para cargar el driver de Windows.

El punto es que luego de terminado el upgrade no tenía acceso a Internet. En el menú de redes de Ubuntu no me aparecía ninguna red inalámbrica. Para diagnosticar el problema, lo primero que hago es revisar si el driver estaba cargado:
sudo lshw -C network

Y me aparece como UNCLAIMED la interfaz de la tarjeta inalámbrica, es decir, como si no hubiese ningun driver cargado. Sin embargo, luego pruebo:
sudo ndiswrapper -l

y me doy cuenta que el driver SÍ estaba instalado. Aquí fue donde comencé a googlear, y me econtré con esta pregunta. Allí la primera sugerencia era instalar ndiswrapper-dkms, y con ello resolví el problema.

Si la única forma de acceso a Internet de esa máquina es mediante la red inalámbrica, tocará llevarse el paquete en un disco o memoria usb. Se puede descargar de acá:

Además, este paquete depende de dkms, que probablemente no esté instalado, así que hay que llevarlo también:

Luego instalamos los paquetes y cargamos el módulo:
sudo modprobe ndiswrapper

Y recordar que si queremos que el módulo se cargue cada vez que se arranca el sistema, debemos agregarlo a /etc/modules.

viernes, 13 de julio de 2012

7 ejemplos prácticos del comando Locate de Linux



Cuando se necesita buscar algún archivo, comunmente se utiliza el comando find. find es una buena utilidad de búsqueda, pero es lenta. locate puede buscar archivos de forma muy rápida. A continuación presento una traducción -libre- de este artículo, donde se detalla el funcionamiento de locate y se incluyen algunos prácticos ejemplos de uso.



Cómo funciona locate? - updatedb yh updatedb.conf


Cuando decimos que locate busca muy rápido, entonces la primera pregunta que viene a la mente es ¿qué lo hace tan rápido?

Bien, locate no busca los archivos en disco, sino que busca las rutas a los archivos en una base de datos.

La base de datos es un archivo que contiene información sobre los archivos y sus rutas en el sistema. La base de datos de locate se encuentra en /var/lib/mlocate/mlocate.db

La siguiente pregunta lógica es ¿qué mantiene a esta base de datos mlocate actualizada?

Bien, existe otra utilidad conocida como updatedb. Cuando se ejecuta updatedb, se escanea el sistema completo y se actualiza mlocate.db.

De tal manera que una de las limitaciones de locate es que depende de la base de datos, la cual es actualizada por updatedb. Por lo tanto, para obtener resultados actualizados y fiables, de locate, la base de datos debe ser actualizada frecuentemente.

También se puede configurar updatedb de acuerdo a nuestras necesidades. Esto se puede lograr actualizando el archivo updatedb.conf. Este es un archivo de configuración que lee updatedb antes de actualizar la base de datos. updatedb.con se encuentra dentro de /etc/:

# cat /etc/updatedb.conf
PRUNE_BIND_MOUNTS="yes"
PRUNENAMES=".git .bzr .hg .svn"
PRUNEPATHS="/tmp /var/spool /media"
PRUNEFS="NFS nfs nfs4 rpc_pipefs afs binfmt_misc proc smbfs autofs iso9660 ncpfs coda devpts ftpfs devfs mfs shfs sysfs cifs lustre_lite tmpfs usbfs udf fuse.glusterfs fuse.sshfs ecryptfs fusesmb devtmpfs"

updatedb.conf contiene data en la forma VARIABLE=VALOR. Estas variables pueden ser clasificadas en las siguientes categorías:

  • PRUNEFS: Una lista (separada por espacios en blanco) de tipos de sistemas de archivos (como se usan en /etc/mtab) que no deben ser escaneados por updatedb. La comparación de los tipos de archivos es insensible a mayúsculas y minúsculas. Por defecto, ningún sistema de archivo es omitido. Cuando se escanea y un sistema de archivo es omitido, todos los sistemas de archivos montados en su sub-árbol son también omitidos, inclusive si su tipo no coincide con alguna entrada en PRUNEFS.
  • PRUNENAMES: Una lista (separada por espacios en blanco) de nombres de directorio (sin rutas) que no deben ser escaneados por updatedb. Por defecto, ningún nombre de directorio es omitido. Note que sólo se pueden especificar directorios y no se pueden utilizar mecanismos de patrones (como globbing, por ejemplo).
  • PRUNEPATHS: Una lista (separa por espacios en blanco) de nombres de rutas de directorio que no deben ser escaneadas por updatedb. Cada nombre de ruta debe estar en la forma exacta en la cual el directorio sería reportado por locate. Por defecto, ninguna ruta es omitida.
  • PRUNE_BIND_MOUNTS: puede valer "0", "no", "1" o "yes". Si PRUNE_BIND_MOUNTS vale "1" o "yes", los bind mounts que tengamos en el sistema no serán escaneados por updatedb. Todos los sistemas de archivo montados en el sub-árbol de un bind mount también serán omitidos, inclusive si no son bind mounts. Por defecto, los bind mounts no son omitidos.

Tenga en cuenta que toda esta configuración se puede modificar a tavés de las opciones del comando updatedb.


Ejemplos prácticos del uso de locate

1. Buscar un archivo usando locate


Para buscar un archivo con locate, ejecutamos:

locate nombre_de_archivo

Si se especifica la opción -0 se muestra la salida en una sola línea.

locate -0 nombre_archivo


2. Mostrar sólo la cantidad de archivos encontrados

locate -c nombre_de_archivo


3. Usar updatedb para actualizar la base de datos mlocate

sudo updatedb #debe ser ejecutado como root


4. Cambiar la base de datos mlocate

La base de datos que locate utiliza por omisión es /var/lib/mlocate/mlocate.db, pero se puede especificar otra, se utiliza la opción -d:

locate -d ruta_otra_base_datos nombre_de_archivo

5. Verificar si un archivo existe

Si eliminamos un archivo del sistema, hasta que no se actualice la base de datos, seguirá apareciendo en los resultados de búsqueda de locate. Si especificamos la opción -e, locate verificará la existencia física de los archivos y no mostrará aquellos archivos que no se encuentren.

locate -e nombre_archivo

6. No tomar en cuenta mayúsculas y minúsculas

Siendo locate sensible a las mayúsculas y minúsculas, "new.txt" es distinto a "NEW.txt". Si queremos que esto no sea tomado en cuenta, utilizamos la opción -i:

locate -i nombre_De_ArchiVo


7. Filtrar las salidas

Si queremos ver sólo los primeros N resultados, utilizamos la opción -l:

locate -l N nombre_de_archivo

Fuente: TheGeekStuff

jueves, 12 de julio de 2012

Programación de Módulos para el Kernel de Linux (II)

En una entrada anterior realicé una introducción a la programación de módulos para el kernel del Linux: los comandos básicos para gestionarlos (lsmod, insmod, rmmod, etc), su estructura básica, compilación, alguno que otro detalle y por supuesto, el típico hola mundo.

Particularmente para la compilación, utilicé un Makefile sencillo para utilizarlo en cualquier directorio y contra la versión actual del kernel.

Ahora queremos compilar un kernel vanilla, con nuestros propios módulos. Esto es bastante parecido a lo que hicimos en la entrada anterior con algunas consideraciones adicionales.

Partimos del hecho de que tenemos el kernel vanilla sobre el que trabajaremos, y más importante aún, que sabemos compilarlo, así que no tocaremos detalles de la compilación per se.

Agregaremos el hola mundo que ya hemos hecho, al directorio del kernel en el que se almacena el Linux Virtual Server, que en la versión sobre la cual estoy trabajando (la 3.0.1), sería net/netfilter/ipvs/.

Bien, vamos al directorio net/netfilter/ipvs y agregamos nuestro módulo que llamaremos ip_vs_hola.c. Dentro de él, colocaremos el código tal cual como el ejemplo final de la entrada anterior:

#include <linux/module.h>  /* utilizada por todos los modulos */
#include <linux/init.h>    /* utilizada para poder usar macros */
#include <linux/kernel.h>  /* utilizada por printk */

int init_func()
{
    printk(KERN_INFO "holamundo: cargando...\n");
    return 0;
}

void exit_func()
{
    printk(KERN_INFO "holamundo: descargando...\n");
}

module_init(init_func);
modue_exit(exit_func);

Bien, si queremos que nuestro módulo aparezca entre las opciones cuando hacemos make menuconfig, por ejemplo, debemos agregarlo al archivo Kconfig del directorio en el cual se encuentra el módulo (net/netfilter/ipvs/Kconfig en este caso).

config CONFIG_IP_VS_HOLA
    tristate "Hola Mundo"
    help
      Modulo hola mundo para el ip_vs.

Acá le hemos puesto un nombre para ser usado en el ámbito de la configuración, hemos dicho que puede ser seleccionado como módulo, built-in o ninguno, y hemos especificado una ayuda corta. Para más detalles, revisar la documentación oficial de kconfig aquí.

El siguiente paso es modificar el Makefile (también del directorio donde se encuentra el módulo) con las reglas necesarias para su compilación. En este caso, dada la sencillez del problema, basta con agregar obj-$(CONFIG_IP_VS_HOLA) += ip_vs_hola.o en alguna parte del Makefile. Así estaríamos usando la variable con la cual identificamos a nuestro módulo, que al momento de compilar se transformará en "y" o "m" si configuramos para ser compilada buit-in o como módulo, respectivamente.

Finalmente nos queda completar los pasos normales para una instalación de un kernel a partir de sus fuentes (compilar el kernel, compilar los módulos, instalar los módulos e instalar el kernel).

Podemos hacer el ejercicio de seleccionar nuestra opción como built-in, en vez de módulo, y veremos como luego de instalado el kernel, cada vez que lo iniciemos, tendremos en el log el mensaje que imprimimos en la función de inicialización. Si por el contrario, seleccionamos como módulo, tendremos que hacer un modprobe para que se ejecute dicha función.


EXPORT_SYMBOL

Una de las múltiples razones por las cuales quisieramos agregar nuestros módulos a un kernel, es agregar funcionalidades de algún tipo. Eventualmente podríamos requerir utilizar en un módulo, una función que hemos definido en otro módulo.

Ahora vamos a agregar una función saludar() a nuestro módulo ip_vs_hola, que también imprima algo con printk(). Si quisieramos utilizar esta función dentro de otro módulo ip_vs_hola_2, utilizamos EXPORT_SYMBOL de la siguiente manera en ip_vs_hola:

#include <linux/module.h>  /* utilizada por todos los modulos */
#include <linux/init.h>    /* utilizada para poder usar macros */
#include <linux/kernel.h>  /* utilizada por printk */

int saludar()
{
 printk(KERN_INFO "la funcion saludar ha sido invocada \n");
 return 1;
}
EXPORT_SYMBOL(saludar);

int init_func()
{
    printk(KERN_INFO "holamundo: cargando...\n");
    return 0;
}

void exit_func()
{
    printk(KERN_INFO "holamundo: descargando...\n");
}

module_init(init_func);
modue_exit(exit_func);

Y luego, en ip_vs_hola_2 bastaría con una referencia extern a dicha función.
#include <linux/module.h>  /* utilizada por todos los modulos */
#include <linux/init.h>    /* utilizada para poder usar macros */
#include <linux/kernel.h>  /* utilizada por printk */

extern int saludar(void);

int init_func()
{
    saludar();
    return 0;
}

void exit_func()
{
    printk(KERN_INFO "holamundo: descargando...\n");
}

module_init(init_func);
modue_exit(exit_func);

Y eso es todo. No es nada del otro mundo, pero hay que tomar un par de cosillas adicionales en cuenta.