Kernel-Compilator zum Konfigurieren und Compilieren des Linux-Kernels

Heute ist Stammtischzeit:
Jeden Donnerstag 20:30 Uhr hier im Chat.
Wer Lust hat, kann sich gerne beteiligen. ;)
  • Hallo zusammen,

    vor einiger Zeit habe ich einen 7"-Touchscreen geschenkt bekommen - ja, ich bin immer noch der, der die Raspberry Pi's inkl. Zubehör geschenkt bekommt.

    Nachdem der Touch-Screen projektbedingt ein paar Wochen liegen blieb, habe ich ihn dann doch mal ausgepackt und angeschlossen.

    Die Touch-Funktionalität lässt sich nur nach Compilierung der Kernel implementieren. :wallbash: =(

    Nun denn... ein paar Anleitungen
    http://
    http://

    dazu habe ich gefunden - aber zum Ziel haben sie mich alle nicht geführt. Nach jedem Scheitern habe ich die Vorgehensweise analysiert. Bei jeder Anleitung haben sich Fehler eingeschlichen, die man nur bei äußerst gewissenhafter Anwendung vermeiden kann. Außerdem empfinde ich die Kombination von schier endlosen Terminal-Eingaben, die an sich schon fehlerträchtig sind, und die Nutzung graphischer Anwendungen für gewöhnungsbedürftig.

    Kurzum, in mir kam der Wunsch auf, den Prozess zu automatisieren UND von der Qualität des Anwenders unabhängig zu machen.

    Die Idee des Linux-Compilator war geboren.

    Anleitung zur Bedienung

    Dieses Programm setzt Folgendes voraus:
    - Auf einem PC befindet sich das Betriebssystem Ubuntu (auf meinem System Ubuntu 14.04 LTS - es sollte aber auch jedes andere Ubuntu laufen, wahrscheinlich läuft es auf jedem Linux-System)
    - Der Ubuntu-PC ist an ein Netzwerk angeschlossen
    - Der Raspberry Pi ist an das gleiche Netzwerk angeschlossen
    - Raspberry Pi und Ubuntu-PC sind hochgefahren
    - Auf dem Ubuntu-PC läuft der Kernel-Compilator
    - Der USB-Stecker des 7"-Touch-Screens ist in einer USB-Buchse des Ubuntu-PC eingesteckt

    Benutzeroberfläche
    Das Programm besteht aus einer Benutzeroberfläche, die dem Anwender die Informationen aus der Nase zieht. Immer dort, wo ein Bedienelement blassgrün erscheint, darf man etwas eingeben oder eine Aktion starten.

    Ich stelle jetzt die einzelnen Funktionsbereiche vor.

    1. Funktionsbereich Eingabe im Terminal des Raspberry Pi:
    Im oberen Text-Eingabefeld ist die IP-Adresse des Raspberry Pi einzugeben.
    a) Wer sie auswendig weiß :bravo2: :thumbs1:, der kann sie gern dort eintragen und mit Enter bestätigen.
    b) Wer sie nicht auswendig kennt, der kann im Terminal des Raspberry Pi eingeben:

    Code
    ifconfig | grep inet


    Kommen mehrere IP-Adressen, dann entscheide Dich für eine davon. Diese Daten werden dann in das Texteingabefeld des Kernel-Compilator eingetragen.
    c) Da beim Eingeben verhängnisvolle Fehler passieren können, habe ich mir überlegt, wie der Ubuntu-PC bzw. das Programm Kernel-Compilator diese Info herausbekommen kann. Mit Folgendem war ich dann zufrieden:


    Nach Drücken der Scaltfläche RPi im LAN/WLAN suchen wird eine Pipe geöffnet, die mittels

    Code
    hostname -I


    die IP-Adresse des Ubuntu-PC liefert. Also kann die IP-Adresse des Raspberry Pi so unterschielich auch ncht sein, da sie ja zum gleichen Netzwerkbereich gehören muss. Mit Hilfe des Befehls

    Code
    nmap -sP aaa.bbb.ccc.0/24 | grep report


    werden alle IP-Adressen des Netzwerkbereiches gescannt - diejenigen, die tatsächlich existieren, werden im rechts befindlichen Listenfeld ausgegeben. Der Anwender braucht jetzt nur noch die richtige IP-Adresse (bzw. die vierte Zahl davon) anzuklicken. Die "fertige" IP-Adressen steht dann im Texteingabefeld.

    Im mittleren Texteingabefeld wird die Kernel-Version (aktuell ist etwas wie 3.12) eingetragen.
    a) Wer sie auswendig weiß, der kann sie gern dort eintragen und mit Enter bestätigen. :bravo2: :thumbs1:
    b) Wer sie nicht auswendig kennt, der kann im Terminal des Raspberry Pi eingeben:

    Code
    uname -a | awk {'print $3'}


    c) Da beim Eingeben verhängnisvolle Fehler passieren können, habe ich mir überlegt, wie der Ubuntu-PC bzw. das Programm Kernel-Compilator diese Info herausbekommen kann. Mit Folgendem war ich dann zufrieden:

    Code
    executor("ssh -f pi@" || vidgets["text_input7"].data)
    	if uname := open("uname -a | awk {'print $3'}","p") then
    	{	version := read(uname)
    		version := version[1:find(".", version, 4)]
    		VSetState(vidgets["text_input4"], version)
    		close(uname)
    	}


    Nach Drücken der Schaltfläche via SSH ausführen wird ein SSH-Zugang zu der vorher festgelegten IP-Adresse ermöglicht. Die Version des Linux-Kernels wird automatisch in das Texteingabefeld eingetragen. Danach wird der Raspberry Pi mittels

    Code
    sudo shutdown -h now


    sicher heruntergefahren. Die SD-Karte wird entnommen und in einen passenden Slot des Ubuntu-PC oder in einen geeigneten USB-Kartenleser eingesetzt und am USB-Port des Ubuntu-PC eingesteckt.

    Im unteren Eingabefeld werden Informationen über den Touch-Screen eingetragen. Hierzu wird im Prinzip die Linux-Pipe gestartet:

    Code
    lsusb | grep Touch

    2. Im Funktionsbereich Pfad auf Ubuntu-PC werden Pfade für dieses Projekt gesetzt, sowie ein Verzeichnis für den Quellcode des Linux-Kernels eingerichtet. OK, ich hätte jetzt meinen File-Requestor einbinden können - aber ein wenig kann der Anwender auch mal machen.

    3. Im Funktionsbereich Verzeichnisse auf dem Ubuntu-PC wird der Pfad eingetragen, unter der die SD-Karte des Raspberry Pi dem Ubuntu-System nun bekannt ist. Da hier auch wieder Fehler entstehen können, macht der Kernel-Compilator im daruterstehenenden Listenfeld Vorschläge, von denen der Anwender sich das Passende aussucht (anklickt) - und schon steht es im Texteingabefeld.
    Der gleiche Vorgang wiederholt sich für die große Partition der SD-Karte.
    Für Interessierte der Programmcode:


    Und durch den folgenden Code wird auf die Auswahl der Listenfelder reagiert:

    Code
    procedure list_boot(vidget, value)
    	VSetState(vidgets["text_input3"], value[find("/media/", value):0])
    end
    
    
    procedure list_big(vidget, value)
    	VSetState(vidgets["text_input8"], value[find("/media/", value):0])
    end


    wodurch die Auswahl aus dem Listenfeld in die vorgesehenen Texteingabefelder übertragen werden.

    4. Im Funktionsbereich Herunterladen werden alle Informationen angeboten, die im Falle einer Kernel-Compilierung benötigt werden könnten. Beim ersten Aufrufen dieses Programmes sollten im Zweifelsfall alle Optionen aktiviert werden.
    a) Download Linux-Kernel. Hier wird der Linux-Kernel (in der festgelegten Version) in das Projektverzeichnis geladen. Dies geschieht durch folgende Zeilen:

    Code
    procedure aktion(n)
    	case n of
    	{1: {	executor("mkdir " || vidgets["text_input1"].data)
    			chdir(image(vidgets["text_input1"].data))
    			executor("wget https://github.com/raspberrypi/linux/archive/rpi-" || vidgets["text_input4"].data || ".y.tar.gz")
    			executor("tar -zxvf rpi-" || vidgets["text_input4"].data || ".y.tar.gz")
    		}


    b) Bibliotheken herunterladen. Diese sind erforderlich, damit der Kernel-Quellcod später auch fehlerfrei in lauffähigen Code umgewandelt werden kann.

    Code
    2:	{	executor("sudo apt-get install git libncurses5 libncurses5-dev qt4-dev-tools qt4-qmake pkg-config build-essential")
    		}


    c) Python installieren. Später wird ein Skript eingesetzt, das in der Sprache Python geschrieben ist.

    Code
    3:	{	executor("sudo apt-get install python")
    		}


    d) ARM-Cross-Compiler installieren. Auf dem Ubuntu-PC ist ein anderer Prozessor verbaut als auf dem Raspberry Pi. Wenn wir den Compiler ohne weitere Optionen des Cross-Compilierens einsetzen würden, dann würde der erhaltene Linux-Kernel auf dem Raspberry Pi nicht laufen können. Das Compilieren eines Quellcodes für das System A auf einem System B nennt man daher Cross-Compilieren. Für einige Sprachen gibt es Cross-Compiler-Pakete, die beim Compiler-Aufruf mit anzugeben sind, damit die Sache erfolgreich verlaufen kann.

    Code
    4:	{	executor("sudo apt-get install gcc-arm-linux-gnueabi bc")
    		}


    e) GIT-Tools herunterladen. Für das Projekt benötigen wir einige Werkzeuge aus der GIT-Werkzeugkiste (GIT-Tools). Diese werden mittels der folgnden Codezeilen heruntergeladen:

    Code
    8:	{	chdir("..")
    			executor("git clone git://github.com/raspberrypi/tools.git")
    		}


    f) Firmware herunterladen.

    Code
    11:	{	chdir("..")
    			executor("wget https://github.com/raspberrypi/firmware/archive/next.tar.gz")
    			executor("tar -zxvf next.tar.gz")
    		}

    5. Im Funktionsbereich Kernel: Konfigurator, Cross-Compiler werden dann die eigentlichen Compilierungen des Linux-Kernels sowie die Compilierung und der Aufruf des Linux-Konfigurators durchgeführt. Im einzelnen handelt es sich um folgende Aktionen:
    a) Source-Code bereinigen. Die heruntergeladenen Quellcode-Dateien werden empfehlungsgemäß mit Mr. Proper gereinigt. Folgende Codezeilen führen dies durch:

    Code
    5:	{	chdir("linux-rpi-" || vidgets["text_input4"].data) || ".y"
    			executor("make mrproper")
    		}


    b) Kernel-Konfigurator. Der Kernel-Konfigurator ist ein Programm, das wir uns durch Compilieren erst selbst herstellen:


    Hier werden folgende Eingaben vorgenommen:
    - Device Drivers
    - inpt device support
    - Touchscreens
    - Option Touchscreen aktivieren
    - Option USB Touchscreen Driver aktivieren
    Speichern
    Schließen
    c) Kernel compilieren. Hier wird die Kernaufgabe dieses Programmes erledigt, nämlich das Cross-Compilieren für den ARM-Prozessor:

    Code
    7:	{	executor("make O=../kernel" || vidgets["text_input4"].data || "/ ARCH=arm CROSS_COMPILE=/usr/bin/arm-linux-gnueabi- k-k -j" || vidgets["text_input6"].data)
    		}


    d) Kernel-Image erstellen. Hier kommt das bereits erwähnte Python-Skript zum Einsatz:

    Code
    9:	{	chdir("tools/mkimage")
    			executor(".imagetool-uncompressed.py ../../kernel" || vidgets["text_input4"].data || "/arch/arm/boot/image")
    		}


    e) Module erstellen. Module sind ein Verzeichnis auf der BOOT-Partition der SD-Karte. Diese werden mit dem folgenden Code-Ausschnitt erstellt:

    Code
    11:	{	chdir("..")
    			executor("wget https://github.com/raspberrypi/firmware/archive/next.tar.gz")
    			executor("tar -zxvf next.tar.gz")
    		}


    f) SD-Karte aktualisieren. Zunächst werden die alten Dateien gesichert - um im Fall, dass die ganze Aktion nicht funktioniert, alles wieder leicht rückgängig machen zu können. Dann werden die betreffenden neuen Dateien auf die SD-Karte kopiert, einige davon auf die kleine BOOT-Partition, einiges auf die große Partition der SD-Karte in das Verzeichnis /lib. Die folgnde Codezeilen erledigen das:


    Nach Abschuss dieses Funktionsbereichs wird die SD-Karte entnommen, in den Raspberry Pi eingesetzt und dieser damit gebootet.

    6. Im Funktionsbereich Kalibrierung des Touch-Screen wird die Durchfühung der Kalibierung unterstützt.
    a) SSH-Verbindung auf Raspberry Pi. Eine SSH-Verbindung auf den Raspberry wird hergstellt, um das Kalibrator-Programm zu installieren und zu starten.

    Code
    13:	{	executor("ssh pi@" || vidgets["text_input7"].data)
    		}


    b) Kalibrator-Programm installieren. Das Kalibrator-Programm wird installiert.

    Code
    14:	{	executor("sudo apt-get install libx11-dev libxext-dev libxi-dev x11proto-input-dev")
    			executor("wget http://github.com/downloads/tias/xinput_calibrator/xinput_calibrator-0.7.5.tar.gz")
    			executor("tar -zxvf xinput_calibrator-0.7.5")
    			executor("ls")
    			chdir("~/xinput_calibrator-0.7.5")
    			executor("./configure")
    			executor("make")
    			executor("sudo make install")
    			executor("sudo apt-get install Bildschirm-Tastatur")
    		}


    c) Touch-Scren kalibrieren. Der Touch-Screen wird nach Anleitung durchgeführt. Die Ausgabe des KAlibrators wird in der vorgegebenen Datei gespeichert, um auch nach einem Neustart gültig zu bleiben.


    d) Bildschirmtastatur installieren. Tja, jetzt haben wir einen Touchscreen inkl. Touch-Funktionalität - aber keine Bildschirmtastatur. Wer hier drauf klickt, hat dann eine Bildschirmtastatur.

    Code
    ... folgt ...

    e) Rückgängig machen. Tja, wenn's mal nicht funktioniert haben sollte, kann man hier die ganze Sache rückgängig machen und den Zustand vor Einsatz dieses Programmes herstellen.

    Code
    ... folgt ...


    Den abschließenden Quellcode stelle ich im Verlauf der Woche hier ein - wenn denn das Programm mehrere Mal von verschiedenen Anwendern fehlerfrei durchläuft - und der Einsatz am Raspberry Pi jeweils Erfolg hat.

    Beste Grüße

    Andreas

    P.S.: Bitte keine Kommentare, falls Ihr Bedenken :no_sad: zu irgendwelchen Code-Ausschnitten habt. Ein Teil läuft recht gut :cool:, der andere wird es noch tun. :shy:

    Bilder

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

  • Kernel-Compilator zum Konfigurieren und Compilieren des Linux-Kernels? Schau mal ob du hier fündig wirst!

  • Moin Andreas,

    da hast Du Dir ja eine Menge Arbeit gemacht ...
    Leider hast Du vermutlich meinen Beitrag zum Kernel-build damals überlesen.
    Da hatte sich u.a. Notro ebenfalls schon Gedanken dazu gemacht (-> click <-) ... dazu ist -> hier <- auch auf elinux was zu finden.

    Aber trotzdem ... Respekt
    -ds-

  • Moin Dreamshader,

    Du kennst mich doch:
    1. Idee :s
    2. Rechner hochfahren
    3. Idee umsetzen - Layout :angel:
    4. Idee umsetzen - codieren :wallbash:
    5. Testen :@ und optimieren :geek:
    6. Fertig, glücklich und zufrieden :cool:
    7. Oh, hat sich schon mal :auslachen: jemand damit beschäftigt ... interessant, was ist da anders?

    Aber :danke_ATDE: für den Hinweis - ich schaue mir das spätestens am Wochenende an - vielleicht ist da noch was Interessantes verborgen.

    Beste Grüsse

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    Einmal editiert, zuletzt von Andreas (22. September 2014 um 13:12)

  • Hi Dreamshader,

    vielen Dank für die Links. endlich habe ich mal die Zeit gefunden, mich damit auseinanderzusetzen.

    Ich bin zu der Erkenntnis gelangt, dass bei Deinen beiden Links intern auch nichts anderes passiert, als bei meinem Programm. Es werden absolut die gleichen Dateien heruntergeladen, auf identische Weise cross-compiliert. Der einzige Unterschied besteht darin, welche Dateien dann letztlich auf die SD-Karte gelangen. Und dies bedarf dann einer weitergehenden Analyse.

    Mittlerweile habe ich nochmals einige Stunden in die Weiterentwicklung investiert, da ich jetzt zum Standpunkt gekommen bin, dass es ausreichend sein muss, dem Programm den Kernel-Stand mitzuteilen, und er den "Rest" dann selber machen soll. Nach dem Motto: Der Anwender darf keine Möglichkeiten erhalten, durch sein undedarftes Zutun irgendetwas zum Misserfolg beitragen zu können.

    Der auf einem Ubuntu-PC laufende Kernel-Compilator kann momentan:- Kontakt mit dem Raspberry Pi aufnehmen
    - dessen Kernel-Version auslesen
    - Touch-Screen per USB auslesen
    - Raspberry Pi herunterfahren (um die SD-Karte entnehmen zu können)
    - Projektverzeichnis auf dem Ubuntu-PC einrichten
    - die zugehörigen Kernel-Dateien herunterladen
    - den Cross-Compiler herunterladen, entpacken und auf den Kernel-Quellcode anwenden
    - Kernel-Konfigurator erstellen und ausführen
    - angepassten Kernel auf die mittlerweile im PC steckende SD-Karte übertragen

    Neu ist ein Automatik-Modus, der alle bereits erfassten Daten beim nächsten Start automatisch bereitstellt und somit verteilte Sitzungen erlaubt, ohne immer wieder von vorne die immer wieder gleichen Daten auszulesen und auszuwählen.

    Neu ist auch eine Benutzerführung, wodurch der Anwender darauf hingewiesen wird, wo als nächstes drauf zu klicken ist. (Stichwort: Super-DAU)

    Momentan gibt es noch Probleme mit der Lauffähigkeit des neuen Kernels - wahrscheinlich habe ich noch nicht ganz verstanden, welche Dateien alle auf die SD-Karte kopiert werden müssen.

    Aber auch diese Woche ist wieder eine Woche im Hotel - viele Stunden, neue Codezeilen zu erdichten, zu testen und neue Ideen einfliessen zu lassen.

    Beste Grüsse

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

  • Hallo Andreas,
    ich hätte da evtl. noch was, das zu berücksichtigen wäre ...

    Durch einen Tip von meigrafd bin ich auf den netinstaller aufmerksam geworden und habe den -> hier <- mal ausprobiert. Klappt prima, aaaaber ...

    Der Kernel ist keiner von der Raspberry Pi Foundation sondern ein Debian-basierter. Das heisst, die Sourcen kommen nicht von github sondern aus einem anderen Repository.
    rpi-source unterstützt das leider nicht ...
    Informationen dazu findest Du am Ende des verlinkten Beitrags ...

    cu,
    -ds-

  • Hallo Dreamshader,

    vielen Dank für den Hinweis und Link - schaue ich mir nachher im Hotel an - sollte ich da WLAN-empfang haben. Ansonsten programmiere ich so, als hätte ich`s. ;)

    Beste Grüsse

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!