Cubietruck als Mini Server

Cubietruck als Heimserver

Zur Vorbereitung sollte man sich die die Tutorials von www.cubian.org durchlesen und das aktuelle cubian Image für das Cubieboard 2 auf eine Micro-SD-Karte schreiben.
Diese Anleitung enthält viele Schnipsel aus den Anleitungen im Internet. Diese Anleitungen sind alle auf einer eigenen Seite aufgeführt.
Sollte es beim lesen dieser Anleitung schon eine fertiges Cubian Image für denCubietruck geben, erübrigt sich der ganze Aufwand mit Kernel selbst bauen.
Im Netzwerk sollte ein DHCP-Server (Router des Heimnetzwerks) laufen und der Zugriff aufs Internet ohne Proxy-Anmeldung möglich sein.
Damit genügen Speicherplatz vorhanden ist, würde ich eine 2,5" SSD mit mindesten 120 GB verwenden.
Der Umgang mit verschiedenen GNU/Linux Befehlen muss vorausgesetzt werden.

Die Shell an sich.
fdisk zum Partitioniern von Festplatten
mkfs.ext4 zum Formatieren der Systempartition.
mkswap zum anlegen der Swappartition.
nano oder vi als Editor.
mkdir zum anlegen von Verzeichnissen.
rsync zum kopieren des Systems von der SD-Karte auf die SSD
Es würde nicht schaden, wenn man schon mal eine Kernel selbst kompiliert hat.

Vorbereitungen:

Cubietruck zusammenbauen:

Den Cubietruck auspacken und mit der SSD zusammenbauen.

Installation der Tools:

apt-get install build-essential libncurses5-dev u-boot-tools qemu-user-static debootstrap git binfmt-support libusb-1.0-0-dev pkg-config
apt-get install gcc-arm-linux-gnueabihf

Download der sunxi-Tools als Quelltext:
mkdir ~/cubie
cd ~/cubie
git clone git://github.com/linux-sunxi/u-boot-sunxi.git
git clone git://github.com/linux-sunxi/sunxi-tools.git
git clone git://github.com/linux-sunxi/sunxi-boards.git
git clone http://github.com/cubieboard/linux-sunxi.git
git clone https://github.com/cubieboard/cubie_configs

Schritt 1: Cubian Image für Cubieboard 2 besorgen unter http://cubian.org/downloads/ und entpacken.
Schritt 2: Das Cubian-Image auf die Micro-SSD schreiben und das Root-File-System auf die ganze Karte ausdehnen, die Karte sollte 2 GB oder größer sein. sdx ist durch die Gerätedatei der Micro-SD-Karte zu ersetzen.

dd if=[IMAGE-DATEI] of=/dev/sdx bs=4096; sync

Falls notwendige die Karte aushängen.

umount /media/cubieboard

Das Root-Datei-System auf die maximale Größe ausdehnen.

Mit fdisk die Partition /dev/sdx1 löschen und neu anlegen mit der maximalen Größe.
Nun die Größe des Dateisystems anpassen.
 
resize2fs /dev/sdx1

Die Karte auswerfen und wieder einlegen.

Schritt 3: Wenn man keinen geeigneten Monitor mit HDMI Eingang hat, dann muss man die Konfigurationsdatei script.bin anpassen, damit der VGA Ausgang aktiviert wird.

Zum bearbeiten der Konfigurationsdatei sribt.bin benötigt man die Tools von SUNXI.

cd ~/cubie/sunxi-tools
make
cd ~/cubie
sudo cp /media/cubieboard/boot/script.bin ./
sudo cp /media/cubieboard/boot/script.bin /media/cubieboard/boot/script-bin.org
./sunxi-tools/bin2fex script.bin > script.fex
nano script.fex

Jetzt ist der erste Teil der Sektion [disp_init] anzupassen.
[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 4
screen0_output_mode = 4
screen1_output_type = 2
screen1_output_mode = 14

Umwandeln in die Binär-Datei
./sunxi-tools/fex2bin script.fex > script.vga

Auf die SD-Karte kopieren:
sudo cp script.vga /media/cubieboard/boot/script.bin

Schritt 4: Kernel kompilieren und installieren.

Den Kernel bauen wie im Tutorial auf cubieboard.org beschrieben http://docs.cubieboard.org/tutorials/ct1/development/compiling_latest_kernel_for_cubietruck_cubieboard3

Ein Sicherungskopie des Kernels auf SD-Karte anlegen.
sudo cp /media/cubieboard/boot/uImage /media/cubieboard/boot/uImage.org

Den Kernel aus linux-sunxi/arch/arm/boot nach /media/cubieboard/boot/uImage kopiern.
Die Kernel-Module auf die Karte installieren.

cd /media/cubieboard
make -C ~/cubie/linux-sunxi INSTALL_MOD_PATH=`pwd` ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- modules_install

Schritt 5: Von der SD-Karte starten und das System testen

Die Micro SD-Karte in den Cubietruck einlegen, bis auf den Strom die Kabel anschließen.
Jetzt den Strom anschließen.
Nach den Boot-Meldungen sollte sich das System irgendwann mit dem Login-Prompt melden.

Mit User cubie und Passwort cubie anmelden.
Zu Root werden.

sudo su

cat /proc/partitions

Es sollte so ähnlich ausshen:

major            minor        #blocks            name

93        0    7520256 nand
93        1       1024 nanda
93        2        256 nandb
93        3    7502592 nandc
   8        0 125034840 sda
179        0    1902592 mmcblk0
179        1    1901568 mmcblk0p1

ifconfig

Es sollt so oder so ähnlich aussehen:

eth0      Link encap:Ethernet Hardware Adresse c8:60:00:4f:52:34
          inet Adresse:10.210.0.101 Bcast:10.210.0.255 Maske:255.255.255.0
          inet6-Adresse: fe80::ca60:ff:fe4f:5234/64 Gültigkeitsbereich:Verbindung
          UP BROADCAST RUNNING MULTICAST MTU:1500 Metrik:1
          RX packets:31322 errors:0 dropped:0 overruns:0 frame:0
          TX packets:24192 errors:0 dropped:0 overruns:0 carrier:1
          Kollisionen:0 Sendewarteschlangenlänge:1000
          RX-Bytes:33582591 (33.5 MB) TX-Bytes:3039844 (3.0 MB)
          Interrupt:53

lo        Link encap:Lokale Schleife
          inet Adresse:127.0.0.1 Maske:255.0.0.0
          inet6-Adresse: ::1/128 Gültigkeitsbereich:Maschine
          UP LOOPBACK RUNNING MTU:16436 Metrik:1
          RX packets:2477 errors:0 dropped:0 overruns:0 frame:0
          TX packets:2477 errors:0 dropped:0 overruns:0 carrier:0
          Kollisionen:0 Sendewarteschlangenlänge:0
          RX-Bytes:442846 (442.8 KB) TX-Bytes:442846 (442.8 KB)

Schritt 6: Die SSD partitonieren und formatieren.

fdisk /dev/sda

Eine primäre Partition sda1 vom Typ 82 Linux anlegen mit einer Größe von HD-Kapazität minus 2 GB.
Den Rest der Platte als primäre Partition Typ 83 Swap, sda2 einrichten

fdisk.ext4 /dev/sda1
mkswap /dev/sda2

System stoppen:

halt

Schritt 7: Das Root-File-System von der SD-Karte auf die SSD übertragen.
Die SSD mit einem Adapter an einen Linux-PC anschließen und die SSD-Karte mit einem Kartenleser anschließen.
Die SD-Karte nach /mnt/alt mounten.
Die Root-Partition auf der SSD als /mnt/neu mounten.

Jetzt die Daten per rsync kopieren.

sudo su
rsync --stats --progress --numeric-ids -aAhHSP /mnt/alt/ /mnt/neu/
rsync --stats --progress --numeric-ids -aAhHSPc /mnt/alt/ /mnt/neu/

Mit dem Editor der Wahl /mnt/neu/etc/fstab anpassen

/dev/sda1   /      ext4    errors=remount-ro 0       1
/dev/sda2    none    swap    sw                0       0

Jetzt muss noch das boot.scr angepasst werden, damit der Kernel /dev/sda als rootfs nimmt.

cd /mnt/alt/boot
cp boot.scr boot_scr.org
nano boot.cmd

Den Eintrag root=/dev/mmcblk0p1 auf root=/dev/sda1 ändern, speichern + beenden und aus der boot.cmd die boot.scr erzeugen.
image -C none -A arm -T script -d boot.cmd boot.scr

Die Partitionen aushängen und die SSD und die SD-Karte in den Cubietruck einbauen.
Jetzt den Cubietruck starten.
Der Cubietruck sollte jetzt den Kernel von der SD-Karte booten und das Root Filesystem von der SSD starten.

Bei mir sieht ein df etwa so aus (128 GB SSD):

Dateisystem    1K-Blöcke Benutzt Verfügbar Verw% Eingehängt auf
rootfs         121790564 1355860 114248108    2% /
/dev/root      121790564 1355860 114248108    2% /
devtmpfs          415344       0    415344    0% /dev
tmpfs              83092     176     82916    1% /run
tmpfs               5120       0      5120    0% /run/lock
tmpfs             426540       0    426540    0% /run/shm
tmpfs             415452       4    415448    1% /tmp
tmpfs             415452       0    415452    0% /var/tmp

fest IP einrichten

apt-cacher-ng
Es muss unbedingt das aktuelle Paket von Projekt-Hompage genommen werden.
http://ftp.debian.org/debian/pool/main/a/apt-cacher-ng/?C=M;O=D

WSUSS-Offline
Die aktuelle Version gibt es unter: http://download.wsusoffline.net/
das ZIP-File runterladen, auspacken nach /srv/ctupdate und die sh-Datei 1 x die Woche per Cron mit den richtigen Optionen starten.

Dnsmasq

Liste der Offenen Punkte:

Den HDMI-Ausgang so konfiguriern, dass der auch mit alten DVI-Monitoren funktioniert. Das scheint laut eines Foren-Betrags auch ein Problem der Kernel Konfiguration sein.
Die Konfiguration von /dev/ttyUSB0 automatisieren.

Wolfgang Kutscherauer kutschi@dingolfing.org