Własny moduł Linux na Raspberry Pi

W tym artykule zajmiemy się przygotowaniem modułu Linux „Hello World” na Raspberry Pi. Przy okazji przejdziemy przez proces kompilacji natywnej oraz kompilacji skrośnej. Jeśli jednak nie czytałeś wcześniej artykułu Programowanie sterowników urządzeń w Linux – jak zacząć?, a dopiero zaczynasz przygodę z programowaniem modułów/sterowników Linux to zacznij od niego.

Kompilacja natywna vs kompilacja skrośna

Jeśli nie słyszałeś wcześniej tych pojęć to może to brzmieć odrobinę groźnie. Jak się jednak zaraz okaże nie ma w tym nic trudnego. Kompilacja natywna to taka, podczas której kod generowany jest na platformę, na której wykonywana jest kompilacja. Najprostszym przykładem będzie kompilacja i uruchomienie programu na swoim komputerze.

W przypadku kompilacji skrośnej, proces budowania wykonywany jest na jednej platformie, ale wygenerowany kod przeznaczony jest do wykonywaniana na innej. Przykładem może być kompilacja kodu na PC, który potem jest wykonywany na mikrokontrolerze. Kompilacja skrośna jest szczególnie często stosowana dla systemów wbudowanych. W przypadku mikrokontrolerów nie mamy nawet możliwości zbudowania na nich kodu.

Na większych systemach wbudowanych, np. Raspberry Pi, często mamy możliwość przeprowadzenia kompilacji natywnej. Dla utrwalenia – w takim wypadku kompilujemy kod na Raspberry i uruchamiamy go na Raspberry. Mimo to, w większości przypadków wykorzystywana jest kompilacja skrośna. Jest to spowodowane tym, że stacja robocza ma po prostu dużo większe zasoby od prostego SBC i taka kompilacja trwa na niej znacznie krócej. W przypadku bardzo prostej aplikacji nie robi to aż tak dużej różnicy, ale już np. kompilacja jądra Linuxa na Raspberry zajęłaby od kilku do kilkunastu godzin, podczas gdy na zwykłym komputerze zajmuje to zazwyczaj kilkanaście minut.

Kompilacja natywna

Zacznijmy od prostszego wariantu, czyli kompilacji natywnej. Będzie to wyglądać niemal identycznie jak w artykule Programowanie sterowników urządzeń w Linux – jak zacząć?. Jedyną różnicą będzie platforma – tam robiliśmy to na desktopie, tutaj użyjemy Raspberry Pi. Większości opisów nie będę tutaj powtarzał dlatego jeśli jeszcze nie czytałeś tego artykułu to zacznij proszę od niego. Zakładam też, że Raspberry nie jest Ci obce i już wcześniej z niego korzystałeś, dlatego pominę tutaj opis platformy, instalacji systemu czy konfiguracji. Jeśli jednak wcześniej nie miałeś z nią do czynienia to myślę, że fajnym miejscem na początek będzie kurs Raspberry Pi kurs od podstaw z forbota. W swojej konfiguracji wykorzystałem system operacyjny Raspberry Pi OS Lite i skonfigurowałem ssh, aby móc wygodnie pracować bez konieczności podłączania UART czy monitora. Należy też pamiętać o zapewnieniu dostępu do internetu.

Kompilacja natywna modułu

Wykorzystamy tutaj ten sam kod modułu i Makefile, który przedstawiałem już we wspomnianym artykule:

#include <linux/module.h>
#include <linux/kernel.h>

static int __init hello_world_init(void)
{
    printk(KERN_INFO "Hello World!\n");
    return 0;
}

static void __exit hello_world_exit(void)
{
    printk(KERN_INFO "Goodbye World!\n");
}

module_init(hello_world_init);
module_exit(hello_world_exit);

MODULE_AUTHOR("EmbeddedDev");
MODULE_DESCRIPTION("Hello World module");
MODULE_LICENSE("GPL");

#include <linux/module.h>

#include <linux/kernel.h>

static int __init hello_world_init(void)

{

printk(KERN_INFO "Hello World!\n");

return 0;

}

static void __exit hello_world_exit(void)

{

printk(KERN_INFO "Goodbye World!\n");

}

module_init(hello_world_init);

module_exit(hello_world_exit);

MODULE_AUTHOR("EmbeddedDev");

MODULE_DESCRIPTION("Hello World module");

MODULE_LICENSE("GPL");

obj-m += hello_world.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

obj-m += hello_world.o

all:

make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:

make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Pierwszym krokiem będzie instalacja kernelowych headerów odpowiadającym wersji kernela. W przypadku raspberry pakiet z headerami nazywa się raspberrypi-kernel-headers:

pi@raspberrypi:~ $ sudo apt install raspberrypi-kernel-headers

1	pi@raspberrypi:~ $ sudo apt install raspberrypi-kernel-headers

Wszystkie niezbędne narzędzia do kompilacji są domyślnie dostępne w systemie, więc nie musimy nic więcej doinstalowywać i możemy od razu przejść do budowania modułu, wywołując make w folderze zawierającym kod źródłowy modułu hello_world.c i Makefile.

pi@raspberrypi:~/hello_world_module $ make
make -C /lib/modules/5.10.63-v7+/build M=/home/pi/hello_world_module modules
make[1]: Entering directory '/usr/src/linux-headers-5.10.63-v7+'
  CC [M]  /home/pi/hello_world_module/hello_world.o
  MODPOST /home/pi/hello_world_module/Module.symvers
  CC [M]  /home/pi/hello_world_module/hello_world.mod.o
  LD [M]  /home/pi/hello_world_module/hello_world.ko
make[1]: Leaving directory '/usr/src/linux-headers-5.10.63-v7+'

pi@raspberrypi:~/hello_world_module $ make

make -C /lib/modules/5.10.63-v7+/build M=/home/pi/hello_world_module modules

make[1]: Entering directory '/usr/src/linux-headers-5.10.63-v7+'

CC [M] /home/pi/hello_world_module/hello_world.o

MODPOST /home/pi/hello_world_module/Module.symvers

CC [M] /home/pi/hello_world_module/hello_world.mod.o

LD [M] /home/pi/hello_world_module/hello_world.ko

make[1]: Leaving directory '/usr/src/linux-headers-5.10.63-v7+'

Jeśli wszystko się powiedzie powinniśmy widzieć plik hello_world.ko.

Uruchomienie modułu

Pozostało już tylko uruchomić moduł. Jak już wiesz, do ładowania i odładowywania modułów korzystamy z narzędzi insmod i rmmod. Sprawdźmy czy wszystko działa jak należy:

pi@raspberrypi:~/hello_world_module $ sudo insmod hello_world.ko
pi@raspberrypi:~/hello_world_module $ sudo rmmod hello_world

1 2	pi@raspberrypi:~/hello_world_module $ sudo insmod hello_world.ko pi@raspberrypi:~/hello_world_module $ sudo rmmod hello_world

Po wykonaniu powyższych operacji w dmesgu powinny pojawić się wiadomości wypisane przez nasz moduł:

pi@raspberrypi:~/hello_world_module $ dmesg | tail
[...]
[ 2396.065931] Hello World!
[ 2425.693961] Goodbye World!

pi@raspberrypi:~/hello_world_module $ dmesg | tail

[...]

[ 2396.065931] Hello World!

[ 2425.693961] Goodbye World!

Jak widzisz, prosta sprawa 🙂 Przejdźmy teraz do kompilacji skrośnej

Kompilacja skrośna

W tej części moduł skompilujemy na komputerze, a potem przeniesiemy i uruchomimy go na Raspberry Pi. Na swojej maszynie mam zainstalowane Ubuntu 20.04, ale na każdej dystrybucji opartej na Debianie powinno to wyglądać tak samo lub bardzo podobnie. W przypadku innych, część komend może się trochę różnić, ale dostosowanie ich nie powinno być kłopotliwe.

Pobieranie kodu jądra

Jak już wiesz, do zbudowania modułu będą nam potrzebne narzędzia do kompilacji oraz headery odpowiadające wersji jądra. Ale uwaga: wersji jądra, do którego moduł będzie ładowany, czyli tego z Raspberry Pi. W moim wypadku jest to 5.10.63:

pi@raspberrypi:~ $ uname -r
5.10.63-v7+

1 2	pi@raspberrypi:~ $ uname -r 5.10.63-v7+

Pamiętaj, że u Ciebie wersja jądra na RPi może być inna. Możliwe, że w momencie kiedy Ty pobrałeś Raspbiana był tam kernel w innej wersji.

Na Ubuntu nie znajdziemy pakietu z headerami kernela wykorzystywanego na Raspberry Pi, dlatego w tym wypadku będziemy potrzebowali całego kodu źródłowego jądra. Możemy go znaleźć w repozytorium github.com/raspberrypi/linux:

lagun@lagun:~/workspace/kernel-development/rpi$ sudo apt install git
lagun@lagun:~/workspace/kernel-development/rpi$ git clone --depth=1 https://github.com/raspberrypi/linux

1 2	lagun@lagun:~/workspace/kernel-development/rpi$ sudo apt install git lagun@lagun:~/workspace/kernel-development/rpi$ git clone --depth=1 https://github.com/raspberrypi/linux

Podczas klonowania można dodać flagę --depth=1. Jej dodanie spowoduje, że sklonowany zostanie wyłącznie aktualnie aktywny branch bez żadnej historii. Nie potrzebujemy całego repo ze wszystkimi branchami i historią, a zaoszczędzi to dużo czasu i miejsca na dysku.

lagun@lagun:~/workspace/kernel-development/rpi/linux$ git branch
* rpi-5.10.y

1 2	lagun@lagun:~/workspace/kernel-development/rpi/linux$ git branch * rpi-5.10.y

Niestety w repozytorium nie ma tagów dla konkretnych wersji jądra. W momencie gdy klonowałem to repozytorium dostępne źródła były dla kernela w wesji 5.10.78:

lagun@lagun:~/workspace/kernel-development/rpi/linux$ make kernelversion
5.10.78

1 2	lagun@lagun:~/workspace/kernel-development/rpi/linux$ make kernelversion 5.10.78

Jak widać wersja różni się od tej, którą mamy na platformie (5.10.63). W związku z tym, jeśli zbudujemy moduł dla wersji 5.10.78 nie będziemy w stanie go załadować. Podczas takiej próby pojawi nam się komunikat:

pi@raspberrypi:~ $ sudo insmod hello_world.ko
insmod: ERROR: could not insert module hello_world.ko: Invalid module format

1 2	pi@raspberrypi:~ $ sudo insmod hello_world.ko insmod: ERROR: could not insert module hello_world.ko: Invalid module format

Natomiast w dmesgu znajdziemy:

[20581.462299] hello_world: disagrees about version of symbol module_layout

1	[20581.462299] hello_world: disagrees about version of symbol module_layout

Najłatwiejszym sposobem rozwiązania tego problemu będzie zbudowanie całego kernela i zainstalowanie go na Raspberry. Napisałem na ten temat oddzielny artykuł (Kompilacja jądra dla Raspberry Pi), więc zajrzyj proszę do niego. Ja już to u siebie zrobiłem – jak widać poniżej, aktualnie wersja jądra na Raspberry jest taka sama jak wersja źródeł, którą sprawdzaliśmy wcześniej. Możemy więc przejść do kompilacji skrośnej modułu.

pi@raspberrypi:~ $ uname -r
5.10.78-v7+

1 2	pi@raspberrypi:~ $ uname -r 5.10.78-v7+

Kompilacja skrośna modułu

Tutaj sprawa też będzie wyglądało trochę inaczej, bo potrzebujemy kompilatora, który wygeneruje kod wykonywalny do uruchomienia na innej architekturze. Jeśli przechodziłeś ścieżkę cross kompilacji jądra z wyższej wspomnianego artykułu to już go instalowałeś:

lagun@lagun:~$ sudo apt install gcc-arm-linux-gnueabihf

1	lagun@lagun:~$ sudo apt install gcc-arm-linux-gnueabihf

Kod źródłowy modułu pozostanie taki sam, natomiast w Makefile musimy wprowadzić małą zmianę. Konieczne jest ustawienie odpowiedniej ścieżki do źródeł jądra. W moim wypadku wygląda to tak jak poniżej. Jeśli sklonowałeś repozytorium Linuxa w inne miejsce to będziesz musiał odpowiednio dostosować ścieżkę.

obj-m += hello_world.o
all:
	make -C ~/workspace/kernel-development/rpi/linux M=$(PWD) modules
clean:
	make -C ~/workspace/kernel-development/rpi/linux M=$(PWD) clean

obj-m += hello_world.o

all:

make -C ~/workspace/kernel-development/rpi/linux M=$(PWD) modules

clean:

make -C ~/workspace/kernel-development/rpi/linux M=$(PWD) clean

Aby skompilować moduł wystarczy już tylko wykonać make ze zdefiniowanymi zmiennymi środowiskowymi ARCH oraz CROSS_COMPILE. Są one niezbędne w przypadku kompilacji skrośnej. Zmienna ARCH określa dla jakiej architektury docelowej ma być wykonywana kompilacja, natomiast zmienna CROSS_COMPILE definiuje przedrostek dla narzędzi do kompilacji, które mają być wykorzystane podczas budowania.

lagun@lagun:~/workspace/kernel-development/rpi/module$ ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make
make -C ~/workspace/kernel-development/rpi/linux M=/home/lagun/workspace/kernel-development/rpi/module modules
make[1]: Entering directory '/home/lagun/workspace/kernel-development/rpi/linux'
 CC [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.o
 MODPOST /home/lagun/workspace/kernel-development/rpi/module/Module.symvers
 CC [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.mod.o
 LD [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.ko
make[1]: Leaving directory '/home/lagun/workspace/kernel-development/rpi/linux'

lagun@lagun:~/workspace/kernel-development/rpi/module$ ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make

make -C ~/workspace/kernel-development/rpi/linux M=/home/lagun/workspace/kernel-development/rpi/module modules

make[1]: Entering directory '/home/lagun/workspace/kernel-development/rpi/linux'

CC [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.o

MODPOST /home/lagun/workspace/kernel-development/rpi/module/Module.symvers

CC [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.mod.o

LD [M] /home/lagun/workspace/kernel-development/rpi/module/hello_world.ko

make[1]: Leaving directory '/home/lagun/workspace/kernel-development/rpi/linux'

Uruchomienie modułu

Po udanej kompilacji wystarczy już tylko przenieść skompilowany moduł hello_world.ko na Raspberry Pi. Można go przesłać np. za pomocą narzędzia scp lub bezpośrednio skopiować na kartę SD. Pozostałe kroki (ładowanie, odładowywanie modułu) wyglądają już tak samo jak zawsze. Korzystamy z narzędzi insmod i rmmod podając im ściężkę do skompilowanego modułu.

Podsumowanie

Kolejny artykuł z kategorii Linuxa za nami 🙂 Tym razem zrobiliśmy coś na platformie embedded. Zdecydowałem się na Raspberry Pi, ze względu na jej dużą popularność. Jest spore prawdopodobieństwo, że ze wszystkich platform posiadasz akurat ją. Jeśli masz jakąś inną platformę to bardzo fajnym ćwiczeniem będzie przejście całego procesu także dla niej.

W artykule udało się wpleść trochę informacji na temat kompilacji skrośnej. Jest ona bardzo często wykorzystywana w pracy z systemami wbudowanymi. Jeśli skupiłeś się tylko na pierwszej części z kompilacją natywną to zdecydowanie zachęcam do przejścia także tej trochę bardziej złożonej ścieżki 🙂