Dbox2 Entwicklungsumgebung

Aus TuxBoxWIKI
Wechseln zu: Navigation, Suche
Baustelle-klein.png Hinweis: In diesem Artikel nimmt gerade jemand größere Änderungen vor. Um Bearbeitungskonflikte zu vermeiden, warte bitte mit dem Bearbeiten, bis dieser Text wieder entfernt ist.

Allgemeines

Newmake ist eine Überarbeitung des alten "make" Prozesses, inzwischen auch als Oldmake bezeichnet, und wurde durch Barf ins Leben gerufen. Neben der deutlich strukturierteren Basis, bietet es unter anderem auch den Vorteil, dass es auch ohne ohne großes Verständnis für den Buildprozess gelingen kann, Flashimages und YADDs unter Linux zu erstellen. Basierend auf Newmake gibt es inzwischen auch eine auf Scripts basierende Quasi-Frontendlösung, um Flashimages oder YADDs benutzerdefiniert per Menü zu erstellen, das sogenannte yBuild.
Dieser Artikel basiert zum größtem Teil auf die deutsche Version von Barfs Newmake-Dokumentation, die er uns freundlicheweise zur Verfügung gestellt hat. Eine detaillierte Beschreibung (auch der make targets) unter anderem auch in englischer Sprache befindet sich auf Barf's Homepage.

Dieser Artikel behandelt Newmake aus Sicht des Benutzers (nicht Entwickler). Es behandelt die Image- u. YADD-Herstellung und einfache Beipiele für Benutzeranpassungen ("Customization").
Die Architektur von Newmake wird in einem anderen Artikel beschrieben.

Zur Geschichte

Vor einigen Jahren war die Imageherstellung für die Tuxbox so etwas wie "Schwarze Kunst". Die Makefile-Unterstützung war, insbesondere für andere Images als cramfs-Images, ziehmlich lückenhaft. Die CVS Werkzeuge waren schlecht, oder unvollständig. Noch schlimmer, einige Teile wurden absichtlich geheim gehalten. Vorallem das Werkzeug, jetzt als mkflfs bekannt, welches inzwischen aber im CVS-Verzeichnis .../hostapps/mkflfs zu finden ist, wurde zurückgehalten.

Laut eines Forumsbeitrags aus dieser Zeit, waren die meisten Entwickler nicht in der Lage, eigene Images herzustellen. Die "Gilde der Imagehersteller" wurde geboren. Aus dieser Zeit dürften die "AlexW-Images" ein Begriff sein. Hauptsächlich bestanden diese aus reinen CVS-Sources mit einigen mehr-oder-weniger geheim gehaltenen "Fixes", (vermutlich) notwendig für das Herstellen eines funktionierenden Images aus dem CVS-Quellcode.

Im August 2003, wurde es für das Projekt, das sich "GNU DBox2 Software-Projekt" nennt, in zunehmendem Maße peinlich, mkflfs geheim zu halten und der Quellcode für mkflfs wurde ins CVS eingecheckt. Auch die Funktionalität der Makefiles wurde stufenweise verbessert. Noch war viel zu wünschen übrig: Funktionalität, Pflegbarkeit, gesundes Software-Design...
Ein Image aus reinen CVS-Dateien zu bauen, war nicht wirklich möglich.

2004 wurde das YADI ("Yet Another DBox Image") Projekt geboren. (Bitte nicht "YADI" und "YADD" verwechseln!).
Sein Ziel war es, das "Imagebauen" zu automatisieren und zu vereinfachen. Zu diesem Zweck wurden eine Anzahl von Scripten und Patches gesammelt und/oder geschrieben. Zusätzlich wurden flashfertige Images zur Verfügung gestellt.

YADI war ein grosser Erfolg. Das Ziel wurde erreicht. Images wurden zur Verfügung gestellt, die (fast) vollständig auf freier Software basierten, sowohl inhaltlich als auch bezüglich der benötigten Werkzeuge, in eine Weise, die für den Benutzer durchaus nachvollziehbar war.
Mit dem YADI-Skript war das automatische Imagebuilden möglich, jedoch statt grundlegende Schwächen im CDK-Imagebau-Prozeß zu beseitigen, stellte man nur Skripte zum Imagebauen zur Verfügung. Es wurde kein übliches Buildsystem für dieses Software-Projekt zur Verfügung gestellt, wie dies beispielsweise von Make, oder ein neuerer Nachfolger wie Ant,Cmake oder Maven könnten.
Newmake, verfügbar als alternativer Branch im CVS, versucht diese Schwächen zu beseitigen.


Ein spezieller Dank an jedem, der Bugreports und Feedback geliefert hat. Insbesonderes gilt dies für dietmarw, der Newmake benutzt, um die dietmarW-Images zu erzeugen.

Ziel

Das Ziel des vorliegenden Artikels ist, dem Leser grundlegendes Know-How zu vermitteln. Es ist nicht das Ziel, eine idiotensichere Schritt-für-Schritt Anweisung bereitzustellen, wie das bei sogenannten HOWTO's der Fall wäre.
Kenntnisse im Umgang mit Shellskripten wird für viele Teile, insbesondere das Customization-Kapitel, aber nicht für Image/YADD-Herstellung in seiner einfachsten Form vorausgesetzt.

Der vorliegende Artikel versucht nicht die innere Funktion der Makefiles und des Makeprozesses zu beschreiben. Hierfür wird der Leser auf die Quellen hingewiesen, und zu relevanten Threads im CDK-Forum des Tuxbox-Forums. Alle Optionen für configure werden auch nicht beschrieben, nur die Allgemeinsten und Wichtigsten.

Wie schwierig ist es?

Die Antwort könnte lauten: Es ist so schwerig wie man diesen Artikel zu lesen versteht. Der Leser, der ohne Probleme den Inhalt versteht, sollte keine Probleme haben. Leser, für die das Meiste nur Kauderwelsch ist, sollten vielleicht besser bei fertigen Images bleiben.

Images und YADD's bauen

Targets

Es gibt neben zahlreichen untergeordneten Zielen (Targets), zwei hauptrangige Targets. Diese wären entweder

oder

Ein YADD besteht aus einigen Dateien, die die DBox über den TFTP-Service lädt, sowie ein Filesystem, das von einem NFS-Server für die dBox zur Verfügung gestellt wird.
Diese Betriebsart hat insbesondere während der Softwareentwicklung oder beim Erlernen des Systems viele Vorteile.
Der Name "YADD" bedeutet "Yet Another DBox Distribution" ("noch eine dBox Verteilung"). Leider hat sich dieser irreführende und durchaus alberne Name durchgesetzt.

Erste Schritte und Überlegungen

Eine Empfehlung für den angehenden "Image/YADD-Lehrling" wäre:
Baue zuerst ein YADD mit Deiner Lieblings-GUI, und lerne damit umzugehen.
Nächster Schritt wäre dann, ein jffs2-Image mit der Lieblings-GUI zu erstellen.

Meistens möchte man die folgenden Schritte kombinieren und/oder automatisieren. Im Unterschied zu "HOWTO's", versucht dieser Artikel aber nur grundlegendes Know-How zu vermitteln, und überlässt das Scripting dem Leser. Leser mit Vorkenntnissen über Skriptprogrammierung sollten danach schon in der Lage sein, ihre eigenen Build-Skripte verfassen zu können.

In diesem Artikel bezeichnet "GUI" entweder


Das "Filesystem" im Kontext eines kompletten Images bezeichnet das Dateisystem, in dem das root-Verzeichnis liegt. Diese kann ein

  • cramfs (ein komprimiertes, Read-only filesystem für embedded Systeme) sein,
  • squashfs (ein anderes komprimiertes read-only-Dateisystem, oft als leistungsfähiger als cramfs betrachtet)

oder

  • jffs2 (ein "journalled" Read-Write-Filesystem).

Ein "cramfs Komplett-Image" besteht aus einem Root-Dateisystem mit dem cramfs Dateisystem und einem kleineren jffs2-Filesystem, das nach /var gemounted wird.
Analog gilt dies auch für "squashfs Komplett-Images", während ein "jffs2 Komplett-Image" kein separates /var-Dateisystem enthält, weil das Wurzeldateisystem schon jffs2 ist und deswegen schreibbar ist.

Zusätzlich enthalten die Komplett-Images eine zusätzliche Partition, die den u-boot Bootloader enthalten. Diese Partition ist zwischen dBoxen mit einen und zwei Flashchips unterschiedlich. Dieses wird durch "1x" und "2x" angezeigt. Ein komplettes Image trägt den Namen

[neutrino, enigma]-[cramfs, squashfs, jffs2].img[1, 2]x, 

z.B.:

neutrino-jffs2.img2x.

Buildsystem Voraussetzungen

Die Voraussetzungen auf dem Buildhost können in etwa so zusammengefasst werden:
Ein modernes Unix/Linux System mit ca. 2 GB freiem Speicherplatz. Epfehlenswert ist aber, mehr Speicherplatz einzuplanen, da beispielsweise bei Verwendung von ccache einiges an Daten zwischengelagert wird und je öfter man kompiliert, es dann doch eng werden könnte.

Das Tuxbox Projekt hat keine favorisierte Buildumgebung. Fragen wie "geht es mit Redhat x.y?" lassen sich nicht genau beantworten. Der Grund hierfür ist, dass niemand sich wirklich dafür interessiert, die Eigenschaften der bestimmten Distributionen zu erkunden. Gewisse Anforderungen werden dagegen für Versionen der Werkzeuge, wie autoconf, automake, make usw. formuliert. Die momentan erfordelichen Toolversionen sind in folgendender Tabelle zusammengefasst:

Tool benötigte Version abweichender Name
autoconf 2.57a
automake 1.8
libtool 1.4.2
gettext 0.12.1
make 3.80
makeinfo irgendwelche
tar irgendwelche
bunzip2 irgendwelche
gunzip irgendwelche
patch irgendwelche
infocmp irgendwelche
gcc = 2.95 or >= 3.0
g++ = 2.95 or >= 3.0
flex irgendwelche
bison irgendwelche
pkg-config irgendwelche
wget irgendwelche


Der Bauprozeß überprüft automatisch einige dieser Anforderungen. Wenn eines dieser Tools fehlt, oder wenn die Version zu alt ist, ist es in der Regel einfacher, die erforderliche Version nachträglich zu installieren, entweder als kompiliertes Paket, z.B. im rpm-Format vom jeweiligem Distributor, oder sich direkt die Quellen zu besorgen, zu compilieren und zu installieren, als zu versuchen oder herauszufinden ob die oben genannten Anforderungen wirklich notwendig sind.

Hinweis:

In anderen Anleitungen zum Buildvorgang wird gefordert, dass Tools wie fakeroot,
mksquashfs, mkcramfs, mkjffs2fs (oder mkfs.jffs2), vielleicht auch mlibs
oder ccache, auf Ihrem System installiert sein müssen. In dieser Umgebung ist dies nicht
erfordelich, da einige entweder überhaupt nicht benötigt werden bzw. die Installation im 
Makeprozess selbst vorgenommen wird!


Auf einem SuSE System 10.0 war es z.B. notwendig, autoconf, automake, gcc, bison, flex, gcc, c++, newcurses-develop sowie zlib-develop nach zu installieren.
Builden auf einem Unix-non-Linux System sollte vermutlich möglich sein, so weit die erforderlichen GNU Werkzeuge vorhanden sind. Mit einem anderen make als GNU wird es fast sicher nicht laufen, da die GNU-Erweiterungen uneingeschränkt verwendet werden.

Es wird daher davon abgeraten eine Umbegebung z.B. mit Cygwin aufzubauen, da es höchswahrscheinlich nicht funktionieren wird. In dieser Richtung wurde zwar einiges für den Makeprozess eingebaut, jedoch dürfte dies nicht dem zeitgemäßen Stand entsprechen, um aktuell auch damit arbeiten zu können.

Empfehlenswert ist allerdings eine Buildumgebung mittels VMWare aufzubauen. Hierfür gibt es auch eine "konfektionierte" Lösung von yiogol, der hierfür ein passendes VMWare-Image erstellt hat, welches im Prinzip alle notwendigen Zutaten enthält.


Auschecken

Die Tuxbox Quellen werden durch den Tuxbox CVS-Server bereitgestellt.
Regelmäßige Quellreleases sind niemals gemacht worden, und sind auch nicht für die Zukünft geplant. Für unsere Zwecke werden die Quellen anonym "ausgecheckt", was bedeutet, dass diese auf die eigene Festplatte kopiert werden, indem man zuerst auf einer (lokalen) Festplatte mit "ordentlich" freiem Platz ein leeres Verzeichnis erstellt, z.B. /tuxbox-cvs und in diesen Ordner wechselt, und diesen Befehl ausführt.

cvs -d anoncvs@cvs.tuxbox.org:/cvs/tuxbox -z3 co -f -r Newmake -P .

Dieser Befehl checkt die Newmake Files aus. In Fällen, in denen keine Newmake Version vorhanden ist, wird die HEAD-Version genommen.

Im HEAD gibt es zwei Files:

cdk/root/etc/init.d/rcS

und

root/etc/init.d/rcS.insmod

Im Newmake werden diese nicht benötigt da sie mittels

root/etc/init.d/rcS.m4

erzeugt werden. Es ist ratsam, diese beiden zu löschen, um auf der sicheren Seite zu sein.

Nun könnte kann man einige Patches auf die Quellen anwenden. Wenn man zum ersten Mal kompiliert, ist es aber ratsam, Patches nicht anzuwenden. Wenn Probleme auftreten, ist es viel einfacher (technisch sowohl als auch für jeden selbst) jemand zu helfen, der die "unveränderten CVS Quellen" verwendet.


Konfiguration

Jetzt müssen einge Zwischenschritte erledigt werden, damit der Buildprozess auch weis, was und vorallem wie er es machen soll.

Man wechselt nun in das CDK-Unterverzeichnis

cd cdk

und gibt diesen Befehl ein (ohne Argumente).

./autogen.sh

Dieser erzeugt unter anderem ein Shellskript namens configure.
Wird dies ausgeführt, wird dabei eine Anzahl von Optionen übergeben, um das System für das Builden eines Images/YADD entsprechend den Benutzerwünschen vorzubereiten.


Optionen

Für eine komplette Liste von Optionen, benutze den Befehl

./configure --help. 

Hier einige Ausgaben:

  • Program names:
 --program-prefix=PREFIX            prepend PREFIX to installed program names
 --program-suffix=SUFFIX            append SUFFIX to installed program names
 --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
  • System types:
 --build=BUILD     configure for building on BUILD [guessed]
 --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 --target=TARGET   configure for building compilers for TARGET [HOST]
  • Optional Features:
 --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 --enable-maintainer-mode  enable make rules and dependencies not useful
                         (and sometimes confusing) to the casual installer
 --disable-dependency-tracking  speeds up one-time build
 --enable-dependency-tracking   do not reject slow dependency extractors
 --enable-kernel26       set up the CDK to use the 2.6 kernel (experimental)
 --disable-nptl          do not use native posix threads for glibc (only
                         meaningful for kernel 2.6.x, default for 2.4.x)
 --enable-flashrules     enable rules for creating flash targets
 --enable-lirc           include lirc in yadds and images
 --enable-cdkVcInfo      include cdkVcInfo in yadds and images
 --enable-german-keymaps include loadkey and German keymaps in yadds and
                         images
 --enable-ide            include ide and ext2/ext3 drivers in yadds and
                         images
 --disable-ext3          exclude ext2/ext3 drivers in yadds and images
 --enable-xfs            include xfs drivers in yadds and images
 --enable-nfsserver      enable the dBox NFS server
 --enable-sambaserver    enable the dBox samba server
 --enable-dosfstools     enable the dosfstools
 --enable-upnp           include upnp support
 --enable-flac           include Neutrino flac audio decoder with libFLAC
 --enable-ccache         enable ccache supported compiling
  • Optional Packages:
 --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 --with-cpu=MODEL        cpu model [823,405]
 --with-targetruleset=NAME     OBSOLETE, use --[enable|disable]-flashrules instead
 --with-assume-kernelsources-old       Do not recompile due to new kernel sources
 --with-rootpartitionsize=SIZE size of the root partition
 --with-defaultlocale=LOCALE   default locale
 --with-targetprefix=DIR prefix for target files [PREFIX/cdkroot]
 --with-hostprefix=DIR   prefix for host files [PREFIX/cdk]
 --with-bootprefix=DIR   prefix for boot files [PREFIX/tftpboot]
 --with-flashprefix=DIR  prefix for flash files [PREFIX/cdkflash] (only used for flash building)
 --with-serversupport=DIR  prefix for server file templates [PREFIX/serversupport]
 --with-ucodesdir=DIR  optional directory containing ucodes [NONE]
 --with-logosdir=DIR  optional directory containing logos [[CVS/]logos]
 --with-customizationsdir=DIR  optional directory containing customization scripts CVS
 --with-updatehttpprefix=URL  optional URL containing the URL of a directory with update images [NONE]
 --with-checkImage=[none,rename,warn]  How/if to invoke checkImage [none]
 --with-cvsdir=DIR       where to find the cvs
 --with-appsdir=DIR      apps dir from cvs [[CVS/]apps/]
 --with-bootdir=DIR      boot dir from cvs [[CVS/]boot/]
 --with-driverdir=DIR    driver dir from cvs [[CVS/]driver]
 --with-hostappsdir=DIR  hostapps dir from cvs [[CVS/]hostapps]
 --with-gnuserver=ADDRESS   the gnu server for gnu-stuff (without ftp://)
 --with-defaultserver=ADDRESS   the server that is taken if no server is given/works (without http://)
 --with-ccachedir=DIR directory where ccache is installed
 --with-maxcachesize=SIZE maximal ccachesize for ccache
 --with-maxcachefiles=COUNT maximal count of cachefiles for ccache


Für uns sind aber vorerst nur wenige Optionen nützlich. Für die meissten Optionen reichen die Standardvorgaben völlig aus.

Eine typische Anwendung, der mit den Pfadnamen oben kompatibel wäre, könnte so eingestellt werden:

./configure --with-cvsdir="/tuxbox-cvs" --prefix="/dbox2" --enable-maintainer-mode


  • --with-cvsdir

sagt wo die Quellen zu finden sind, (darin sollte auch ein Unterverzeichnis .../cdk besitzen), während

  • --prefix

bedeutet, dass eine Anzahl von wichtigen Verzeichnissen als Unterverzeichnisse des besagten Verzeichnisses erstellt werden sollen. Ihre Position kann durch andere Konfigurationsoptionen weiter beeinflußt werden.

  • --enable-maintainer-mode

ist, auch für Nichtmaintainers praktisch, da er den hergestellten Makefiles ermöglicht, sich automatisch neu zu erzeugen, sobald die Notwendigkeit entsteht, zum Beispiel nach einem Software-Update.

Es gibt sicher noch andere nützliche Optionen. Einige werden später besprochen.


Fehlerausgaben

Überprüfe bitte die Ausgaben von autogen für Fehler ("Error") und Warnungen.
Hierbei können diese Warnungen ignoriert werden:

/usr/local/share/aclocal/pkg.m4:5: warning: underquoted definition of PKG_CHECK_MODULES from autogen.sh 

ebenso folgende Warnungen von configure:

...
configure: WARNING: using tuxbox mklibs
checking for mkcramfs... no
configure: WARNING: using tuxbox cramfs
checking for mkjffs2... no
checking for mkfs.jffs2... no
configure: WARNING: using tuxbox mkfs.jffs2
checking for mksquashfs... no
configure: WARNING: using tuxbox squashfs
...

Dies sind nur Hinweise darauf, dass hier projekteigene Versionen einiger Tools verwendet werden.

Beachte!

Wenn man diesen Artikel mit ähnlichen Beschreibungen "aus vergangenen Zeiten"  
vergleicht, bemerkt man, dass die Option --with-targetruleset=[standard,flash] nicht mehr
vorhanden ist. Bisher war es notwendig, bei der Konfiguration sich entweder auf Builds von YADDs
oder Images einzuschränken. Im Newmake ist dieses nicht mehr notwendig.

Warnung!

 Versuche niemals, als root zu bauen!

Kompilieren

Die high-level make Targets, die für das Builden von Komplett-Images relevant sind, heißen:

flash-[neutrino, enigma, all]
flash-[cramfs, squashfs, jffs2, all]
[1x, 2x, alle]

Für YADD-Builds, sind diese:

yadd-[neutrino, enigma, all]

Beispiele:

make flash-neutrino-jffs2-all 

erzeugt flashbare jffs2-only Images mit Neutrino, für 1x-Boxen und für 2x-Boxen (Dateinamen neutrino-jffs2.img1x und neutrino-jffs2.img2x).

der Befehl:

yadd-enigma

erzeugt ein YADD, das Enigma enthält.

Zeitaufwand

Das Kompilieren kann bei so einem Projekt und je nach Konfiguration und Rechnerleistung schon einige Zeit in Anspruch nehmen.
Auf einem Athlon XP 1800 dauert ein Befehl wie make yadd-neutrino mit leeren Verzeichnissen etwa 1 und 1,5 Stunden. Um den Vorgang insbesondere bei wiederholten Kompilieren und besonders auf langsameren Rechnern zu beschleunigen, steht die Option

--enable-ccache

zur Verfügung, welche man mit in die Konfiguration einbinden kann.
Erfahrungsgemäß wird so durchschnittlich ca. 1-2 Drittel der Zeit eingespart.

Hinweis
Ccache kann sich erst bemerkbar machen, wenn der Buildvorgang mindestens einmal durchgelaufen ist!

Tip
Um die benötigte Zeit genau zu ermitteln, kann man den Befehl time einbauen.

time make yadd-neutrino

Am Ende des Bauvorganges werden damit die entsprechenden Zeitinformationen ausgegeben.


Beispiele

Hier einige Beispiele mit denen man Images, Yadds oder einzelne Targets bauen kann. Diese Beispiele sollten so wie sie hier vorgegeben sind ohne Veränderung auf jedem Linux-System mit den bisher beschriebenen Voraussetzungen Ergebnisse bringen. Da die Systeme trotzdem Unterschiede aufweisen könnten, kann man das aber nicht garantieren.

neutrino-jffs2-Image

Man könnte dies nun in ein Script packen und sich das Image bauen lassen. Dies könnte in etwa so aussehen:

#! /bin/bash 
# beispiel.sh
# Diese Script baut neutrino-jffs2 Images, jeweils 1x und 2x
#----------------------------------------------
USERDIR=/home/$(whoami) 
#----------------------------------------------
LOGODIR=/Logos 
CP=/tuxbox-cvs 
DB=/dbox2 
ARCHIVEDIR=/Archive 
export CVS_RSH=ssh 
#----------------------------------------------- 
cd "$CP"
cvs -d anoncvs@cvs.tuxbox.org:/cvs/tuxbox -z3 co -f -r newmake -P . 
cd cdk
/bin/ln -sf $ARCHIVEDIR/ Archive
./autogen.sh 
./configure --prefix="$DB" --with-cvsdir="$CP" --enable-flashrules --enable-ccache --with-checkImage=rename --with-logosdir="$LOGODIR" 
make flash-neutrino-jffs2-all 

Neutrino YADD

Um ein Neutrino Yadd zu bauen würde das so aussehen:

#! /bin/bash 
# beispiel.sh
# Diese Script baut ein Neutrino Yadd
#----------------------------------------------
USERDIR=/home/$(whoami) 
#----------------------------------------------
LOGODIR=/Logos 
CP=/tuxbox-cvs 
DB=/dbox2 
ARCHIVEDIR=/Archive 
export CVS_RSH=ssh 
#----------------------------------------------- 
cd "$CP"
cvs -d anoncvs@cvs.tuxbox.org:/cvs/tuxbox -z3 co -f -r newmake -P . 
cd cdk
/bin/ln -sf $ARCHIVEDIR/ Archive
./autogen.sh 
./configure --prefix="$DB" --with-cvsdir="$CP" --with-logosdir="$LOGODIR" --enable-ccache 
make yadd-neutrino


Was kommt dann...?

Booten von YADD

Wenn ein YADD frisch erzeugt wurde, kann damit auch die Box booten. Näheres dazu auch im Artikel CDK booten.
Newmake hält auch ein Make-Target für den serversupport bereit.

make serversupport

Dies erzeugt einige Konfigurationsdateien für den Server der das YADD-Build nahtlos an das Server-Setup anknüpft.


Flashen des Images

Wenn ein Image gebaut wurde, ist der logische nächste Schritt das Einspielen des Images in den Flash der Box. Hierfür entweder, das interaktive Flashen innerhalb der GUI (Expertenfunktionen) zu benutzen, oder den dboxflasher zu verwenden, welches hier auch beschrieben wird. Der dboxflasher wird durch das Make-Target make serversupport erzeugt. Andere Möglichkeiten des Flashens werden hier beschrieben.

Inkrementelle Builds

Im allgemeinen sind Leute nicht an einem einmaligen Build der Software interessiert. Verbesserungen an den Quellen werden in das CVS täglich eingecheckt. Viele Leute möchten die Software durch eigene Programmierung verbessern oder Patches anwenden. Es ist dabei wünschenswert, dass genau die Teile neu erzeugt wird, die neu erzeugt werden sollen, nicht mehr und nicht weniger. Das vorliegende "Newmake" geht einen direkten Weg in diese Richtung.
Um ein Target neu zu bauen, benutzen den Befehl

make [target]

und make wird es, falls notwendig, neu erzeugen.

Es kann dann passieren, dass make zusätzlich einen vollständig anderen Bestandteil neu erzeugt! Dieses ist dann der Fall, wenn das jeweilige Target von anderen Teilen abhängt, die sich geändert haben.

In einige Situationen kann es wünschenswert sein, ein erneutes Build einer Komponente zu erzwingen. Einige Komponenten werden in einem Distributionsfile zum Verzeichnis cdk/Archive heruntergeladen, und wenn das Build stattfindet, ausgepackt, Patches werden angewendet (nur in einigen Fällen, konfiguriert, kompiliert, installiert, und die Quellen dann wieder gelöscht.
Alles findet automatisch statt. Die Installation eines bestimmten Pakets wird durch das Anlegen einer Markerdatei im Verzeichnis cdk/.deps vermerkt.

Falls gewünscht, kann solch eine Markiererdatei entfernt werden, um das Neuerzeugen der entsprechenden Komponetne zu erzwingen. Es gibt hierfür auch entsprechende Targets, die "Cleaning Targets".

Cleaning targets

Es gibt mehrere unterschiedliche Aufräum-Targets:

Das drastischste Reinigungs-Target, (fast) alles löschend, was nicht vom CVS ausgecheckt wurde. Dieses ist eher selten notwendig.

make distclean


Ein intelligenteres Target ist mostlyclean. Es säubert die Verzeichnisse, die Tuxboxquellen enthalten, lässt aber die Kompilationsumgebung und alle Auspacken-kompilieren-installieren-löschen-Komponente unberührt.
Auch das cdkroot Verzeichnis, (d.h. die Yadd-Installation), sowie die TFTP-Files (Kernel und u-boot) werden nicht angefasst.

make mostlyclean



Löscht alle Markerdateien im /cdk/.deps Verzeichnis und zwingt so zum Neukompliieren aller Auspacken-kompilieren-installieren-löschen-Komponenten.
Dies ist selten sinnvoll: Diese hängen von ihren Quellen und vielleicht von einem Patchfile ab, und der Makefile kennt diese Abhängigkeiten.

make depsclean



Kombiniert mostlyclean, depsclean, und flash-clean. Versucht auch soviel wie möglich im cdkroot-Verzeichnis zu löschen, das nicht während des Bootstrapdurchlaufes installiert war. So wird versucht, die Umgebung in einem Zustand zu bringen, wo die Buildumgebung gerade kompiliert worden ist, z.B. mit make bootstrap.

make clean


Dieses Target löscht die meisten Verzeichnisse in $(flashprefix), mit Ausnahme der Boot-Partitionen und der Kernelbauverzeichnisse.
Dieses ist oft sinnvoll, da diese Bestandteile verhältnismässig sich selten ändern.

make flash-semiclean


Zusätzlich zum flash-semiclean löscht dieses Target auch Bootfiles und die Kernbauverzeichnisse. Vollimages werden unberührt gelassen.

make flash-mostlyclean


Dieses Target löscht Alles in $(flashprefix).

make flash-clean


Einige Quellverzeichnisse können mit einem Befehl wie

make -C /tuxbox-cvs/apps/tuxbox/neutrino clean 

gesäubert werden.

Aktualisierung des CVS-Quellcodes

Um die Quellen mit neueren Checkins zu aktualisieren, verwende diesen Befehl für das toplevel CVS Verzeichnis (oder von einem anderen Verzeichnis, wenn Ihr wisst, was ihr tut;-). Mögliche Fehler werden in das logfile cvs.log geschrieben.

cvs up -f -r Newmake -dP > cvs.log 2>&1

Tip
Um mit dem CVS arbeiten zu können nimmt man für gewöhnlich die Konsole für die Eingaben. Es gibt aber auch verschiedene Frontendwerkzeuge wie CrossVC oder auch andere, die einen recht komfortablen Umgang mit den CVS-Daten ermöglichen. Auch einige IDE's bieten solche CVS-Schnittstellen an.


Customization

Bisher lief immer alles hinaus Images oder Yadds zu bauen, die aus dem unveränderten CVS-Quellen gebaut wurden.
Images und die Yadds können aber auch angepasst ("customized") werden, ohne die Makefiles zu ändern.
Hier gibt es verschiedene Möglichkeiten.

Konfigurationsoptionen

hier einige nützliche Optionen:
Hiermit kann ein Verzeichniss angegeben werden, welches die Ucodes enthält, die im Image enthalten sein sollen.

--with-ucodesdir=[DIR]

Hinweis:

Ein Image, dass ucodes enthält, darf 
nicht verbreitet werden! 



Mit der Option

--with-logosdir=[DIR] 

kann ein Verzeichniss angegeben werden, das boot-logos (logo-lcd und logo-fb) enthält, die im Image enthalten sein sollen.

Diese Option

--with-defaultlocale=[LOCALE]

sorgt dafür, dass die gewünschte Sprache schon beim bauen eingestellt wird.

Ändern der Partitionierung

Die Rootpartitionsgröße für cramfs und squashfs Images kann mit der Configure-Option

--with-rootpartitionsize=[SIZE]

angegeben werden.
Die Größe der var-Partition wird automatisch berechnet, wobei man den restlichen Flashspeicher nutzt, der nicht durch die anderen Partitionen benutzt wird. Die Standardgröße ist 0x660000. Diese Zahl sollte eine Multiple der Erasesize, momentan 0x20000 sein. Dies wird allerdings ignoriert falls es wie bei der jffs2-Imageerstellung unsinnig wäre.

Variablen

Pfade

Es sind noch weitere Benutzeranpassungen möglich. Dafür ist es aber notwendig, etwas Wissen über die innere Funktion des Makefiles zu haben.
In der Folge bezeichnet

$(flashprefix) 

den Wert der Makefile Variablen flashprefix (mit Konfiguration wie oben /dbox2/cdkflash)

$(targetprefix)

bezeichnet den Wert der Makefile Variablen targetprefix (mit Konfiguration wie oben /dbox2/cdkroot), und

$(buildprefix) 

bezeichnet den Wert der Makefile Variablen buildprefix (mit der Konfiguration oben /tuxbox-cvs/cdk).

Um z.B. ein neutrino-cramfs.img2x zu erzeugen, werden die folgenden Verzeichnisse erstellt:

  • $(flashprefix)/root (enthält Filesystem- und GUI-unabhängige Bestandteile)
  • $(flashprefix)/root-cramfs (enthält den Kernel, für Root-Filesystem auf cramfs konfiguriert, zusammen mit seinen Treibern) und
  • $(flashprefix)/root-neutrino (enthält die Neutrinoinstallation).


Aus diesen drei Verzeichnissen, werden das Rootfilesystemverzeichniss

  • $(flashprefix)/root-neutrino-cramfs und das

var-filesystemverzeichnis

  • $(flashprefix)/var-neutrino gebaut.


Hiermit ist es möglich, einen Befehl wie

make $(flashprefix)/root-neutrino-jffs2

bzw. wenn man sich im Verzeichnis ./tuxbox-cvs/cdk befindet, den Befehl

make root-neutrino-jffs2

einzugeben, wobei man bei erster VAriante natürlich $(flashprefix) selbst durch den korrekten Pfad ersetzen muss, da $(flashprefix) nur eine make-Variable ist, welche in unsrem Beispiel den Pfad zu ./dbox2/cdkflash darstellt.
Man kann so manuell gewünschten Änderungen an $(flashprefix)/root-neutrino-jffs2 vornehmen, und dann, mit dem Befehl

make flash-neutrino-jffs2-2x 

den Imagebau abschlieen, um ein Image zu erstellen, das diese manuellen Änderungen enthält.
Dieses kann für den einmaligen Imagebau sinnvoll sein. Jedoch in vielen Fällen dürfte eine automatisierte und systematischere Methode erforderlich sein.

Customization-Scripte

Sofern vorhanden und ausführbar werden innerhalb der wichtigsten Targets sogenannte Customization-Scripte aufgerufen. Das bzw. die Scripte müssen im customizationsdir liegen. Dies ist bei Bedarf mit der Option

--with-customizationsdir=[DIR]

einstellbar. Standardverzeichnis ist ./cdk.
Auf die Scripte werden zwei Argumente zur Laufzeit übergeben:
Für Imagetargets sind dies

  • $(flashprefix)

und

  • $(buildprefix)

für Yaddtargets sind diese

  • $(targetprefix)

und

  • $(buildprefix)



Die Bezeichnung "Script" ist etwas irreführend, da sie eigentlich wie normale Programme mit zwei Argumenten ausgeführt werden. Anstelle eines Shell-Scripts könnte dies z.B. ein kompiliertes C Programme, oder ein Perl-Script sein.
Der Name eines Customization Scriptes besteht in der Regel aus dem Namen eines Targetverzeichnisses bzw. in einigen Fällen einem Target und dem angefügtem *-local.sh.

Für Flash-Targets

Der Name der Customization Scripte für Images besteht aus den wie oben benannten Verzeichnissen in flashprefix,

  • root


dem Namen der jeweilige Benutzeroberflche, als "GUI" in Klammern bezeichnet, also

  • neutrino
  • enigma
  • lcars
  • radiobox


"FS" zeigt an welches Filesystem gemeint ist.

  • cramfs
  • squashfs
  • jffs2


so wäre die Bezeichnung der jeweiligen Scripte so aufgebaut:

  • root-local.sh
  • root-[GUI]-local.sh
  • root-[GUI]-[FS]-local.sh
  • root-[FS]-local.sh
  • var-[GUI]-local.sh


Beispiele:

root-local.sh
root-neutrino-local.sh
root-neutrino-squashfs-local.sh
root-squashfs-local.sh
var-neutrino-local.sh

Für Yadd-Targets

Für Yadds ist das Prinzip ähnlich, nur dass es hier quasi nur einen Ordner gibt. Dafür stellvertretend steht dafür dann

  • yadd.

Das "GUI" in Klammern bezeichnet auch hier die jeweilig betroffene Benutzeroberflche, also

  • neutrino
  • enigma
  • lcars
  • radiobox


so wäre die Bezeichnung der jeweiligen Scripte so aufgebaut.

  • yadd-[GUI]-local.sh

Beispiel:

yadd-neutrino-local.sh

Andere Customization Scripte

Die bisher benannten Customization Scripte für Flash- u. Yadd-Targets sind so die gebräuchlichsten.
Es gibt aber noch jede Menge mehr in Newmake. Im Prinzip ginge dies auf so gut wie alle Targets anzuwenden. Möchte man z.B. ein Tool "customizen", etwa hdparm, kann man ein Script erstellen:

  • hdparm-local.sh

Fürt man dann das Target:

make hdparm

aus, wird dann das ausgeführt was im Customization Script angelgt wurde. Die Aktionen im Original-Makefile werden übersprungen.

Auch diese Funktion ist recht interessant:
Während des make-Durchlaufs werden einige Targets ausgeführt, welche u.a.die /.version-Files bei YADD

  • version

bzw.

  • flash-version

im Image erstellt.
Sofern vorhanden und ausführbar werden als Ersatz sattdessen diese in den Targets ausgeführt:

  • version-local.sh
  • flash-version-local.sh

Beispiele für Custiomization

Das Custiomizationscripting soll durch das folgende Beispiel veranschaulicht werden. Beispiel:

In einem jffs2-Image wird dies gewünscht:

  1. Eigene /etc/hosts benutzen,
  2. Eigene neutrino.conf, bouquets.xml, services.xml benutzen
  3. einschließlich lirc-Komponenten, zusammen mit eigenen lirc Konfigurations-Dateien.

1. und 3. sind Erweiterungen, die nach $(flashprefix)/root kommen sollten, während 2. Neutrino-regeln sind, welche nach sollten $(flashprefix)/root-neutrino-jffs2 gehöhren.
Um 1. und 3. zu erreichen, wird das Script root-local.sh erstellt, z.B.:

#!/bin/sh
# root-local.sh
flashprefix=$1
buildprefix=$2
newroot=$flashprefix/root
myfiles=/home/somewhere/dbox/myfiles
cp -f  $myfiles/etc/hosts $newroot/etc
make flashlirc
cp -fr $myfiles/var/tuxbox/config/lirc $newroot/var/tuxbox/config

Das Script für 2. heist root-neutrino-local.sh, was dem verherigen sehr ähnlich ist:

#!/bin/sh
# root-neutrino-local.sh
flashprefix=$1
buildprefix=$2
newroot=$flashprefix/root-neutrino
myfiles=/home/somewhere/dbox/myfiles
cp $myfiles/var/tuxbox/config/neutrino.conf	 $newroot/var/tuxbox/config
cp $myfiles/var/tuxbox/config/zapit/bouquets.xml $newroot/var/tuxbox/config/zapit
cp $myfiles/var/tuxbox/config/zapit/services.xml $newroot/var/tuxbox/config/zapit

Bitte beachten: Diese Scripte sollen als Beispiele dienen und können vermutlich nicht ohne Anpassung verwendet werden.

Einige "best practices"

In diesem Abschnitt befinden sich einige Richtlinien, die zwar nicht zwingend "notwendig" sind, um korrekte Ergebnisse zu erzeilen, jedoch werden sie langfristig helfen, bessere, zuverlässigere und pflegbare Software zu erstellen. Dies betrifft Customizations, sowie zukünftige Änderungen am Makefile und deren Bestandteilen selbst.
Wenn man diese Richtlinien nicht mag, kann ma sie ignorieren, zumindest wenn man Customization Scripte für den eigenen Bedarf schreibt.

Idempotens

Es ist fast immer eine gute Idee zu versuchen, ein Installationsscript idempotent zu schreiben. Dies bedeutet, dass das mehrmalige Ausführen den gleichen Effekt hat wie das einmalige Ausführen. Benutze "make install".
In der Vergangenheit hat das Tuxbox Makefile die Komponenten zuerst in $(targetprefix) installiert, und dann die Imageverzeichnisse durch Kopieren der einzelnen Files aus der $(targetprefix) Hierarchie erstellt. Dieses ist nicht sehr gute Softwaretechnik.
Zuerst gehört das Know-how bzgl. Installation des Paketes in das Makefile des Pakets, und soll nicht einem einzigem großen Makefile sitzen, das einfach einzelne Files rüberkopiert. Wenn dieses Paket sich ändert, z.B. man ein Konfigurations-File hinzufügt oder löscht, wird es auch notwendig, das globale Makefile zu ändern.

Es ist häufig der Fall, dass das Makefile, das ein Paket gehört, include-Files, (statische) Bibliotheken, Info-Files etc. installiert, die nicht auf einem enbedded System mit beschränktem Speicher erwünscht sind. Die korrekte Lösung zu diesem (wirklichen!) Problem wäre, das Makefile mit einen Pakets zu ändern, entweder, um ein flashinstall-Target zu schreiben, oder das Makefile mit einem Parameter wie installsize=[full,flash] zu versehen.
Wenn dies nicht durchführbar ist, ist es durchaus sinnvoller, daß nach make -C ... install das Löschen unerwünschten Files besser ist, als das kopieren einzelner Files.
Zu erwähnen ist auch, daß in dem Schritt, der die Verzeichnisse $(flashprefix)/root-gui-filesystem erzeugt, das include-verzeichnis, sowie alle statischen Bibliotheken gelöscht werden und dynamische Bibliotheken von unbenutzten Symbolen gestrippt werden.


Antworten auf einige Fragen

Falls das Build nicht gelingt

Es gibt kein Standardverfahren was zu tun wäre, wenn das Build misslingt. Es wird versucht, hier einige Richtlinien zu geben und diese zu lesen bevor man im Forum postet.

Zuerst, überprüft man den Output der ersten zwei Schritte, autogen.sh und configure auf Fehler und Warnungen. Jede Warnung oder Fehler, außer den fünf Warnungen, die oben genannt wurden, zeigen ein Problem an, dass ein Build wahrscheinlich unmöglich macht.

Wenn ein Build abbricht, kann es die Umgebung in einem inkonsistenten Zustand versetzen. Dies gilt insbesondere für die Verzeichnisse in $(flashprefix). Wenn der Bau solch eines Make-Targets abbricht, besteht das Verzeichnis, ist entsprechend ihrer Änderungszeit aktuell, und ein folgender make Befehl behandelt ihn wie fertig und okay.

Selbstverständlich wird ein fehlerhaftes Build das Ergebniss sein. Wenn ein Build eines Unterverzeichnisses von $(flashprefix) in die Brüche geht, dann lösche man es, bevor ein anderer Make Befehl ausgeführt wird.

Bei "es funktionierte gestern"-Problemen, ist vermutlich die Umgebung in solch einem Zustand. Ein mehr-oder-weniger drastischer Reinigungsbefehl (siehe oben) ist hierbei oft schneller als eine Problemsuche.

Wenn man Hilfe benötigt, siehe unten!.


Nach dem Flashen bekomme ich "Kein System" auf dem LCD/Was ist diese "bad magic byte" Zeugs?

Diese Frage kommt hoffentlich nicht... Die kurze Antwort ist: Man weiß es nicht. Wir wissen es nicht. Aber, wenn Ihr diesen Artikel so weit gelesen habt, erwartet bitte keine "kurze Antworten", sondern "gute Antworten". O.K. Das Thema ist ausführlich hier besprochen worden. Kurz gesagt, das Image "ist" in Ordnung, es ist nur dass irgendwelche Firmware in der dBox es zurückgewiesen wird, weil es einige "schlechte magische Bytes" auf bestimmten Adressen findet.

Das Programm checkImage aus dem CVS, zu finden im Verzeichnis ./hostapps/checkImage ermittelt die "schlechten Bytes", aber es macht nichts, um diese zu beheben. Die Erfahrung sagt, daß Images, die checkImage für gut findet, wirklich laufen. Cramfs-, oder squashfs Images, worüber sich checkImage beschwert, laufen im allgemeinen nicht, in einigen Fällen läufen sie aber doch.

Auch bei jffs2-images ist dies manchmal der Fall, dass sich checkImage beschwert, laufen, aber nicht immer. Mit diesen empirischen Beobachtungen ist man nun sich selbst überlassen.

Newmake weiß, wie dieses Programm angerufen werden kann, um die erzeugten Images automatisch zu überprüfen. Die Konfigurationsoption

--with-checkImage=[none,rename,warn] 

wird hier dazu verwendet. Falls warn gewählt ist, wird für jedes Image, das den Test nicht besteht, eine leere Datei erzeugt, am Namen wird "_bad" angehängt. Wenn rename gewählt wird, wird das fragliche Imagefile nur umbenannt indem "_bad" angehängt wird.

Es muss erwähnt werden, daß die "schlechten magischen Bytes" in einem (oder mehreren!) der Partitionsteile sitzt, und werden nicht durch den abschließenden Schritt erzeugt (die *.img1x und/oder *.img2x Files bauen). Es ist möglich, checkImage auf die Partitionsfiles anzuwenden *.jffs2, *.cramfs

  • .squashfs
  • .flfs1x
  • .flfs2x

Schließlich hat checkImage eine Debugoption, die nützlich sein kann.


Ich habe ein Fehler gefunden!

Bugs, Unklarheiten, Verbesserungsvorschläge, etc. der Software sollten vorzugsweise im Cross Development Kit - Forum des Tuxbox-Boards gepostet werden.


Ich benötige Hilfe!

Supportanfragen können im Cross Development Kit - Forum des Tuxbox-Boards gepostet werden. Postings in deutsch oder englisch sind willkommen. Bitte nicht vergessen, die benutzten Konfigurationsoptionen zu erwähnen.


Anhang

Einige nützlichee Customization Script Snippets

In diesem Anhang werden einige nützliche Customization Scripte gezeigt. Zwei Scripte sind bereits oben gezeigt worden.

Warnung Auch falls die Beispiele in einigen Fällen benutzbar sind, werden die Scripte als Beispiele, nicht als Lösungen zu den realen Problemen gezeigt. Aus diesem Grund sind die Beispiele hier als Codefragmente, nicht als downloadbare Dateien, veröffentlicht. Bitte nicht verwenden, es sei denn es ist ungefährlich und Ihr versteht, wie sie funktionieren. Es ist grundlegende Script-Erfahrung erfordelich.

Games und Languages nuker

Dieses Script löscht alle Spiele (definiert als plugins mit type=1 in ihrer Konfigurationsdatei), sowie unerwünschte Sprachfiles (Neutrino angenommen). Das File sollte von root-neutrino-$filesystem-local.sh aufgerufen werden.

#!/bin/sh
# Nukes all game plugins, as well as all locale files not listed in LANGUAGES
newroot=$1/root-neutrino-jffs2
LANGUAGES="deutsch english"
for f in $newroot/lib/tuxbox/plugins/*.cfg; do
   grep 'type=1' $f>/dev/null && rm -f $newroot/lib/tuxbox/plugins/`basename $f .cfg`.*
done
for f in $newroot/share/tuxbox/neutrino/locale/*; do
   (echo $LANGUAGES | grep -v `basename $f .locale` >/dev/null) && rm -f $f
done


/.version anpassen

Euere eigene /.version-File herzustellen (anggezeigt von Neutrino durch dBox -> Services -> Image-Version und cdkVcInfo beim Botten) ist sicher ein allgemeiner Wunsch.

  • flash-version-local.sh
#/bin/sh
USER=$(whoami)
if [ $0 = $CDIR/flash-version-local.sh ] ; then
   outfile=$FLASHDIR/root/.version
   type="Image"
else
   outfile=$TARGETDIR/.version
   type="Yadd"
fi;
echo Creating $outfile ...
echo "version=`./mkversion -snapshot -version 200`"      > $outfile
echo "creator=$USER"                                     >> $outfile
echo "imagename=$USER-$type"                             >> $outfile 
echo "homepage=http://www.your-website.de"                   >> $outfile


mkversion

Das benannte Script mkversion stellt die etwas kryptische Versionszeichenkette her und ist einfach eine "Verkapselung" davon. Es wird hier gezeigt:

#!/bin/sh
releasetype=3
versionnumber=000
year=`date +%Y`
month=`date +%m`
day=`date +%d`
hour=`date +%H`
minute=`date +%M`
while expr $# > 0 ; do
case "$1" in
    -release) 
    releasetype=0
  ;;	
    -snapshot) 
    releasetype=1
  ;;	
    -internal) 
    releasetype=2
  ;;
   -version)
    versionnumber=$2
  shift
  ;;	
esac
shift
done
echo $releasetype$versionnumber$year$month$day$hour$minute


Archivierung der Images

Es ist eigentlich die Aufgabe des Buildprozesses, flashbare Images zu erzeugen, und nicht sie zu archivieren. Jedoch kann die Customization leicht dazu "missbraucht" werden, um irgendeine Art der Archivierung zu ermöglichen, wie das folgende Beispiel zeigt:

#!/bin/sh
flashprefix=$1
imagefile=`basename $0|sed -e s/-local.sh//`
imagefilebase=`echo $imagefile|sed -e s/\.img.x//`
extension=`echo $imagefile|sed -e s/[-a-z0-9]*\.//`
newfilename="barf-"$imagefilebase-`date --iso-8601`.$extension
echo Copying $flashprefix/$imagefile to $flashprefix/$newfilename...
cp $flashprefix/$imagefile $flashprefix/$newfilename

Das Script sollte einen oder mehr der Namen

[neutrino, enigma]-[cramfs, squashfs,jffs2].[img1x, img2x]

haben. Es benennt die Files entsprechend dem Tagesdatum um.


Links



Review-KandidatDieser Artikel befindet sich derzeit im Reviewprozess. Hilf mit, ihn zu verbessern! Falls du bei weiteren Artikeln helfen willst, findest du hier eine Auswahl offener Artikel.