Parallella paradumbs: trabajando más cómodo

En el marco del proyecto Forzando Brutalmente MD5 [1] he usado una parallella[2] y aquí comparto algunas notas inconexas que he tomado


Supongamos que seguiste algun instructivo y ya anda.

FileSystem remoto

Para evitar usar el filesystems en compilaciones y otras actividades.

El camino del nfs...

Usando paraubuntu no pude y como no he podido usar linaro...

Desktop

• $ sudo apt-get install nfs-kernel-server
• $ sudo vi /etc/exports
• /var/nfs    192.168.xxx.xxx(rw,sync,no_root_squash,no_subtree_check)
• $ sudo exportfs -a
• $ sudo service nfs-kernel-server start

Client

• $ showmount -e 192.168.xxx.xxx
• Export list for 192.168.xxx.xxx:
• /srv/nfs 192.168.xxx.yyy
• $ sudo mount 192.168.xxx.xxx:/var/nfs /home/parallella/remoto
• mount.nfs: No such device
• $ cat /proc/filesystems | grep nfs
• no output, no support

 links [3]

El camino de SSHfs...

Parallella

• instalar y activar ssh-server
• poner en $PATH lo que necesitás en la parallella

Client

• $ sudo apt-get install sshfs
• $ sshfs "$USER@$HOST:$PATH" $LOCAL_PATH

IP fija, cable cruzado y no depender de DHCP

Modificar la configuración
[/etc$ cat network/interfaces.d/eth0]

auto eth0
#iface eth0 inet dhcp    ; anterior
iface eth0 inet static
address 192.168.1.101
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1
dns-nameservers 192.168.1.1

y para tomar la nueva IP y modo:


$ sudo service networking restart

Monitorear la temperatura

Se puede usar el ztemp.sh en el home de parallella o más lindo

$ git clonehttps://github.com/parallella/parallella-utils.git
$ cd  parallella-utils.git
$ make 

Se puede iniciar en pantalla remota con

$ ssh -X parallella@192.168.1.106 /home/parallella/parallella-utils/xtemp/xtemp

o con x2x.

Como usar la salida hdmi

Según leí, no se puede poner un teclado y mouse a la vez sin usar un hub activo por que no le da la corriente. Además está complicado poner los adaptadores pues los conectores están muy juntos. Además no sé que adaptador poner para USB, pues intuyo que no es el de USB-HOST a.k.a. OTG, si no algo así como "cruzado".

Solución: utilizando x2x agregar el monitor conectado a la parallella al desktop local.

x2x

parallela

$ sudo vi lxdm.conf -> autologin=parallella
$ sudo service lxdm restart
$ sudo apt-get install x2x

desktop

$ ssh -XC parallella@192.168.1.101  x2x -east -to :0.0


Debido a que tengo tres monitores en la desktop, con esta disposición:

+---------+
|         | XXXXXXX
|         +---------+
|                   |
|                   |
|         +---------+
|         | XXXXXXX
+---------+

 
las zonas marcadas con XXX no son accesible con el puntero del mouse, incómodo pero no bloqueante.


Mientras investigaba el asunto me topé con esto, bastante interesante pero no lo probé:

https://unix.stackexchange.com/questions/192206/is-it-possible-to-access-to-the-framebuffer-in-order-to-put-a-pixel-on-the-scree

Tambien hay mención a usar remotamente el frame buffer en http://rayhightower.com/blog/2015/12/08/how-to-run-headless-parallella/, pero no lo probé.

Serial

Viendo la documentación del ejemplo de rpi-camera, recordé que hay una interfaz serial [4]. Parece que si no tiene nada al arrancar queda deshabilitada.

Como no tengo el adaptador ni ganas de conseguirlo, usaré una edu-ciaa-nxp para acceder, uno de estos días.

Con motivo de estar probando como cambiar el bitstream [5], que fue bastante estresante, si le sumamos que no me estaba arrancando, me ví forzado a que fuera uno de estos días.

Tuve mucho pánico, pero tras leer en múltiples fuentes que eran compatibles eléctricamente, no hay ningún misterio:

GND <-> GND
TX -> RX
RX <- TX


Y esto en la EDU-CIAA-NXP funciona bastante ok:

#include "sapi.h"

int main(void){
   char dato[] = { 0x0,0x0 };
   boardConfig();
   uartConfig( UART_232, 115200 );
   uartConfig( UART_USB, 115200 );
   while(1) {
      if ( uartReadByte( UART_USB, (uint8_t * )&dato[0] ) ){
         uartWriteByte( UART_232, dato[0] );
      }
      if(  uartReadByte( UART_232, (uint8_t * )&dato[0] ) ){
         uartWriteByte( UART_USB, dato[0] );
      }
   }
   return 0 ;
}


Luego,

miniterm.py /dev/ttyUSBx 115200

 El único problema es que algún servicio simpático usa colores, nada grave. Ah, tampoco funciona borrar y las flechas, uno de estos dias me voy a encargar.

Listo, ya me encargué, hay que usar screen:

screen /dev/ttyUSBx 115200

Vista completa:

EDU-CIAA-NXP serial a Parallella:

Raspberry PI 2

Y tanto me gustó el serial que aproveché para usarlo con raspberry pi 2 b, ni que fuera tan difícil, no? por qué no lo vengo usando desde hace años?

EDU-CIAA-NXP a Raspberry Pi 2B

Falta echo

Si hace falta arrancar con runlevel 1, según me ha ocurrido, puede no haber echo local. Se puede corregir en la terminal o ejecutando

stty echo
unalias ls

El segundo comando es para evitar los colores y sus caracteres rotos de escape.

Ubuntu 14.04

Lo anterior vale para parabuntu-2016.11.1-headless-z7010.img y ubuntu-15.04-esdk-2016.3-headless-z7010.img, para ubuntu-14.04-headless-z7010-20150130.1.img hay que escarbar un poco más, pues no bien arranca linux deja de funcionar la terminal serial.

Hay dos caminos,  habilitar una terminal según paso a detallar:

Terminal

Primero, si vas a trabajar con la imagen hay que montar la partición root con el script [6], si es con la SD, sólo montarla.

Luego aplicar lo que dice [7]:

Este no: "Configuring inittab (only Dapper and older !)"


Este tampoco: "Configuring upstart (Edgy/Feisty/Jaunty)"

Este si: "Configuring upstart (Karmic and newer)"

Crear /etc/init/ttyS0

# ttyS0 - getty
#
# This service maintains a getty on ttyS0 from the point the system is
# started until it is shut down again.

start on stopped rc RUNLEVEL=[12345]
stop on runlevel [!12345]

respawn
exec /sbin/getty -L 115200 ttyS0 vt102

pero no, no era este el segundo camino, no funciona ni cambiando todas las ttyS0 por ttyPS0.

Device Tree

En [6] explica como modificar las opciones de arranque del kernel:

Uncompile the binary Linux device tree:

sudo apt install device-tree-compiler
cp /media/<username>/boot/devicetree.dtb
dtc -I dtb -O dts -o devicetree.dts devicetree.dtb


Open the devicetree.dts file and add console statement to bootargs:

       chosen {
          bootargs = "console=ttyPS0,115200 root=/dev/mmcblk0p2 rw earlyprintk rootfstype=ext4 rootwait";
          linux,stdout-path = "/amba@0/serial@e0001000";
       };


Compile device tree:

dtc -I dts -O dtb -o devicetree.dtb devicetree.dts
sudo cp devicetre.dtb  /media/<username>/boot
sync

y funciona.

Expandiendo el filesystem

Me agarra un terrible vértigo seguir los pasos de [9], que parece decir que lo hacés en la misma máquina. Por las dudas me llevé la sd a otra e hice el proceso offline.


sudo umount /dev/sdb1
sudo umount /dev/sdb2
sudo fdisk /dev/sdb
d
n
w

Un paso extra:

sudo e2fsck -f /dev/sdb2

sudo resize2fs /dev/sdb2


Y así quedó:

Usando /dev/xdevcfg

Como ya he mencionado en [10], el bistream se puede cargar de dos maneras, copiándolo a la partición de boot o volcándolo a /dev/xdevcfg.

Hay dos tiempos involucrados:

Uno es el tiempo de construcción de bitstream. Suponiendo que ya está el código listo, hacer ./run ... ./build.sh lleva 10 minutos.

Luego hay que montar la SD, copiar el bitstream, desmontar la SD, ponerla en la parallella, iniciarla... 5 minutos más, si no consideramos que por alguna falla aún no diagnosticada (probablemente la fuente), a veces tengo que reiniciarla durante varios minutos hasta que arranca correctamente.

El primer tiempo es inevitable, pero con la disciplina de versionar cada bitstream se ahorra el tiempo si hay que volver atras.

El segundo se puede reducir considerablemente si los bitstreams se van copiando de algún modo a la partición root y de ahí a /dev/xdevcfg:

cat /home/parallella/bistreams/parallella.bit.bin.v3 > /dev/xdevcfg


Acá podemos ver en acción el mismo programa que pone 2 y 3 en las posiciones apropiadas de memoria y obtiene 5 o 6 de otra, según esté el bitstream sumador o el multiplicador:

Transferencias de archivos

Hay tres escenarios:

La red está ok

Usas scp.

runlevel 1

En las pruebas que he hecho, aunque funciona la red no he podido activar sshd. Tengo una tara disciplinaria de seguridad que me impide poner en mi máquina principal un servidor de ssh, pues eso implicaría ingresar mis credenciales desde máquinas en las que no confío. Podría crear un usuario sólo para las transferencias de archivos, pero eso es muy fácil, asi que olvidemos la red...

serial x/y/zmodem

...salvo para instalar lrzsz_0.12.21-7_armhf.deb o equivalente.

Si la red anda,

apt-get install lrzsz

baja ese package y lo instala. Si la red no anda, hay que conseguirlo de algún modo, ponerlo offline en la SD e instalarlo.

El programa de termial moserial entiende xmodem, ymodem y zmodem.

En la terminal ejecutamos

rz

y en el menú "send file" y listo. Por disciplina, le corremos md5sum en ambos lados a ver si coincide.



Cuando ejecutamos rz dice rz waiting to receive.**B0100000023be50
 

Cuando hacemos "send file" elegimos el archivo y muestra el progreso:

 

Finalmente, vemos como coinciden los hashes:

Tarda horrores, pero no requiere intervención así que es mejor que offline.

offline

Por último, cada vez que querés copiar un archivo, apagás la parallella, sacás la SD, la ponés en otra máquina, le copiás lo que querés y así. Obviamente no es el método ideal, pero puede hacer falta al comienzo.

netcat

Ok, no nos olvidemos de la red, pues el serial tarda mucho. Si estamos sin ssh por algún motivo pero sin embargo la red funciona, nos queda netcat.

En la máquina:


netcat 192.168.1.106 1234 < github/oh/src/accelerator/fpga/parallella.bit.bin 


En la parallella:

Archivos cortos

A veces hay archivos cortos que desearíamos editar con vi/pico/lo que quieras, pero por serial no no, no anda.

Lo preparás en la computadora principal y haces algo parecido a lo que hace zmodem, lo transmitís por la conexión serial asi:

• Copiás en el portapapeles el contenido del archivo
• Ingresás en la terminal

cat << EOF > archivo.destino

• Pegás el portapapeles en la terminal.
• Escribís

EOF

• y enter y listo.

Si hubiera alguna linea igual a EOF en el archivo, tendrías que usar otro señalador de fin de archivo.

Combinando con base64 podés transmitir binarios tambien.




[1] http://seguridad-agile.blogspot.com/2018/05/forzando-brutalmente-md5-presentacion.html

[2] https://www.parallella.org

[3] links relativos a NFS

https://www.digitalocean.com/community/tutorials/how-to-set-up-an-nfs-mount-on-ubuntu-14-04

https://www.linuxquestions.org/questions/linux-networking-3/nfs-client-mount-nfs-mount-2-no-such-device-4175610087/

https://parallella.org/forums/viewtopic.php?f=9&t=902

[4] http://www.parallella.org/forums/viewtopic.php?t=1211&p=7552

[5] no publicado aun, se va a llamar Parallella: FPGA


[6] https://seguridad-agile.blogspot.com/p/remover-exif-xxx-while-read-image-echo.html -> Mount partitions inside disk image

[7] https://help.ubuntu.com/community/SerialConsoleHowto

[8] https://parallella.org/forums/viewtopic.php?f=49&t=3289

[9] http://suzannejmatthews.github.io/2015/05/29/setting-up-your-parallella/