IPCorp Blog

Los héroes de esta historia son dos:

• SystemRescue
• VirtualBox

El primero es una LiveDistro es decir una distribución de Linux que se ejecuta en el arranque sin instalarse en un disco duro. Un comentario al margen respecto de esto es que en nuestro país Argentina se encuentra una de las primeras LiveDistro del Planeta y lleva el nombre de UTUTO, además de ser la primer Distribución reconocida totalmente libre por el proyecto GNU.

Read the rest of this entry »

Hace unos días actualicé a Ubuntu 9.10, y al finalizar apareció un mensaje que indicaba que mi disco tenía muchos sectores erróneos.

Uno de mis compañeros intentó detectar los sectores erróneos con System Rescue, y reportó que estaba todo bien.

Buscando encontré un foro en ubuntu-es que planteaba el mismo problema (http://www.ubuntu-es.org/?q=node/120405).

Resultó ser un bug, pueden verlo reportado en https://bugs.launchpad.net/ubuntu/+source/libatasmart/+bug/438136.

Afortunadamente, no tuve que cambiar el disco.

Si bien pasar archivos de texto plano a PDF en Linux no requiere mayor esfuerzo que la simple acción de mandar a imprimir de cualquier editor de texto como Gedit o KWrite , se vuelve un poco más complicado si tenemos una cierta cantidad de ellos.

Para evitarme el trabajo de hacerlo manualmente me puse a buscar una herramienta para automatizar la tarea, ya que tenía que pasar a PDF el padrón la provincia de Corrientes con electores agrupados y separados por sexo, municipios y circuitos en casi 300 archivos de texto. Haciendo un poco de investigación me topé con Text2PDF una sencilla aplicación que permite la exportación de archivos de texto plano a PDF, esta herramienta tiene una desventaja ya que no tiene un paquete precompilado para Linux, así que tenemos que bajar el código fuente desde acá y compilarlo.

Para realizar la compilación necesitamos tener instalados los paquetes de desarrollo, en Ubuntu podemos hacerlo mediante aptitude

sudo aptitude install build-essentials

luego creamos una carpeta y bajamos el código fuente de la aplicación

mkdir text2pdf
cd text2pdf
wget http://www.eprg.org/pdfcorner/text2pdf/text2pdf.c
gcc text2pdf.c -o text2pdf

para mayor comodidad podemos agregar la ruta al ejecutable dentro en el PATH, ahora podemos hacer una pequeña prueba al estilo UNIX

text2pdf -h | text2pdf > help.pdf

Listo, resta hacer un script que recorra todos los archivos de texto dentro del directorio y que los pase a PDF, sencillo no?.

Vamos a ver dos maneras, una mediante uno de mis lenguajes favoritos: ruby y la otra mediante BASH por si no quieren instalar ruby.

Primero vamos con Ruby, en un archivo llamado text2pdfmasivo.rb escribimos lo siguiente:

Dir.glob("*.txt").each { |file| system "text2pdf "#{file} > #{file}.pdf" }

con Dir.glob(”*.txt”) filtramos y obtenemos un array con todos los archivos txt y luego lo recorremos, con el comando system hacemos podemos ejecutar programas externos y para poder ejecutarlo usamos el intérprete de ruby

ruby text2pdfmasivo.rb

Ahora vamos a hacerlo con BASH, en un archivo llamado text2pdfmasivo.sh agregamos

for i in "ls -a -A *.txt $1"
do
text2pdf $i > "$i.pdf"
done;

La lógica es exactamente la misma que en el ejemplo anterior, le damos los permisos de ejecución necesarios y listo ya lo podemos correr.

Nota: no soy experto en BASH por lo que cualquier comentario para mejorar el script es bienvenido .

Una desventaja importante de Text2PDF es que arroja errores de segmentación para archivos grandes de aproximadamente 500 páginas o más, pero exportar ese tipo de volumen suele ser muy raro .

Para poder ver cuanta memoria tenemos en nuestra tarjeta gráfica en linux, utilizamos el comando “lspci” de la siguiente manera:

$ lspci

Luego nos aparece un listado del siguiente tipo:

00:00.0 Host bridge: Intel Corporation Mobile PM965/GM965/GL960 Memory Controller Hub (rev 0c)
00:02.0 VGA compatible controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
00:02.1 Display controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
00:1a.0 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #4 (rev 02)
00:1a.1 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #5 (rev 02)
00:1a.7 USB Controller: Intel Corporation 82801H (ICH8 Family) USB2 EHCI Controller #2 (rev 02)
00:1b.0 Audio device: Intel Corporation 82801H (ICH8 Family) HD Audio Controller (rev 02)
00:1c.0 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 1 (rev 02)
00:1c.1 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 2 (rev 02)
00:1c.4 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 5 (rev 02)
00:1d.0 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #1 (rev 02)
00:1d.1 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #2 (rev 02)
00:1d.2 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #3 (rev 02)
00:1d.7 USB Controller: Intel Corporation 82801H (ICH8 Family) USB2 EHCI Controller #1 (rev 02)
00:1e.0 PCI bridge: Intel Corporation 82801 Mobile PCI Bridge (rev f2)
00:1f.0 ISA bridge: Intel Corporation 82801HEM (ICH8M) LPC Interface Controller (rev 02)
00:1f.1 IDE interface: Intel Corporation 82801HBM/HEM (ICH8M/ICH8M-E) IDE Controller (rev 02)
00:1f.2 SATA controller: Intel Corporation 82801HBM/HEM (ICH8M/ICH8M-E) SATA AHCI Controller (rev 02)
00:1f.3 SMBus: Intel Corporation 82801H (ICH8 Family) SMBus Controller (rev 02)
02:09.0 FireWire (IEEE 1394): Ricoh Co Ltd R5C832 IEEE 1394 Controller (rev 05)
02:09.1 SD Host controller: Ricoh Co Ltd R5C822 SD/SDIO/MMC/MS/MSPro Host Adapter (rev 22)
02:09.2 System peripheral: Ricoh Co Ltd R5C843 MMC Host Controller (rev 12)
02:09.3 System peripheral: Ricoh Co Ltd R5C592 Memory Stick Bus Host Adapter (rev 12)
02:09.4 System peripheral: Ricoh Co Ltd xD-Picture Card Controller (rev ff)
09:00.0 Ethernet controller: Marvell Technology Group Ltd. 88E8040 PCI-E Fast Ethernet Controller (rev 12)
0b:00.0 Network controller: Intel Corporation PRO/Wireless 3945ABG [Golan] Network Connection (rev 02)


Luego nos fijamos en la linea que dice VGA compatible controller, resaltada en rojo en el listado de arriba y prestamos atención a la cadena del dispositivo (00:02:0), luego simplemente ejecutamos:


$ lspci -v -s 00:02.0


lo que nos da el siguiente resultado:


00:02.0 VGA compatible controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
Subsystem: Dell Device 022f
Flags: bus master, fast devsel, latency 0, IRQ 2297
Memory at fea00000 (64-bit, non-prefetchable) [size=1M]
Memory at e0000000 (64-bit, prefetchable) [size=256M]
I/O ports at eff8 [size=8]
Capabilities:
Kernel modules: intelfb


Para más información sobre este comando, simplemente vean el manual, tiene muchas funciones interesantes


$ man lspci


Gracias a nixCraft (http://www.cyberciti.biz/faq/howto-find-linux-vga-video-card-ram/)

RouterBoard es una plataforma de hardware fabircada por Mikrotik, los productos RouterBoard en general vienen equipados con el sistema operativo RouterOS y existen modelos muy variados adaptados para cada situación particular. En este caso puntual tenemos un modelo RB433uah bastante nuevo con características que lo hacen interesantes para un uso bastante variado.
Tratándose de hardware no convencional y con características un tanto particulares donde la instalación no se hace de la manera que conocemos habitualmente llevada a cabo en una Pc, lo cual no significa que no haya una distribución de Linux que pueda correr en dicho hardware, al contrario, muchos modelos comerciales, no esta marca, ya lo traen instalado y soportado oficialmente. En este caso instalamos la distribución Openwrt especialmente preparada para routers y trae entre sus profiles la posibilidad de elegir compilaciones para arquitectura Mips, que es nuestro caso.
Habiendo documentación suficiente acerca de los pormenores de la instalación de Openwrt, a propósito bastante atípica por su oprientación específica hacia routers y hardware embedded, vamos a fijarnos sólo en lo que a las particularidades que la placa Mikrotik Rb433uah nos presenta y no será suficiente para realizar una instalación sin experiencia previa. No obstante puede tomarse la guía del link mencionado mas adelante, por ejemplo, para complementar y adaptarla a este modelo.
Tomando como punto de partida este post y esta serie de consejos y experiencias para instalar Linux OpenWrt en la placa Mikrotik RB433UAH. Aunque aparentemente similares, internamente la rb433uah está mas emparentada con el modelo RB450 que con las 433 anteriores. Y a pesar de no estar en la lista oficial de Harware soportado, aplicando una serie de parches, se puede hacer funcionar y darle una utilidad, sobre todo para aquellos que no simpatizan con RouterOs preinstalado y licenciado por defecto al comprarla.

Como se puede ver el Router RB433uah es una poderosísima placa con procesador Mips de 680Mhz con overlock hasta 800Mhz, 128Mb de RAM y almacenamiento NAND Flash de 512 Mb. Con un plus de 2 puertos USB lo cual expande enormemente sus posbilidades de uso. Además equipada claro de 3 slots minipci y 3 ethernets.

Para este momento en particular se usa el development branch de openwrt:

 svn co svn://svn.openwrt.org/openwrt/packages/

actualmente con kernel 2.6.30

Como primera medida habrá que agregar el modelo a la lista de placas soportadas, lo cual nos permitirá bootear de la misma via tftpboot y reconocer el almacenamiento NAND Flash de 512Mb donde alojar permanentemente la instalación.

Primero parchar los archivos mach-rb-4xx.c, prom.c y ar71xx.h:

Index: target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h
===================================================================
--- target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h (working copy)
@@ -124,7 +124,9 @@
AR71XX_MACH_AW_NR580, /* AzureWave AW-NR580 */
AR71XX_MACH_RB_411, /* MikroTik RouterBOARD 411/411A/411AH */
AR71XX_MACH_RB_433, /* MikroTik RouterBOARD 433/433AH */
+ AR71XX_MACH_RB_433U, /* MikroTik RouterBOARD 433/433UAH */
AR71XX_MACH_RB_450, /* MikroTik RouterBOARD 450 */
+ AR71XX_MACH_RB_450G, /* MikroTik RouterBOARD 450G */
AR71XX_MACH_RB_493, /* Mikrotik RouterBOARD 493/493AH */
AR71XX_MACH_PB42, /* Atheros PB42 */
AR71XX_MACH_PB44, /* Atheros PB44 */
Index: target/linux/ar71xx/files/arch/mips/ar71xx/prom.c
===================================================================
--- target/linux/ar71xx/files/arch/mips/ar71xx/prom.c (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/ar71xx/prom.c (working copy)
@@ -39,10 +39,16 @@
.name = "433",
.mach_type = AR71XX_MACH_RB_433,
}, {
- .name = "450",
+ .name = "433U",
+ .mach_type = AR71XX_MACH_RB_433U,
+ }, {
+ .name = "450",
.mach_type = AR71XX_MACH_RB_450,
}, {
- .name = "493",
+ .+ .mach_type = AR71XX_MACH_RB_450G,
+ }, {
+ .name = "493",
.mach_type = AR71XX_MACH_RB_493,
}, {
.name = "AP81",
Index: target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c
===================================================================
--- target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c (working copy)
@@ -72,7 +72,7 @@
}
};

-#if 0
+#if 0
/*
* SPI device support is experimental
*/
@@ -84,7 +84,8 @@
{
.bus_num = 0,
.chip_select = 0,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 33000000,
+ .mode = SPI_MODE_0,
.modalias = "m25p80",
.platform_data = &rb4xx_flash_data,
}
@@ -98,13 +99,15 @@
{
.bus_num = 0,
= "450G",
.chip_select = 0,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 33000000,
+ .mode = SPI_MODE_0,
.modalias = "m25p80",
- .platform_data = &rb433_flash_data,
+ .platform_data = &rb4xx_flash_data,
}, {
.bus_num = 0,
.chip_select = 2,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 10000000,
+ .mode = SPI_MODE_0,
.modalias = "mmc_spi",
.platform_data = &rb433_mmc_data,
}
@@ -113,7 +116,6 @@
static u32 rb433_spi_get_ioc_base(u8 chip_select, int cs_high, int is_on)
{
u32 ret;
-
if (is_on == AR71XX_SPI_CS_INACTIVE) {
ret = SPI_IOC_CS0 | SPI_IOC_CS1;
} else {
@@ -205,7 +207,31 @@
}

MIPS_MACHINE(AR71XX_MACH_RB_433, "MikroTik RouterBOARD 433/AH", rb433_setup);
+static void __init rb433u_setup(void)
+{
+ rb4xx_generic_setup();
+ rb433_add_device_spi();

+ ar71xx_add_device_mdio(0xffffffe9);
+
+ ar71xx_eth0_data.phy_if_mode = PHY_INTERFACE_MODE_MII;
+ ar71xx_eth0_data.phy_mask = 0x00000006;
+ ar71xx_eth0_data.speed = SPEED_100;
+ ar71xx_eth0_data.duplex = DUPLEX_FULL;
+
+ ar71xx_eth1_data.phy_if_mode = PHY_INTERFACE_MODE_RMII;
+ ar71xx_eth1_data.phy_mask = 0x00000010;
+
+ ar71xx_add_device_eth(1);
+ ar71xx_add_device_eth(0);
+
+ ar71xx_add_device_usb();
+
+ ar71xx_pci_init(ARRAY_SIZE(rb4xx_pci_irqs), rb4xx_pci_irqs);
+}
+
+MIPS_MACHINE(AR71XX_MACH_RB_433U, "MikroTik RouterBOARD 433UAH", rb433u_setup);
+
static void __init rb450_setup(void)
{
rb4xx_generic_setup();
@@ -226,7 +252,27 @@
}

MIPS_MACHINE(AR71XX_MACH_RB_450, "MikroTik RouterBOARD 450", rb450_setup);
+static void __init rb450g_setup(void)
+{
+ rb4xx_generic_setup();
+ rb4xx_add_device_spi();

+ ar71xx_add_device_mdio(0xffffffe0);
+
+ ar71xx_eth0_data.phy_if_mode = PHY_INTERFACE_MODE_MII;
+ ar71xx_eth0_data.phy_mask = 0x0000000f;
+ ar71xx_eth0_data.speed = SPEED_1000;
+ ar71xx_eth0_data.duplex = DUPLEX_FULL;
+
+ ar71xx_eth1_data.phy_if_mode = PHY_INTERFACE_MODE_RMII;
+ ar71xx_eth1_data.phy_mask = 0x00000010;
+
+ ar71xx_add_device_eth(1);
+ ar71xx_add_device_eth(0);
+}
+
+MIPS_MACHINE(AR71XX_MACH_RB_450G, "MikroTik RouterBOARD 450G", rb450g_setup);
+
static void __init rb493_setup(void)
{
rb4xx_generic_setup();

Una vez aplicado arrancamos via tftpboot, previamente formateamos la memoria flash NAND desde la Bios:

comprobamos si la memoria fue detectada correctamente:

$ cat /proc/mtd
dev: size erasesize name
mtd0: 00040000 00040000 "booter"
mtd1: 003c0000 00040000 "kernel"
mtd2: 1fc00000 00040000 "rootfs"

mtd0 partición booter no nos interesa, mtd1 partición donde se guarda el kernel y finalmente partición mtd2 para filesystem raiz.

montamos la partición para el kernel:

root@OpenWrt:/# mount /dev/mtdblock1 /mnt/
yaffs: dev is 32505857 name is "mtdblock1"
yaffs: passed flags ""
yaffs: Attempting MTD mount on 31.1, "mtdblock1"
yaffs: auto selecting yaffs2
yaffs_read_super: isCheckpointed 0

root@OpenWrt:/# ls /mnt/
lost+found

root@OpenWrt:/# df -h
Filesystem Size Used Available Use% Mounted on
tmpfs 62.1M 52.0K 62.1M 0% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/mtdblock1 3.8M 2.3M 1.5M 60% /mnt

root@OpenWrt:/# find /mnt/
/mnt/
/mnt/lost+found

Aparentemente por un problema con el driver del soporte mtd la partición de 4mb aparece con 60% de espacio ocupado a pesar de estar literalmente vacía.
Nuestra imagen elf del kernel generalmente tendrá 2,5 Mb o más y no habrá manera de copiarla aquí.

la partición raiz se ve similar:

root@OpenWrt:/# df -h
Filesystem Size Used Available Use% Mounted on
tmpfs 62.1M 40.0K 62.1M 0% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/mtdblock1 3.8M 2.3M 1.5M 60% /mnt
/dev/mtdblock2 508.0M 2.3M 505.8M 0% /tmp/rootfs

Se necesitará extender mientras tanto la partición kernel de tal forma que sea posible ubicar nuestra imagen elf creada para tal fin.
En la mayoría de los sistemas embebidos (http://www.ssiembedded.com/embedded_linux_managing_memory.html), los dispositivos flash se usan directamente sin tabla de particiones, como otras memorias tales como las CF, que emulan discos duros. El driver de mapeo MTD provee funciones para leer/escribir en la memoria flash y aquí es donde se especifica una estructura de partición harcodeada. Vemos a continuación una porción del archivo rb4xx_nand.c que nos interesa:

Archivo trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c:

static struct mtd_partition rb4xx_nand_partitions[] = {
{
.name   = "booter",
.offset = 0,
.size   = (256 * 1024),
.mask_flags = MTD_WRITEABLE,
},
{
.name   = "kernel",
.offset = (256 * 1024),
.size   = (4 * 1024 * 1024) - (256 * 1024),
},
{
.name   = "rootfs",
.offset = MTDPART_OFS_NXTBLK,
.size   = MTDPART_SIZ_FULL,
},
};

incrementamos el tamaño de la partición kernel a 8mb con el siguiente parche:

Index: trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c
===================================================================
--- trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c (revision 16778)
+++ trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c (working copy)
@@ -92,7 +92,7 @@
{
.name = "kernel",
.offset = (256 * 1024),
- .size = (4 * 1024 * 1024) - (256 * 1024),
+ .size = (8 * 1024 * 1024) - (256 * 1024),
},
{
.name = "rootfs",

Recompilamos y booteamos Openwrt. Ahora la tabla de particiones se ve un poco diferente:

root@OpenWrt:~# cat /proc/mtd
dev: size erasesize name
mtd0: 00040000 00040000 "booter"
mtd1: 007c0000 00040000 "kernel"
mtd2: 1f800000 00040000 "rootfs"

root@OpenWrt:/# df -h
Filesystem                Size      Used Available Use% Mounted on
tmpfs                    62.1M     40.0K     62.0M   0% /tmp
tmpfs                   512.0K         0    512.0K   0% /dev
/dev/mtdblock1            7.8M      2.3M      5.5M  29% /mnt

Con espacio suficiente para ubicar la imagen elf del kernel openwrt.

Siguiente paso montamos las particiones:

root@OpenWrt:/# mkdir /tmp/kernel
root@OpenWrt:/# mkdir /tmp/rootfs
root@OpenWrt:/# mount /dev/mtdblock1 /tmp/kernel/
root@OpenWrt:/# mount /dev/mtdblock2 /tmp/rootfs

debería verse asi:

root@OpenWrt:/# df -h
Filesystem                Size      Used Available Use% Mounted on
tmpfs                    62.1M     40.0K     62.0M   0% /tmp
tmpfs                   512.0K         0    512.0K   0% /dev
/dev/mtdblock1            7.8M      2.3M      5.5M  29% /tmp/kernel
/dev/mtdblock2          504.0M      2.3M    501.8M   0% /tmp/rootfs

Finalmente compiamos la imagen openwrt-ar71xx-vmlinux.elf del kernel con el nombre “kernel” y desempaquetamos openwrt-ar71xx-rootfs.tgz en rootfs por ej con:

root@OpenWrt:/# tar -xzvf openwrt-ar71xx-rootfs.tgz -C /tmp/rootfs
root@OpenWrt:/# umount /tmp/kernel
root@OpenWrt:/# umount /tmp/rootfs
root@OpenWrt:/# reboot

Tenemos Openwrt completamente funcional.

En abril de 2008 La Fundación Linux publicó un pequeño informe estadístico sobre el desarrollo del kernel. En el mismo se puso de manifiesto una serie de consideraciones acerca del sagrado core usado diariamente por millones de ordenadores en el mundo, tales como : ¿Cuántas líneas de código tiene el kernel?, ¿Cuántas líneas se borraron o cuántas nuevas hay respecto del año anterior?, ¿Quiénes son los sponsors? y otros datos significativos.

Los números entonces eran los siguientes:

- 8.859.683 líneas de código, con un 10% de crecimiento por año 3621 líneas se añaden por día, provocando esto que se anuncie un nuevo release cada 2.7 meses.

- Cada día aproximadamente 1000 desarrolladores de más de 100 corporaciones trabajan en el desarrollo, de estos el 70 por ciento trabajan en empresas reconocidas tales como:IBM, Intel, The Linux Foundation, MIPS Technology, MontaVista, Movial, NetApp, Novell y Red Hat.

Lamentablemente este informe ya está obsoleto, y es por esto que la Fundación Linux publicó un informe en el día de ayer, 19 de agosto del 2009, con nuevos datos en base al kernel 2.6.30, los números son:

- Aproximadamente 1000 desarrolladores de 200 compañías diferentes trabajan en el núcleo, lo que representa un incremento del 10% respecto del 2008. El 70% de las contribuciones viene de desarrolladores Red Hat, IBM, Novell, Intel, Oracle, Fujitsu y otras muchas empresas de menor talla.

- El principal contribuyente individual es David Miller, y la nota particular es que Linus Torvalds ya no se encuentra dentro de los mayores aportantes, pero esto no tiene que sorprender dado el rol administrativo que lleva.

Nunca antes en la historia de la computación ha habido tantas empresas, usuarios y desarrolladores unidos detrás de un mismo proyecto.

El texto completo de ambos informes se encuentra disponible en los siguientes links:

Informe Linux Foundation Marzo 2008

Informe Linux Foundation Agosto 2009

Correcciones: @mariana_cecilia

SSHFS es un desarrollo independente al del paquete openssh que nos permite montar particiones a través de la red de manera segura a través de SSH y se instala como una aplicación separada. En sistemas derivados de Debian podemos instalarlo con apt-get.

sudo apt-get install sshfs

Ahora podemos montar cualquier disco remoto utilizando el siguiente comando:

sshfs nombreusuario@servidor:/ruta/del/directorio /directorio/destino

Un aclaración importante es que si montamos una partición a través de Internet, tenemos que tener en cuenta el proceso extra que requiere el encriptamiento de la comunicación, SSHFS puede ser LENTO si tenemos que trabajar con muchos archivos.

Investigando un poco la API de twitter (http://apiwiki.twitter.com), me di cuenta que es muy sencillo utilizarla desde mi consola con curl (http://curl.haxx.se). Se me ocurren muchas cosas que se pueden realizar  a partir de esto, desde un monitor de procesos hasta un aviso de que prendiste tu linux.

Aca van los ejemplos:

curl --basic --user username:password --data status="Twitter desde mi consola " http://twitter.com/statuses/update.xml

Explicacion de los parametros

1. --basic --user username:password . Usuario y password que usas para twitter

2. --data status="Twitter desde mi consola:D" . Actualizacion de tu estado en twitter.
3. http://twitter.com/statuses/update.xml . Ah no olvidar esto, URL de la API.


Otra opcion puede ser  con Wget  (http://www.gnu.org/software/wget.

Ejemplo

wget --keep-session-cookies --http-user=miusuario --http-password=mipassword --post-data="status=Actualizo con Wget:D" http://twitter.com:80/statuses/update.xml

Todos sabemos que un sistema GNU/Linux es bastante estable y fiable. Pero un ordenador de escritorio con Linux instalado y multitud de aplicaciones, los últimos drivers, programas betas, efectos de escritorio, etc, etc puede ser que alguna vez se nos quede completamente colgado y no responda a ninguna combinación de teclas. Ni siquiera el Ctrl+Alt Barckspace reinicia el entorno gráfico. ¿Qué podemos hacer?. En esta situación lo importante es prevenir daños mayores, sobre todo ocasionados al disco duro y el sistema de archivos. Lo importante es apagar correctamente el ordenador para minimizar los posibles daños.

La secuencia de teclas se denomina SysRq y está implementada en el kernel. Esta secuencia sirve para casos e emergencia en un sistemas Linux que ha dejado de responder.

Pulsa:

Alt+Imprimir pantalla y mientras las mantienes pulsadas debes pulsar estas teclas “R” “S”
“E” “I” “U” y “B” (sin soltar Alt+Imprimir pantalla)

R: devuelve el control al teclado.
S: sincroniza.
E: manda a los procesos la señal term.
I: manda a los procesos la señal kill.
U: desmonta los sistemas de ficheros.
B: reinicia el sistema.

Mientras pulsas las teclas no vas a oír ni ver nada. Parecerá que el sistema sigue colgado, pero no es así. Al poco tiempo el kernel termina todos los procesos, cierra los puertos, librerías , archivos, etc. De esta manera pagar el ordenador es mucho más seguro que desconectarlo directamente de la corriente o dejar el botón de “power” apretado.

fuente: papirux nº 2

Muchas veces en GNU/Linux debemos trabajar con muchas terminales abiertas, si bien emuladores de terminales como gnome-terminal permiten el uso de pestañas resultan incómodas cuando debemos pasar rápidamente entre unas y otras.

Terminator es un emulador de terminales que nos permite organizar de diferentes maneras las terminales dentro de la ventana. Estos son algunos de los comando más útiles, los cuales también son accesibles a través del menú contextual.

• Ctrl-Shift-E: divide la ventana verticalmente.
• Ctrl-Shift-O: divide la ventana horizontalmente.
• Ctrl-Shift-T: crea una nueva pestaña en la ventana de terminator a la que podemos volver a subdividir.
• Ctrl-Shift-P: activa la terminal anterior.
• Ctrl-Shift-N: activa la siguiente vista.
• Ctrl-Shift-W: cierra la vista actualmente activa.
• Ctrl-Shift-Q: sale de terminator.
• F11: pone a terminator en modo pantalla completa.

Otra ventaja es que no tiene barra de menú por lo que al  poner en pantalla completa, realmente llena la pantalla. En la imagen pueden observar a terminator en acción como lo uso habitualmente: la pantalla divida en forma horizontal y luego cada vista en forma vertical.