Lekcja 01- Przygotowanie środowiska

Wstęp

W tej lekcji przygotujemy sobie środowisko pracy czyli:

1. Pobierzemy toolchain
2. Przygotujemy kartę uSD(dla osób używających BBB i RPi4)
3. Skompilujemy QEMU

Toolchain

Zacznijmy może od wytłumaczenia czym jest ten toolchain. Najprościej mówiąc jest to zbiór narzędzi potrzebnych do zbudowania oprogramowania czyli jest to po prostu zbiór niezbędnych kompilatorów, linkerów i tego typu programów.

Z pojęciem toolchaina łączy się jeszcze pojęcie cross-kompilacji czyli budowania programu na inną architekturę docelową niż architektura maszyny budującej. Mówiąc obrazowo, gdy standardowo piszesz program np. w C++ i kompilujesz go następnie za pomocą kompilatora g++ wykonujesz proces kompilacji- kompilujesz program na swoim komputerze i na nim go uruchamiasz. Z cross-kompilacją mamy do czynienia gdy ten sam program budujesz na swoim komputerze, a uruchamiasz np. na RPi4.

Ale do rzeczy, musimy mieć jakiś toolchain, którym będziemy mogli zbudować oprogramowanie na interesujące nas platformy. My będziemy używać toolchaina dostarczanego przez Linaro. Pobierz toolchain odpowiedni dla twojej platformy:

# BeagleBone Black
wget https://releases.linaro.org/components/toolchain/binaries/latest-7/arm-linux-gnueabihf/gcc-linaro-7.5.0-2019.12-x86_64_arm-linux-gnueabihf.tar.xz
# QEMU
wget https://releases.linaro.org/components/toolchain/binaries/latest-7/arm-linux-gnueabi/gcc-linaro-7.5.0-2019.12-x86_64_arm-linux-gnueabi.tar.xz
# Raspberry Pi 4 i opcjonalnie QEMU
wget https://releases.linaro.org/components/toolchain/binaries/latest-7/aarch64-linux-gnu/gcc-linaro-7.5.0-2019.12-x86_64_aarch64-linux-gnu.tar.xz

Gdy już pobrałeś interesujący Cię toolchain rozpakuj pobraną paczkę:

tar xf toolchain.tar.xz

Polecam rozpakować toolchain do jakiegoś sensownego miejsca ponieważ będzie on nam później potrzebny.

Następnie musimy dodać lokalizację kompilatorów do zmiennej środowiskowej PATH aby były one łatwo dostępne z każdego miejsca w systemie. Aby to zrobić wywołaj komendę:

export PATH=$PATH:/ścieżka/do/toolchain/bin

Teraz możesz wywołać kompilatory Linaro z jakiegokolwiek miejsca w systemie. Aby ta zmiana zmiennej PATH była stała dodaj ten wpis w pliku ~/.basrc. Jeśli nie dodasz ustawienia zmiennej PATH do tego pliku będziesz musiał ją ustawiać za każdym razem gdy uruchamiasz konsolę.

Przygotowanie karty uSD

Jeśli zamierzasz używać QEMU możesz pominąć tę sekcje.

Bootloader, firmware, kernel czy pliki systemowe Linuksa będą się znajdować na karcie uSD, którą będziemy umieszczać w BBB lub RPi4, przygotujmy więc sobie odpowiednio karty pamięci. Do przygotowania posłużą nam programy parted oraz mkfs. Zanim przejdziesz do operacji na karcie upewnij się, że zgrałeś z niej wszystkie istotne dla Ciebie pliki. Po drugie upewnij się, że wykonujesz wszystkie operacje na karcie uSD, a nie np. na podłączonym do komputera dysku. Karty pamięci są zazwyczaj reprezentowane w systemie przez pliki /dev/mmcblkX gdzie X to liczba naturalna, ewentualnie jeśli używasz czytnika kart SD, który podłącza się do komputera za pomocą USB wtedy może zostać ona wykryta jako /dev/sdX gdzie X to litera z alfabetu. Jeśli masz wątpliwości co do tego jak została twoja karta nazwana w systemie możesz użyć programu dmesg i zobaczyć ostatnie logi po podłączeniu karty.

BeagleBone Black

W przypadku BBB kartę podzielimy na trzy partycje:

1. Pierwsza partycja będzie zawierać bootloader i będzie używała systemu plików FAT32
2. Druga partycja będzie przechowywać kernel i device-tree, będzie używała systemu plików ext4
3. Trzecia partycja będzie zawierała rootfs Linuksa, też będzie używać systemu plików ext4

Aby tak sformatować kartę pamięci wykonaj następujące komendy:

sudo parted --script /dev/kartaSD mklabel msdos \
                      mkpart primary fat32 0% 100MiB \
                      mkpart primary ext4 100MiB 1100MiB \
                      mkpart primary ext4 1100MiB 100% \
                      set 1 boot on

sudo mkfs.vfat /dev/kartaSD1 -n uboot
sudo mkfs.ext4 /dev/kartaSD2 -L kernel
sudo mkfs.ext4 /dev/kartaSD3 -L rootfs

Raspberry Pi 4

W przypadku RPi4 kartę podzielimy na dwie partycje:

1. Pierwsza partycja będzie zawierać firmware, kernel i device-tree, będzie używała systemu plików FAT32
2. Druga partycja będzie przechowywać rootfs i będzie używała systemu plików ext4

Aby tak sformatować kartę pamięci wykonaj następujące komendy:

sudo parted --script /dev/kartaSD mklabel msdos \
                     mkpart primary fat32 0% 1GiB \
                     mkpart primary ext4 1GiB 100% \
                     set 1 boot on
sudo mkfs.vfat /dev/kartaSD1 -n boot
sudo mkfs.ext4 /dev/kartaSD2 -L rootfs

W obu przypadkach za pomocą programu parted stworzyliśmy nową tablicę partycji typu MS-DOS z czego pierwsza partycja jest partycją rozruchową. Za pomocą programów mkfs sformatowaliśmy partycje do odpowiednich formatów i nadaliśmy im etykiety wyjaśniające ich przeznaczenie.

QEMU

Jeśli jesteś bardzo leniwy to możesz pobrać QEMU z repozytoriów np. Ubuntu za pomocą dobrze wszystkim znanej komendy apt install, nie polecam jednak takiego podejścia ponieważ są tam dosyć stare wersje tego oprogramowania.

My przejdziemy tutaj trochę trudniejszą ścieżką, ale będziemy mieli za to niemalże najnowszą wersje QEMU 6.0.0 z bieżącego roku czyli z 2021, która działa znacznie lepiej niż to co jest dostępne w repozytoriach w repozytoriach Ubuntu.

Paczkę z kodem QEMU 6.0.0 możesz pobrać tutaj:

wget https://download.qemu.org/qemu-6.0.0.tar.xz

Po pobraniu rozpakuj paczkę:

tar xf qemu-6.0.0.tar.xz

Przejdź do rozpakowanego katalogu. Zanim zaczniemy budować musimy najpierw uruchomić skrypt configure. Aby nie budować emulatorów dla wszystkich dostępnych architektur podamy skryptowi configure parametr mówiący żeby zbudował emulatory dla ARM, ARM64 oraz x86_64:

./configure –target-list=arm-softmmu,aarch64-softmmu,x86_64-softmmu

Skrypt configure może krzyczeć, że brakuje mu jakiś pakietów, w takim przypadku należy doinstalować brakujący pakiet. Nie będę podawać, które pakiety trzeba doinstalować, niech to będzie Twoje zdanie bojowe 🙂

Gdy już mamy skonfigurowane wszystko możemy przystąpić do budowania QEMU, aby to zrobić wykorzystamy standardową komendę make:

make # tak, bez żadnych parametrów

Kompilacja może chwilę zająć(u mnie trwała prawie 8 i pół minuty) więc możesz pójść sobie zrobić herbatkę, kawkę czy co tam lubisz.

Po zbudowaniu wszystkie wygenerowane pliki znajdują się w katalogu build. Nas z tego katalogu oczywiście interesują emulatory czyli pliki qemu-system-arm, qemu-system-aarch64 oraz qemu-system-x86_64.

Możesz zainstalować QEMU na swoim komputerze za pomocą narzędzia make:

make install

Ale nie musisz tego robić, jak chcesz to możesz uruchamiać pliki z katalogu build.

I dewolaj! Jak to mawiają Francuzi. Masz gotowe środowisko pracy aby zacząć stawiać pierwsze kroki w tworzeniu własnej dystrybucji Linuksa.