Guida al cross-compiling con DistCC

1.  Cross-compiling con distcc

Introduzione

distcc è un tool che consente di dividere il fardello della compilazione del software tra diversi computer collegati in rete. Se tutte le macchine collegate utilizzano la stessa toolchain, compilata per la stessa architettura di processore, non è richiesta alcuna configurazione speciale di distcc. Ma che cosa si deve fare se si ha necessità di compilare per un'architettura diversa usando computer differenti? Questa guida mostrerà come configurare distcc in modo da compilare per architetture differenti.

Emergere le utility necessarie

Per prima cosa, è necessario emergere crossdev su tutte le macchine che saranno coinvolte nel processo di compilazione. crossdev è un tool che rende facile la compilazione delle toolchains tra diverse architetture. Fu scritto in origine da Joshua Kinard e riscritto da zero da Mike Frysinger. Il suo utilizzo è molto semplice: crossdev -t sparc, ad esempio, compilerà una cross-toolchain completa rivolta all'architettura Sparc. Questa include binutils, gcc, glibc, e gli headers di linux. Per avere maggiore aiuto, prova ad eseguire crossdev --help. Ovviamente, si dovrà emergere la giusta cross-toolchain su tutte le macchine che aiuteranno la compilazione.

Fatto ciò, è necessario emergere distcc su tutte le macchine che saranno coinvolte nel processo. Questo include la macchina che eseguirà emerge e le macchine con i cross-compilatori. Vedi la guida Gentoo Linux e Distcc per maggiori informazioni su come configurare ed usare distcc.

Note arch-specifiche

Se stai cross-compilando tra differenti sottoarchitetture per Intel x86 (es. i586 e i686), devi comunque compilare una cross-toolchain completa per il CHOST desiderato, altrimenti la compilazione fallirà. Questo perché i586 e i686 sono in realtà CHOST diversi, nonostante siano entrambi considerati "x86." Per favore ricordati di questo quando compili le tue cross-toolchains. Per esempio, se la macchina principale è un i586, significa che si dovranno compilare le cross-toolchains i586 sulle macchine ausiliarie i686.

Configurare distcc per cross-compilare correttamente

Con la configurazione di default di distcc, la cross-compilazione non funzionerà correttamente. Il problema è che molte compilazioni invocano semplicemente gcc anziché il nome completo del compilatore (es. sparc-unknown-linux-gnu-gcc). Quindi, quando la compilazione viene distribuita ad una macchina ausiliaria con distcc, viene invocato il compilatore nativo anziché il tuo cross-compilatore nuovo fiammante.

Fortunatamente, c'è una soluzione per questo piccolo problema. Tutto ciò che serve è un wrapper script e alcuni symlinks sulla macchina che eseguirà emerge. Userò la mia macchina Sparc come esempio. Ogni volta che vedi sparc-unknown-linux-gnu qui sotto, devi inserire il tuo CHOST (x86_64-pc-linux-gnu per una macchina AMD64, ad esempio). Quando si emerge distcc per la prima volta, la directory /usr/lib/distcc/bin appare così:

# cd /usr/lib/distcc/bin
# ls -l
total 0
lrwxrwxrwx  1 root root 15 Dec 23 20:13 c++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 cc -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 g++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 gcc -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 sparc-unknown-linux-gnu-c++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 sparc-unknown-linux-gnu-g++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Dec 23 20:13 sparc-unknown-linux-gnu-gcc -> /usr/bin/distcc

Ecco cosa devi fare:

# rm c++ g++ gcc cc

Fatto ciò, creeremo il nuovo script su questa macchina. Avvia il tuo editor preferito e crea un file con il seguente testo, poi salvalo come sparc-unknown-linux-gnu-wrapper. Ricordati di sostituire il CHOST (in questo caso, sparc-unknown-linux-gnu) con il vero CHOST della macchina che eseguirà emerge.

#!/bin/bash
exec /usr/lib/distcc/bin/sparc-unknown-linux-gnu-g${0:$[-2]} "$@"

Fatto ciò, renderemo eseguibile lo script e creeremo i necessari symlinks:

# chmod a+x sparc-unknown-linux-gnu-wrapper
# ln -s sparc-unknown-linux-gnu-wrapper cc
# ln -s sparc-unknown-linux-gnu-wrapper gcc
# ln -s sparc-unknown-linux-gnu-wrapper g++
# ln -s sparc-unknown-linux-gnu-wrapper c++

Fatto ciò, /usr/lib/distcc/bin apparirà così:

# ls -l
total 4
lrwxrwxrwx  1 root root 25 Jan 18 14:20 c++ -> sparc-unknown-linux-gnu-wrapper
lrwxrwxrwx  1 root root 25 Jan 18 14:20 cc -> sparc-unknown-linux-gnu-wrapper
lrwxrwxrwx  1 root root 25 Jan 18 14:20 g++ -> sparc-unknown-linux-gnu-wrapper
lrwxrwxrwx  1 root root 25 Jan 18 14:20 gcc -> sparc-unknown-linux-gnu-wrapper
lrwxrwxrwx  1 root root 15 Nov 21 10:42 sparc-unknown-linux-gnu-c++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Nov 21 10:42 sparc-unknown-linux-gnu-g++ -> /usr/bin/distcc
lrwxrwxrwx  1 root root 15 Jul 27 10:52 sparc-unknown-linux-gnu-gcc -> /usr/bin/distcc
-rwxr-xr-x  1 root root 70 Jan 18 14:20 sparc-unknown-linux-gnu-wrapper

Congratulazioni; adesso hai (speriamo) una configurazione cross-distcc funzionante.

Come funziona

Quando distcc viene eseguito, esso controlla se è invocato come i686-pc-linux-gnu-gcc, sparc-unknown-linux-gnu-g++, etc. Quando distcc poi distribuisce la compilazione a una macchina ausiliaria, gli passa il nome con cui è stato invocato. Il demone distcc sulla macchina ausiliaria cerca poi sulla macchina stessa un binario con lo stesso nome. Se riceve solo gcc, cercherà gcc, che sarà probabilmente il compilatore nativo sulla macchina ausiliaria, se non ha la stessa architettura della macchina che ha eseguito emerge. Quando viene inviato il nome completo del compilatore (es. sparc-unknown-linux-gnu-gcc), non può esserci confusione.

I contenuti di questo documento sono rilasciati sotto la licenza Creative Commons - Attribution / Share Alike.