Kompletny system dla Cubietruck oparty na Debianie Wheezy

[pancio]

Budowa systemu - wstęp

Ten tutorial oparty jest w znacznej części na Howto ze strony http://linux-sunxi.org na której znajduje się bardziej szczegółowy opis. Zapaleńców odsyłam więc do źródła... Poniżej postaram się przybliżyć proces tworzenia środowiska do kompilacji i stworzenia własnej dystrybucji Linux Debian dla platformy Cubieboard2/Cubietruck.

Ta strona opisuje proces łączenia bootloadera U-Boot, jądra Linux i systemu bazowego (stworzonego np. z pomocą debootstrap-a), tak aby utworzyć system na karcie SD. Do zabawy potrzebny jest nam komputer z system Linux lub wirtualna maszyna np w VirtualBox. Jeśli masz zamiar zainstalować Linuksa na natywnym sprzęcie w maszynie wirtualnej wskazane jest użycie wersji 64-bitową (amd64 lub x86_64), ponieważ niektóre narzędzia Allwinner działają tylko na systemach 64-bitowych. narzędzia te nie są wymagane ale mogą być one użyteczne do odzyskiwania uszkodzonego systemu urządzenia.

Nie będziemy budować całej dystrybucji, tylko stworzymy bootloader U-Boot, skompilujemy jądro i kilka narzędzi, a następnie użyjemy istniejącego rootfs. W zależności od wielkości rootfs, możesz użyć karty SD o pojemności 2GB lub większej. A po pomyśnej instalacji systemu możesz przenieść rootfs na dysk twardy (SATS lub SATA SSD) lub pamięć flash by zdecydowanie przyspieszyć działanie systemu.

Pamiętaj! Wszystko co robisz, robisz wyłącznie na własną odpowiedzialność!!!

Założenia:
- system bazowy to Linux MINT 13 (x86_64),
- system docelowy to Debian Wheezy na architekturze armhf dla platformy Cubietruck (Cubieboard3),
- wszystkie operacje wykonywane są w katalogu domowym użytkownika, w tym konkretnym przypadku: /home/pancio,
- wszystkie operacje wykonywane są z uprawnieniami zwykłego użytkownika (oprócz instalacji wymaganych pakietów),
- urządzenie blokowe dla karty SD to /dev/mmcblk0 - jeśli w Twoim systemie jest inne uwzględnij to w wykonywanych skryptach,
- partycje na karcie SD to odpowiednio: /dev/mmcblk0p1 i /dev/mmcblk0p2
- wersja bootloadera u-boot v2013.07.



Przygotowanie do kompilacji - pobieranie toolchain-a

Toolchain to zestaw plików binarnych, bibliotek systemowych i narzędzi, które pozwalają na budowę (w naszym przypadku, cross-kompilacjię) bootloadera U-Boot i jądra dla platformy docelowej. Opis dotyczy kompilacji na komputerze z Linux MINT 13 i wszystkie wymagane narzędzia pochodzą z tej właśnie dystrybucji. Nic nie stoi jednak na przeszkodzie by użyć natywnego systemu Debian (różnice w instalacji toolchain-a można znaleźć na stronie SUNXI).

Dla systemu Mint 13 lub Ubuntu można zainstalować toolchain bezpośrednio z dystrybucji:

Code: Select all

sudo apt-get update
sudo apt-get install gcc-arm-linux-gnueabi
sudo apt-get install gcc-arm-linux-gnueabihf
sudo apt-get install linux-libc-dev-armhf-cross

Powyższe polecenia powinny zainstalować środowisko kompilatora i cross-kompilatora wraz z wymaganymi zależnościami.

Do kompilacji u-boot i tworzenia systemu plików rootfs wymagane będą pakiety:

Code: Select all

apt-get install build-essential git debootstrap u-boot-tools
apt-get install libusb-1.0-0-dev
apt-get install pkg-config-arm-linux-gnueabihf

Może się zdarzyć, że wymagane będą inne pakiety ale prawdopodobnie masz je już zainstalowane... ja doinstalowałem jeszcze:

Code: Select all

qemu-common
qemu-keymaps
qemu-kvm
qemu-system
qemu-user
qemu-utils

pakiety te pozwolą później na pracę w środowisku chroot architektury ARM (przy tworzeniu rootfs).



Kompilacja bootloadera U-Boot

Opracowany przez Toma Cubie, obecnie utrzymywany przez Henrika Nordström bootloader U-Boot występuje w dwóch gałęziach: jedna z wykorzystaniem pamięci NAND dla Androida (boot.img, fastboot) a druga wspiera karty MMC-SD i Linuxa. Szczegółowe informacje można znaleźć na Linux-sunxi U-Boot wiki.

Pobieranie u-boot z repozytorium git-a:

Code: Select all

git clone https://github.com/linux-sunxi/u-boot-sunxi.git

Przejdź do katalogu projektu. W trzecim poleceniu poniżej nazwa Cubietruck wskazuje na platformę dla której kompilujemy u-boot. Pełna lista obsługiwanych platform znajduje się w pliku u-boot-sunxi/boards.cfg lub na stronie https://github.com/linux-sunxi/u-boot-s ... s.cfg#L347

Code: Select all

cd u-boot-sunxi
make distclean CROSS_COMPILE=arm-linux-gnueabihf-
make CROSS_COMPILE=arm-linux-gnueabihf- Cubietruck_config 
make CROSS_COMPILE=arm-linux-gnueabihf- 

Po zakończeniu kompilacji znajdziesz skompilowane pliki, potrzebne później do uruchomienia systemu w katalogu u-boot-sunxi/spl :

Code: Select all

cd spl
ls
...
u-boot-spl.bin
u-boot.bin
u-boot-sunxi-with-spl.bin

Budowanie script.bin

Pobierz aktualne narzędzia z repozytorium git-a:

Code: Select all

git clone git://github.com/linux-sunxi/sunxi-tools.git
git clone git://github.com/linux-sunxi/sunxi-boards.git

wejdź do katalogu sunxi-tools i uruchom kompilację narzedzia:

Code: Select all

make fex2bin

Następnie wejdź do katalogu sunxi-boards/sys_config/a20 i w drzewie plików odnajdź plik cubietruck.fex. Wyedytuj go i znajdź sekcję:

Code: Select all

[dynamic]
MAC = "000000000000"

zmień wpis MAC by jednoznacznie oznaczyć twoja platformę i zapisz go. Jeśli nie znajdziesz powyższej sekcji po prostu dopisz ją na końcu pliku. Więcej informacji znajdziesz na stronie EMAC

Teraz stwórzmy plik script.bin:

Code: Select all

../../../sunxi-tools/fex2bin cubietruck.fex script.bin

będzie on później potrzebny przy instalacji bootloadera u-boot.


Kompilacja jądra i modułów

Pobieranie aktualnego drzewa jadra z repozytorium git-a:

Code: Select all

git clone -b sunxi-3.4 https://github.com/linux-sunxi/linux-sunxi.git

Konfiguracja jadra pod konkretną platformę (tu A20 - sun7i_defconfig):

Code: Select all

cd linux-sunxi
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- sun7i_defconfig

Konfiguracja co ma zostać skompilowane:

Code: Select all

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig

może okazać się konieczne doinstalowanie libncurses:

Code: Select all

apt-get install libncurses5-dev

i właściwa kompilacja jądra i modułów(-jX określa ile rdzeni procesora przydzielasz procesowi kompilacji):

Code: Select all

make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- uImage modules

oraz budowanie drzewa modułów:

Code: Select all

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- INSTALL_MOD_PATH=output modules_install

skompilowane jądro znajduje się w katalogu: arch/arm/boot/uImage a moduły w output/lib/modules/3.4.XXX/


Przygotowanie systemu - rootfs

Zdecydowałem się na stworzenie systemu z wykorzystaniem pakietu debootstrap ze względu na prostotę instalacji dowolnej dystrybucji z wykorzystaniem systemu gospodarza (w naszym wypadku wymagana platforma to armhf). W katalogu domowym zakładamy folder debootstrap/cubietruck/wheezy. Pomocne będą polecenia skryptu:

Code: Select all

#zmienne środowiskowe wykorzystywane w dalszej części tutoriala
export card=/dev/mmcblk0
export p=p
export cardboot=/dev/mmcblk0p1
export cardroot=/dev/mmcblk0p2
export distro=wheezy
export distropath="/home/pancio/debootstrap/cubietruck/wheezy"

pobieranie dystrybucji w architekturze armhf

Code: Select all

#pobieranie $distro w architekturze armhf
debootstrap --arch=armhf --foreign $distro $distropath

#kopiowanie pliku wymaganego do operacji w chroot na architekturze armhf
cp /usr/bin/qemu-arm-static $distropath/usr/bin/

mount -t proc none $distropath/proc
mount -o bind /dev $distropath/dev
 

zmieniamy środowisko na docelowe:

Code: Select all

chroot $distropath

#druga faza instalacji oprogramowania
/debootstrap/debootstrap --second-stage
[/code]

Będąc w chroot możemy dodatkowo doinstalować potrzebne nam oprogramowania (lepiej zrobić to teraz niż później na karcie SD, gdyż na karcie ta operacja trwa o wiele dłużej). Na początek dodajmy źródła oprogramowania do apt-a:

Code: Select all

# for Debian
cat <<EOT > etc/apt/sources.list
deb http://http.debian.net/debian wheezy main contrib non-free
deb-src http://http.debian.net/debian wheezy main contrib non-free
deb http://http.debian.net/debian wheezy-updates main contrib non-free
deb-src http://http.debian.net/debian wheezy-updates main contrib non-free
deb http://security.debian.org/debian-security wheezy/updates main contrib non-free
deb-src http://security.debian.org/debian-security wheezy/updates main contrib non-free
EOT

Code: Select all

# apt
cat <<END > /etc/apt/apt.conf.d/71-no-recommends
APT::Install-Recommends "0";
APT::Install-Suggests "0";
END

Konfiguracja DNS-a:

Code: Select all

# resolv.conf
cat <<END > /etc/resolv.conf
nameserver 8.8.8.8
END

Konfiguracja fstab (w zależności od ilości partycji - tu 2 partycje na SD - vfat i ext4:

Code: Select all

cat <<EOT >> /etc/fstab
none    /tmp    tmpfs   defaults,noatime,mode=1777 0 0
/dev/mmcblk0p1      /boot   vfat defaults 0 0
/dev/mmcblk0p2      /   ext4 defaults 0 1
EOT

Teraz możemy doinstalować potrzebne nam pakiety:

Code: Select all

export LANG=C
apt-get update
apt-get install locales
dpkg-reconfigure locales
export LANG=en_US.UTF-8
apt-get install vim mc
... 

oraz ustawiamy nazwę systemu hasło root-a oraz włączamy konsolę:

Code: Select all

echo cubietruck > /etc/hostname
echo T0:2345:respawn:/sbin/getty -L ttyS0 115200 vt100 >> etc/inittab
passwd

opuść tryb chroot:

Code: Select all

exit

Skopiuj skompilowane wcześniej moduły jądra do naszego systemu:

Code: Select all

mkdir -p $distropath/lib/modules
rm -rf /mnt/lib/modules/
cp -r /home/pancio/linux-sunxi/output/lib/modules/output/lib $distropath/lib/modules/

Jesteśmy gotowi do przeniesienia systemu na karte SD ...



Instalacja bootloadera u-boot, tworzenie partycji na karcie SD i kopiowanie systemu plików rootfs

Podłącz kartę SD, upewnij się jakie pliki odwzorowują dostęp do urządzeń blokowych (kilka ostatnich linii polecenia dmesg). Dzięki wcześniejszemu użyciu skryptu z części "Przygotowanie systemu - rootfs" powinniśmy mieć dostępne takie zmienne jak: card, p, distro, distropath i cardroot. Uprości to nieco instalacje systemu na karcie SD.

Czyszczenie karty SD pod bootloader:

Code: Select all

dd if=/dev/zero of=${card} bs=1M count=1

Instalacja bootloadera (ścieżka: /home/pancio/u-boot-sunxi/):

Code: Select all

dd if=u-boot-sunxi-with-spl.bin of=${card} bs=1024 seek=8

Partycjonowanie karty SD (dwie partycje):

Code: Select all

sfdisk -R ${card}
cat <<EOT | sfdisk --in-order -uM ${card}
1,16,c
,,L
EOT

Tworzenie systemu plików na karcie SD:

Code: Select all

mkfs.vfat ${cardboot}
mkfs.ext4 ${cardroot}

Kopiowanie jadra na partycję boot:

Code: Select all

mount ${cardboot} /mnt/
cp /home/pancio/linux-sunxi/arch/arm/boot/uImage /mnt/
cp /home/pancio/sunxi-boards/sys_config/a20/script.bin /mnt/
sync
umount /mnt/

Kopiowanie systemu plików rootfs na kartę SD:

Code: Select all

mount ${cardroot} /mnt/
cp $distropath /mnt/
sync
umount /mnt/

Boot!
Odmontuj kartę SD i uruchom system w Cubietruck. Po zalogowaniu do nowego systemu warto wyedytować plik /etc/network/interfaces w celu automatycznego uruchomienia karty sieciowej...