2005.02_Scratchbox–narzędzie do kompilacji skrośnej_[Programowanie].pdf

narzędzia deweloperskie

Scratchbox

– narzędzie

do kompilacji skrośnej

Veli Mankinen

komputeryzacji i oprogra-

mowania, można zauwa-

żyć, że kompilacja skro-

śna jest wynalazkiem względnie nowym.

We wczesnych latach rozwoju informaty-

ki nie była ona w ogóle potrzebna, ponie-

waż programy były pisane na konkretny

sprzęt i w ściśle określonym celu. Z tego

powodu powtórne użycie tego samego

kodu nie było w obszarze zainteresowań

programistów.

Ponieważ dzisiejsze procesory mają

bardzo różną moc obliczeniową, to

w wielu przypadkach kompilacja aplika-

cji na innym, bardziej wydajnym kompu-

terze, zajmuje znacznie mniej czasu niż

kompilacja na sprzęcie, który jest bezpo-

średnim odbiorcą danego oprogramowa-

nia. W ten sposób narodziła się idea kom-

pilacji skrośnej (ang. cross-compiling ).

i z tego powodu nie może być uznawa-

ny za właściwy. Na Rysunku 1 znajduje

się wykres pokazujący różnice w czasach

kompilacji pomiędzy kompilacją natyw-

na a skrośną. Docelowy komputer z pro-

cesorem ARM posiadał następującą kon-

figurację: procesor Intel SA110 233 MHz,

dysk twardy 40 GB, 256 MB pamięci

RAM oraz Debian Sarge z jądrem Linuksa

2.4.25. Wykorzystana platforma do kom-

pilacji skrośnej miała następujące para-

metry: procesor Intel Xeon CPU 2.80

GHz, dysk twardy 80 GB, 2 GB pamięci

RAM oraz Debian Sarge z jądrem Linuksa

2.6.8-1-686 i Scratchboksem 0.9.8.2.

Narzędzia i urządzenia

Typowe użycie kompilacji skrośnej ma

miejsce wtedy, gdy ktoś chce skompilo-

wać program używany na palmtopie, czy

innym niewielkim komputerku o relatyw-

nie małej mocy obliczeniowej procesora.

Ten artykuł będzie koncentrował się na

tworzeniu oprogramowania pod IPAQ-a ,

a kompilacja będzie realizowana na szyb-

kim komputerze klasy X86 . Największą

korzyść z niego będą miały osoby posia-

dające IPAQ-a albo inny komputer z pro-

cesorem ARM, na którym została zainsta-

lowana jakaś dystrybucja Linuksa.

Osoby posiadające IPAQ-a i zaintere-

sowane uruchomieniem na nim Linuksa,

względnie kompilowaniem na ten kom-

puter programów, powinny zapoznać się

z dystrybucją o nazwie Familiar Linux ,

dostępnej pod adresem www.hand-

shelds.org . Na wspomnianej stronie

zostały też umieszczone bardzo użytecz-

ne podręczniki instalacyjne.

W niniejszym artykule zostanie użyte

narzędzie do kompilacji skrośnej pocho-

dzące z projektu o nazwie Scratchbox . Jest

to środowisko programistyczne do two-

Na płycie CD/DVD

Na płycie CD/DVD znajdują się

narzędzia omawiane w artykule.

Co to jest kompilacja

skrośna?

Podstawowa idea kompilacji skrośnej

polega na użyciu pewnego procesora

(HOST) w celu skompilowania progra-

mu przeznaczonego na procesory mające

inną architekturę (TARGET). Oznacza to,

że komputer kompilujący program nie

może natywnie uruchamiać skompilowa-

nego przez siebie oprogramowania. Jest

to pierwsze wyzwanie stojące przez kom-

pilacją skrośną, gdyż wiele środowisk

programistycznych wymaga uruchomie-

nia dodatkowych narzędzi, specyficz-

nych dla docelowej architektury, już pod-

czas kompilacji programu.

Aby uniknąć wspomnianych trudno-

ści, niektórzy ludzie wolą kompilować

programy na docelowej platformie. Jak-

kolwiek na to patrzeć, w wielu przypad-

kach jest to bardzo bardzo wolny proces

O autorze

Autor jest współtwórcą pakietu

Scratchbox. Kontakt z autorem:

veli.mankinen@movial.i

28 luty 2005

G dyby przyjrzeć się historii

scratchbox

narzędzia deweloperskie

#include <stdio.h>

int main(void)

{

printf("Hello World!\n");

return 0;

}

Najpierw skompilujmy "Hello World"

natywnie na X86, aby sprawdzić, jak

działa kompilacja i uzyskać pewne infor-

macje o tworzonych binariach. Załóżmy,

że "Hello World" został zapisany w pliku

o nazwie hello.c . Teraz, w tym samym

katalogu, w którym znajduje się hello.c ,

uruchomimy komendę:

# gcc -Wall -o hello hello.c

Rysunek 1. Porównanie czasów kompilacji przy kompilacji natywnej i skrośnej

W rezultacie nie powinniśmy otrzy-

mać żadnych komunikatów, ale powi-

nien powstać plik binarny hello , który

możemy uruchomić poprzez wpisanie

komendy ./hello . Po wykonaniu tych

działań komputer powinien wyświetlić

napis Hello World! .

Teraz uruchommy komendę file ,

która da nam dostęp do kilku informa-

cji o pliku binarnym: file hello . Powin-

ny one wyglądać podobnie do:

rzenia oprogramowania linuksowego pod

wszystkie dystrybucje Linuksa. Podstawo-

wą ideą Scratchboksa jest zaoferowanie

deweloperom środowiska, które działa i

wygląda jak środowisko docelowe, jesz-

cze zanim środowisko to będzie fizycz-

nie dostępne.

Środowisko Scratchbox zapewnia me-

chanizm logowania identyczny z tym, który

jest stosowany na urządzeniu docelowym.

Narzędzia Scratchboksa mogą być używane

zarówno w tym środowisku, jak i poza

nim. Użycie narzędzi poza środowiskiem

Scratchbox jest takie samo, jak dowolnych

innych narzędzi, które posiada nasz kom-

puter. W takim przypadku jest to zwykłe,

może nawet staromodne, podejście do

kompilacji skrośnej.

Aktualna stabilna wersja Scratchbok-

sa nosi numer 0.9.8.2. Wszystkie pakie-

ty można pobrać ze strony www.scratch-

box.org . Następujące z nich są niezbędne:

scratchbox-core , scratchbox-libs , scratch-

box-devicetools oraz scratchbox-toolcha-

in-arm-glibc . Każdy z nich jest udostęp-

niany w formie pakietów tar.gz , deb oraz

rpm . Możliwy jest wybór dowolnego typu

pakietu.

W przypadku plików tar.gz powinni-

śmy rozpakować je do katalogu / (każdy

z pakietów):

Wykorzystywana przez nas konfiguracja

wymaga około 428 MB wolnego miejsca,

a i tak dodatkowo jest potrzebne trochę

więcej na własne działania. Jeżeli katalog /

nie posiada wystarczającej ilości przestrze-

ni dyskowej, to Scratchbox może być zain-

stalowany w innym miejscu, ale wtedy

niezbędne będzie utworzenie odwołania z

/scratchbox do miejsca docelowego. Reali-

zujemy to za pomocą komendy:

hello: ELF 32-bit LSB executable,

Intel 80386, version 1 (SYSV),

for GNU/Linux 2.2.0, dynamically linked

(uses shared libs), not stripped

Oczywiście, żadna z wyświetlonych

informacji nie odnosi się aktualnie ani do

Scratchboksa, ani do kompilacji skrośnej.

Aby to zmienić, powinniśmy zastosować

kompilator wchodzący w skład pakietu

Scratchbox. Uruchommy komendę:

# ln -s /home/scratchbox /scratchbox

Po rozpakowaniu pakietów musimy jesz-

cze skonfigurować Scratchboksa poprzez

wprowadzenie komendy:

# /scratchbox/compilers/arm-linux S

-gcc-3.3_3.3.4-glibc-2.3.2.ds1/ S

bin/arm-linux-gcc -Wall -o arm-hello hello.c

# /scratchbox/run_me_first.sh

Będziemy musieli udzielić odpowiedzi na

kilka pytań, ale wystarczy, że zaakceptu-

jemy wartości domyślne.

Przechodzimy

do konkretów

Na początek przedstawimy tradycyj-

ne podejście do kompilacji skrośnej

i użyjemy narzędzi Scratchbox w syste-

mie głównym, podobnie jak większości

innych narzędzi. Będziemy potrzebowa-

li niewielkiego fragmentu kodu programu

do kompilacji. To zadanie dobrze spełni

“Hello World”:

Rysunek 2. Praca ze Scratchboksem

odbywa się przede wszystkim w trybie

tekstowym

# tar zxf <nazwa_pakietu> -C /

www.lpmagazine.org

narzędzia deweloperskie

licznych bibliotek i ma skomplikowane

systemy budowania aplikacji. Oznacza

to, że w takiej sytuacji będziemy musie-

li skompilować także biblioteki, a to nie

może odbywać się jednocześnie z kom-

pilowaniem samego programu. Z tego

powodu stosowanie kompilacji skro-

śnej wymaga pieczołowitych ustawień

całego środowiska budującego apli-

kację. Te ustawienia są często trudne

i wymagają dużych nakładów czaso-

wych. Środowisko Scratchbox wykonu-

je większość pracy za nas.

do grupy sbox można sprawdzić za

pomocą polecenia:

# groups

Po zalogowaniu się do Scratchboxa

powinniśmy skonfigurować środowisko

dla potrzeb kompilacji skrośnej:

# sbox-config -ct MYTARGET -cn S

arm-linux-gcc-3.3_3.3.4 S

-glibc-2.3.2.ds1 -cm qemu-arm

Kompilacja skrośna

w Scratchboksie

Scratchbox jest chrootowanym środo-

wiskiem kompilacji skrośnej. Oznacza

to również, że dowolna osoba może

zalogować się do Scratchboksa, tak jak

loguje się na prawdziwym urządzeniu.

W każdym przypadku użytkownicy

muszą zostać dodani do Scratchboksa

przed ich zalogowaniem się (musi to

być użytkownik istniejący w systemie,

ale nie może to być root). Realizujemy

to za pomocą komendy:

Później powinniśmy je aktywować. Reali-

zujemy to poprzez wpisanie komendy:

sbox-config –select-target=MYTARGET

Rysunek 3. Również dla Zaurusa

można tworzyć programy przy pomocy

Scratchboksa

Teraz prompt powinien ulec zmianie na:

[sbox-MYTARGET: ~] > .

W środowisku Scratchbox, w nowym

drzewie /, znajduje się standardowy

zestaw katalogów ( /bin , /sbin , /usr , /var

itd.), ale są one zupełnie puste. Dzięki

temu możliwe jest zainstalowanie dowol-

nego innego oprogramowania w miej-

scu docelowym, bez martwienia się

o możliwość nadpisania programów

komputera głównego. Ponieważ kata-

logi są puste, więc nie mamy rów-

nież biblioteki C, choć jest ona zwykle

wymagana przez komponenty opro-

gramowania. Z tego powodu powin-

niśmy zainstalować lub skompilować

wszystko, czego będziemy potrzebowa-

li w środowisku docelowym. Na szczę-

ście, tzw. toolchain Scratchboksa zawiera

bibliotekę C i możemy ją zwyczajnie sko-

piować poprzez wpisanie komendy:

Jej użycie nie powinno spowodować

wygenerowania żadnych komunika-

tów, ale teraz powinniśmy otrzymać

plik binarny o nazwie arm-hello . Tego

pliku nie da się bezpośrednio urucho-

mić, ponieważ jest on przeznaczony

dla architektury ARM, a znajduje się na

komputerze X86. Jedyne co możemy

zrobić, to zastosować znowu komendę

file , aby przekonać się, że jest to rze-

czywiście plik binarny ARM. Wpisz-

my więc: file arm-hello , co powinno

spowodować wyświetlenie komunika-

tu w stylu:

# /scratchbox/sbin/sbox_adduser nazwa_ S

użytkownika

W celu zalogowania się do systemu

Scratchbox musimy użyć komendy:

/scratchbox/login

Po uruchomieniu tej komendy, powin-

no pojawić się kilku komunikatów

powitalnych, a tzw. prompt systemo-

wy ulegnie zmianie np. na: [sbox-HOST:

~] > . Informuje on, że znajdujemy się

pod zarządem Scratchboksa oraz że

używane jest docelowe środowisko o

nazwie HOST. W Scratchboksie można

użyć wielu środowisk docelowych, co

oznacza, że możemy kompilować pro-

gramy pod różne architektury i usta-

wienia. Warto tu zwrócić uwagę, że

katalog / nie jest tym samym katalo-

giem, co na zewnątrz Scratchboksa,

oraz że będziemy mieli różne katalo-

gi domowe. Ponadto, istotne jest, że

jeśli dany użytkownik zalogował się

do systemu przed dodaniem go jako

użytkownika Scratchboksa, to musi się

przelogować, aby uzyskać przywileje

członkowskie grupy sbox , niezbędne

do uruchomienia omawianego narzę-

dzia deweloperskiego. Przynależność

arm-hello: ELF 32-bit LSB executable,

ARM, version 1 (ARM), for GNU/Linux

2.0.0, dynamically linked

(uses shared libs), not stripped

# sbox-config --copy-clibrary

W ten sposób udało nam się skompilo-

wać skrośnie nasz pierwszy program!

Jeżeli dysponujemy IPAQ-iem lub ekwi-

walentnym urządzeniem z uruchomio-

nym Linuksem, to oczywiście możemy

wypróbować działanie tego progra-

mu. Wystarczy przenieść plik arm-hello

do IPAQ-a, używając komendy scp , a

następnie normalnie uruchomić.

Jeżeli kompilowane fragmenty

kodu są niewielkie (podobnie jak nasz

program), to do wykonania całości

pracy nie potrzebujemy niczego więcej

niż kompilatora obsługującego kompi-

lację skrośną. Wiele programów Open

Source, które można znaleźć, używa

Teraz posiadamy już gotowe środowisko

do kompilowania oprogramowania pod

ARM. Scratchbox jest dostarczany z emu-

latorem QEMU, który będzie używany

w dalszych przykładach. Omawiane na-

rzędzie deweloperskie potrzebuje urzą-

dzenia lub emulatora, który ma moż-

liwość uruchomienia programów dla

docelowej architektury. Dzięki takiej

funkcjonalności możemy mieć środo-

wisko kompilacji skrośnej bez pełnej

wiedzy, zarówno o systemie docelo-

wym, jak i o tym, jak należy tę wiedzę

wbudować w środowisko. Narzędzia

same wyszukają odpowiednie informa-

cje, podobnie jak ma to miejsce podczas

kompilacji natywnej.

luty 2005

scratchbox

narzędzia deweloperskie

Jeżeli ponownie wpiszemy program

"Hello World" i skompilujemy go za

pomocą komendy:

wiście, glib może być kompilowany

także poprzez skonfigurowanie środo-

wiska, ale jest to nieco bardziej skompli-

kowane niż przykład pokazany wyżej.

Dokumentacja o kompilacji skrośnej

glib jest dostępna pod adresem: http://

developer.gnome.org/doc/API/2.0/glib/

glib-cross-compiling.html .

Teraz, gdy w naszym środowisku

mamy już zainstalowane biblioteki C oraz

glib , możemy skompilować nowe "Hello

World", które będzie używało funkcji

print z biblioteki glib . Oto plik glib-hel-

lo.c :

Kompilacja powinna zakończyć się

bez zgłaszania jakichkolwiek błędów,

a jako jej wynik powstanie plik binar-

ny sb-arm-glib-hello . Ponieważ posia-

damy emulator QEMU, więc możemy

go teraz uruchomić, w wyniku czego

powinien pojawić się napis “Hello

World!". Jeżeli teraz wydamy komen-

dę file , to jej wynik powinien być iden-

tyczny jak w poprzedniej wersji pro-

gramu “Hello World!". Jeśli wywołamy

jeszcze komendę ldd , która pokazu-

je wykorzystanie bibliotek, to będzie-

my mogli zobaczyć, że zainstalowana

przed chwilą biblioteka glib jest rze-

czywiście używana ( ldd sb-arm-glib-

hello ):

gcc -Wall -o sb-arm-hello hello.c

to kompilacja powinna przebiec bez

błędów, a jako wynik otrzymamy plik

binarny sb-arm-hello . Po uruchomieniu

komendy:

file sb-arm-hello

otrzymamy komunikat, który pokazuje,

że znowu mamy w swoim ręku rzeczy-

wisty plik binarny ARM:

# include <glib.h>

# include <glib/gprintf.h>

int main(void)

{

g_printf("Hello World!\n");

return 0;

}

sb-arm-hello: ELF 32-bit LSB executable,

ARM, version 1 (ARM), for GNU/Linux

2.0.0, dynamically linked

(uses shared libs), not stripped

libglib-2.0.so.0 => /usr/local/lib/

libglib-2.0.so.0 (0x00000000)

libc.so.6 => /lib/libc.so.6 (0x00000000)

libgcc_s.so.1 => /lib/libgcc_s.so.1 S

(0x00000000)

/lib/ld-linux.so.2 =>

/lib/ld-linux.so.2 (0x00000000)

Ponieważ jesteśmy wewnątrz środowi-

ska Scratchbox, to możemy uruchomić

powstały program w emulatorze poprzez

wpisanie: . /sb-arm-hello . W rezultacie

otrzymamy wynik w postaci napisu Hello

World! .

Scratchbox jest dostarczany z narzędziem

pkg-config , które jest używane w celu

wygodnego wyciągnięcia wszystkich

ścieżek dostępu związanych z biblioteką

glib . Domyślnie, glib instaluje się do /usr/

local/ i do tego samego katalogu są także

instalowane pliki konfiguracyjne pkg-

config . W poniższym przykładzie użyje-

my pkg-config oraz tak ustawimy zmien-

ną środowiskową PKG_CONFIG_PATH,

że narzędzie znajdzie odpowiednie pliki

glib :

W tej chwili możemy już tworzyć pliki

wykonywalne naszych programów i biblio-

tek, a następnie przenosić je na różne

urządzenia oparte o procesor ARM.

Scratchbox zawiera jeszcze wiele

innych rozszerzeń i narzędzi, które

pomagają w tworzeniu oprogramowania,

np. dla Debiana ARM.

Przykład bardziej

skomplikowany

Kolejny przykład będzie wymagał biblio-

teki glib z rodziny GTK+. Najpierw

musimy ściągnąć pakiet glib i skompi-

lować go dla środowiska docelowego za

pomocą następujących komend:

Podsumowanie

Istnieje wiele ciekawych urządzeń, na

których można zainstalować i urucha-

miać Linuksa. Uruchomienie czy skom-

pilowanie naszych ulubionych progra-

mów na te urządzenia może być rzeczy-

wiście trudnym zadaniem. Dzięki odpo-

wiednim narzędziom oraz z pomocą róż-

nych artykułów z czasopism i ze stron

internetowych można spowodować, że

nie będzie to już tak skomplikowane.

A już na pewno jest to bardzo interesują-

ca dziedzina do doświadczeń programi-

stycznych.

# export PKG_CONFIG_PATH=/usr/local/ S

lib/pkgconfig/

> wget ftp://ftp.gtk.org/pub/gtk/v2.2/ S

glib-2.2.3.tar.bz2

> tar -xjvf glib-2.2.3.tar.bz2

> cd glib-2.2.3

> ./configure

> make

> make install

Teraz możemy uruchomić pkg-config

–list-all , co umożliwi nam obejrzenie

bibliotek zainstalowanych w systemie.

W tej chwili powinno to wyświetlić:

Jak można zauważyć, jest to znacz-

nie bardziej złożony przykład. Użyli-

śmy skryptu configure , który kompi-

luje i uruchamia dużo różnych pro-

gramów w celu wyciągnięcia różnych

danych o środowisku. Gdybyśmy użyli

kompilacji skrośnej poza Scratchbok-

sem, wtedy skrypt configure nie ukoń-

czyłby prawidłowo działania, ponieważ

nie mógłby uruchomić programów do

kompilacji. Zerknięcie do pliku /tmp/

cputransp_$USER.log pozwala na uzy-

skanie informacji o komendach, które

były uruchamiane z emulatorem. Oczy-

gmodule-2.0 GModule - Dynamic module

loader for GLib

glib-2.0 GLib - C Utility Library

gobject-2.0 GObject - GLib Type, Object,

Parameter and Signal Library

gthread-2.0 GThread - Thread support

for GLib

W Internecie:

W celu skompilowania nowego "Hello

World" będziemy potrzebowali następu-

jącej komendy:

– Strona domowa projektu Scratchbox:

http://www.scratchbox.org/

– Strona domowa projektu QEMU:

http://fabrice.bellard.free.fr/qemu/

– Strona domowa projektu Handhelds:

http://www.handhelds.org/

# gcc -Wall `pkg-config --cflags S

--libs glib-2.0` -o sb-arm S

-glib-hello glib-hello.c

www.lpmagazine.org

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: