Quando si programma è importante avere buoni tool di debug e uno dei più importanti tool di debug per i sistemi GNU/Linux è strace.

Con strace è possibile visualizzare le chiamate di sistema che via via un processo fa durante la sua evuluzione; il bello di strace è che il suo lavoro lo fa indipendentemente dal fatto che il programma che si desidera monitorare sia compilato con opzioni di debug o meno! Quindi ogni programma è analizzabile con strace.

Ora, dato che noi vogliamo programmare in C su Android e poiché Android è un sistema GNU/Linux è fondamentale che portiamo questo tool sul nostro sistema (o emulatore) Android!

La toolchain

Nell'articolo «Compilare un programma C per Android» abbiamo visto come utilizzare la toolchain di Android, ma in alcuni casi questo non è pratico; Android infatti non utilizza la glibc ma bionic (una libc non-standard e fatta ad hoc), inoltre il sistema di compilazione, seppur basato su make, è molto personalizzato e di fatto incompatibile con i normali Makefile e/o altri tool standard di compilazione (autoconf & C.).

Tutte queste cose messe assieme possono causare seri problemi al processo di compilazione di un programma che invece compilerebbe senza problemi su di un normale sistema GNU/Linux; per risolvere questo problema la via più veloce è utilizzare una toolchain esterna e compilare il nostro programma in maniera statica in modo da evitare dipendenze da librerie dinamiche che non sarebbero presenti su Android.

Una toolchain già pronta ed utilizzabile per i nostri scopi è quella che il progetto emdebian mette a disposizione per i propri utenti. Vediamo allora come installarla.

Premesso che quanto dirò vale per tutti quei sistemi basati sui tool di gestione di pacchetti DEB (per tutti gli altri rimando alle pagine del progetto), sulla mia Ubuntu ho aggiunto al file /etc/apt/sources.list le seguenti linee:

#
# -- Emdebian sources.list entries
#
# deb http://www.emdebian.org/debian/ unstable main
# deb http://www.emdebian.org/debian/ testing main
deb http://www.emdebian.org/debian/ lenny main

(io ho usato lenny come versione, ma nulla vi vieta di usare unstable o testing)

Quindi aggiorniamo i repository remoti:

$ sudo aptitude update

e poi installaliamo la toolchain che ci interessa:

$ sudo aptitude install gcc-4.3-arm-linux-gnueabi linux-libc-dev-armel-cross

Se tutto è andato bene dovreste ottenere:

$ arm-linux-gnueabi-gcc --version
arm-linux-gnueabi-gcc (Debian 4.3.2-1.1) 4.3.2
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

La compilazione

Ora che abbiamo la toolchain passiamo alla compilazione vera e propria di strace. Scarichiamoci i sorgenti:

$ git clone git://strace.git.sourceforge.net/gitroot/strace/strace
$ cd strace/

Quindi passiamo alla compilazione vera e propria:

$ automake --add-missing
$ configure --build=arm-none-linux-gnueabic --host=arm-none-linux-gnueabi
$ make AM_LDFLAGS=-static
$ arm-none-linux-gnueabi-strip strace

Il penultimo comando serve per dire a make di compilare staticamente strace, mentre con l'ultimo si tolgono tutti quei dati non utili all'esecuzione del programma (il nostro telefonino ha risorse limitate quindi è bene togliere tutto quello che non serve). Ecco allora quello che si ottiene:

$ file strace
strace: ELF 32-bit LSB executable, ARM, version 1 (SYSV), statically linked, for GNU/Linux 2.6.14, stripped

Ok, ora siamo pronti per passare il programma sul nostro dispositivo (io userò ancora l'emulatore creato in questo articolo):

$ adb push strace /data/local/bin/

Quindi entriamo nel dispositivo e proviamolo subito:

$ adb shell
# cd /data/local/bin/
# chmod 777 strace
# ./strace
usage: strace [-CdDffhiqrtttTvVxx] [-a column] [-e expr] ... [-o file]
[-p pid] ... [-s strsize] [-u username] [-E var=val] ...
[command [arg ...]]
or: strace -c [-D] [-e expr] ... [-O overhead] [-S sortby] [-E var=val] ...
[command [arg ...]]
...

Funziona! Ma proviamolo con il programma hello compilato nell'articolo indicato prima:

# ./strace ./hello
execve("./hello", ["./hello"], [/* 10 vars */]) = 0
set_tls(0xb0017900, 0xbe9c5d74, 0, 0x847c, 0xb000f448) = 0
getpid()                                = 215
sigaction(SIGILL, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGABRT, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGBUS, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGFPE, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGSEGV, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGSTKFLT, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
sigaction(SIGPIPE, {0xb0001d45, [], SA_RESTART}, {SIG_DFL, , 0) = 0
getuid32()                              = 0
geteuid32()                             = 0
getgid32()                              = 0
getegid32()                             = 0
...
mprotect(0x40008000, 4096, PROT_READ|PROT_WRITE) = 0
mprotect(0x40008000, 4096, PROT_READ)   = 0
ioctl(1, SNDCTL_TMR_TIMEBASE or TCGETS, {B38400 opost isig icanon echo ...}) = 0
write(1, "insert your name: ", 18insert your name: )      = 18
fstat64(0, {st_mode=S_IFCHR|0600, st_rdev=makedev(136, 0), ...}) = 0
mprotect(0x40008000, 4096, PROT_READ|PROT_WRITE) = 0
mprotect(0x40008000, 4096, PROT_READ)   = 0
ioctl(0, SNDCTL_TMR_TIMEBASE or TCGETS, {B38400 opost isig icanon echo ...}) = 0
read(0,

Come c'era da aspettarsi il programma si ferma sulla scanf().