courten

IT-Rechtsberatung

Angepasste Linux-Systeme entwickeln mit T2 SDE

RA Felix von Courten,

infoB7A175CEF3D2AE2A062D@9BF54195685F0AEC25DBra-courten.de

http://courten.de/pub/2010/index.html

8. Kieler Open Source und Linux Tage, 1+2 Oktober 2010

Angepasste Systeme

Einhaltung von Standards
unabhängig von früheren/anderen Versionen
optimiert auf Plattform und Bedürfnisse
geringer Ressourcenverbrauch
disabled feature by default
Snapshots oder Releases erstellen
verschiedene Installationsmöglichkeiten: Laufwerk, Netzwerk

mehr als nur eine Linux-Distribution...

T2 SDE: www.t2-project.org

...sondern ein flexibler Baukasten optimiert für maßgeschneiderte Linux-Systeme

quelltextorientiertes Paketsystem: über 3000 Pakete
automatisiertes Build-System
auf cross-compiling ausgelegt:
- portierbar: unterstützt alle gängigen Architekturen
- skalierbar: vom Embedded System, bis zur Workstation
stable Release: T2 8.0 oder Entwicklerversion T2 trunk 9.0

Das Paketsystem von T2 SDE

http://www.t2-project.org/packages/

T2-Paket = Source + Patches + Meta-Informationen

Sourcen statt vorkompilierter Pakete
keine Package-Maintainer
coreutils statt aufwendiger Paketverwaltung
so wenig Patches wie möglich
stets aktuelle Paketversionen

Das Build-System

in Shell-Skripten geschrieben:
```
scripts/.
```
funktionsspezifisch: ./scripts/Config ./scripts/Download ./scripts/Build-Target
abrufbare Metainformationen:
```
package/.
architecture/.
target/.
```
stabil: Builds erfolgen in einer Sandbox und Chroot-Umgebung
auf cross-compiling ausgelegt

Die Build-Skripte

Die Build-Skripte steuern den kompletten Installationsablauf eines neuen System oder Pakets:

Auslesen der Metainformationen (Parsing)
Download und Entpacken der Tarballs
Anwendung der in T2-SDE aufgenommenen Patches
Bestimmung des Build-Typs configure, make, xmkmf, cmake...
Kompilieren mit den zuvor generierten Konfigurationseinstellungen
Installation:
- in einer Sandbox des Build-System:
```
builds/...
```
- im Verzeichnis des bereits fertigen Target-Systems
```
/
```

cross-compiling

Build System ---cross-compiling ---> Target-System

anderer Prozessor: Alpha,ARM,AVR32,Blackfin,IA64,Motorola 68k,MIPS,MIPS64,PowerPC,PowerPC64,SPARC,SPARC64,SuperH,x86,x86-64
anderes Betriebssystem: Server, Workstation, Embedded System
Kombination aus beidem: Compiler der auf einem Intel-basiertem Linux System läuft und Programme für unter Linux lauffähige Smartphones erzeugt.

cross-compiling: portierbar + skalierbar

T2 SDE: Installation

http://t2-project.org/download

Build-System ---> Target-System

vorkompilierte ISO Images (Minimal-Build) herunterladen (nicht empfohlen)

Mirror auswählen, brennen, booten

Das System vom Source-Code aufbauen (empfohlen)

Tarball herunterladen und entpacken oder Repository mit SVN auschecken
tar xvjf t2-8.0.tar.bz2 -C mein-t2 oder svn co http://svn.exactcode.de/t2/branches/8.0 mein-t2
Ins Verzeichnis wechseln und Build-Skripte ausführen

Einrichtung des Build-Systems

T2 setzt ein bereits vorhandenes einfaches Linux voraus:

Compiler: gcc
GNU tools: cat, cut, sed
C-libs: ncurses
Shell: bash
Netzzugang
Zugriff als root

Bau des Target-Systems

Shell aufrufen, in das Verzeichnis wechseln und Build-Skripte ausführen:

./scripts/Config
./scripts/Download
./scripts/Build-Target

Konfiguration
Download der Paketquellen
Eigentlicher Kompilationsprozess

Konfiguration des Target-Systems

.scripts/Config

Hardwareprofil auswählen
Paketumfang festlegen
Distributionsmedium bestimmen (Install CD, Live CD, nur Pakete)
Optionen setzen

Herunterladen der Paketquellen

./scripts/Download --required

Mirror auswählen

./scripts/Downloads -mirror http://www...

Fehlende Pakete ermitteln
```
.scripts/Download -list-missing
```
Neue URL für den Download festlegen: editieren von paket.desc
Integrität der Pakete prüfen
```
./scripts/Download -check -all
```

Der Kompilationsprozess

Als root auführen:

./scripts/Build-Target

Während der Kompilation wird eine chroot Umgebung verwendet. Nur root darf grundsätzlich den befehl chroot ausführen.
Einige Programme erfordern speziell festgelegte Rechte, Benutzer oder Benutzergruppen. Nur root kann grundsätzlich diese Privilegien setzen bzw. Nutzer und Gruppen anlegen.
Vorkompilierte Libs oder Tools wie fakeroot kommen nicht mit den Metaskripten zurecht

Vorbereitung der Installation

Auf fehlerhafte Builds prüfen:

./scripts/Create-ErrList

Buildverzeichnisse entfernen:

./scripts/Cleanup

Installation des Targetsystems

ISO Image erstellen
```
./scripts/Create-ISO meinLinux
```
- meinLinux_*.iso auf CD-ROM oder DVD brennen
- in einer Virtuellen Maschine testen
Bau einer Variante jeweils mit Option -cfg meinLinux
```
./scripts/Config -cfg meinlinux
./scripts/Download -cfg meinLinux
./scripts/Build-Target -cfg meinLinux
```
- Verzeichnis build/meinLinux auf neue Platte/Partition kopieren
- Testen mit chroot build/meinLinux
und zuletzt booten...