Thin Client evo T20

aus PUG, der Penguin User Group
Wechseln zu: Navigation, Suche

Da sich gerade einige von der Liste den Thin Client "evo T20" von Compaq ersteigern, hier ein Artikel der eine sinnvolle Betankung dessen erleichtern soll. Ich möchte alle, die Erkenntnisse gesammelt haben ermuntern, diesen Artikel fröhlich zu erweitern.

Betankung mit Original Software

Die Win* Methode

Sorry, ich finde es gehört dazu.

  • 1. Image (...Binary Firmware...) und Nexfer von der Compaq Seite ziehen.
  • 2. Nexfer nach C:\Nexfer auspacken.
  • 3. Das Image in obiges Verzeichnis werfen und in "bootp.bin" umbenennen.
  • 4. Die IP Adressen in "bootpmap" und "btptab" anpassen.
  • 5. Ein DHCP auf dem Router kann an bleiben weil andere Ports verwendet werden.
  • 6. nexfer.exe starten. Wenn es wegen Java nicht läuft: fluchen und die Linux variante nehmen.
  • 7. Den evo resetten und 'p' gedrückt halten...

Wenns flaschd, nicht stören!

Nach dem flashen nexfer.exe beenden, damit Windows keine Würmer kriegt.

Nachtrag von li-la: "Evo T20 and T30 Netxfer Tool for Loading Firmware" findet sich inzwischen bei HP:

http://h20000.www2.hp.com/bizsupport/TechSupport/SoftwareDescription.jsp?lang=en&cc=us&swItem=PSG_I16129-38624&jumpid=reg_R1002_USEN

Unter windows wird eine inzwischen veraltete MS-Java Version genommen. Neuere Sun Java gehen nicht. Bei mir funktionert auf einem frisch installierten Win2000 ohne SP die Nachinstallation von: msjavx86.exe

Meine Version ist: 5.00.3805 Sprache: Englisch (USA) Google hilft die passende Version zu finden, MS selbst bietet das NICHT mehr an. Auf einer meiner alten CDs fand sich meine Version.

Die Linux Methode

Du brauchst einen dhcpd und einen tftp

DHCP

Das Config vom dhcpd sieht so aus: 

# dhcpd.conf
#
ddns-update-style interim;
subnet 192.168.0.0 netmask 255.255.255.0 {
# Das ist die Nummer vom TFTP Server
option routers 192.168.0.22;
next-server 192.168.0.22;

pool {
          option domain-name-servers bogus.example.com;
          max-lease-time 300;
          range 192.168.0.200 192.168.0.253;
          allow unknown-clients;
          filename "bootp.bin";
        }
}

Es steht in "/etc" oder "/etc/dhcp". Ein anderer IP Kreis ist nicht nötig, weil gesoderte Portnummern benutzt werden.

Wer das ganze ein wenig einschränken möchte, macht dann irgendwie sowas in der Config (anstelle von 'pool'): 

host ThinClient {
  hardware ethernet 00:80:64:1A:E4:82;
  fixed-address 192.168.0.199 ;
  filename "bootp.bin";
  }


TFTP

Ich hab den hpa-tftp genommen, weil den Denny in seinem LTSP Leitfaden auch verwendet. Dann habe ich das Image nach /var/tftp/bootp.bin kopiert.


Starten

Wir müssen beim Starten auf die verwendeten Ports achten. 

# in.tftpd -a 192.168.0.22:10069 -l -v -s /var/tftpboot 
# dhcpd -p 10067

Jetzt den ThinClient resetten (10s Knopf drücken) und 'p' festhalten bis NETXFER kommt. Beim Flashen nicht stören. Das Runterladen des Images geht schnell. Das Image wird validiert und dann geschrieben, wobei auch die Dateigrößen von poweron.bmp, filesys0.img und filesys1.img angezeigt werden.

Sollte NETXFER "Upload failed" und in.tftpd "RRQ from $IP filename bootp.bin" (syslog) melden, liegt das wahrscheinlich an einem defekten Netzwerkkabel oder Switch/Hub.

Erstellung eines Etherbootimages

Vorwort

Hier geht es darum ein Image für den EVO T20 zu erstellen, welches ihn in die Lage versetzt vom Netzwerk zu booten. Dieser Vorgang wird oft auch PXE genannt. Dies versetzt den ThinClient wieder in einen brauchbaren Zustand z.B. für [LTSP]. Denny hat zu dazu ein Howto für die Pug geschrieben (der EVO kommt darin nicht vor).

Downloads

Diese Software wird benötigt:

Entpacken des Images

Zuerst die Tools entpacken 

$ tar -xvzf bundle-tools-0.7.tar.gz

danch die U96CPQ150.bin in das Verzeichnis kopieren. 

$ cp U96CPQ150.bin bundle-tools

dann in das Verzeichnis wechseln Nun müssen wir den bootstrap Code von NetXfer von dem Image extrahieren. 

$ dd if=../U96CPQ150.bin of=netxfer bs=512 count=577

Danach 

$ make

ausführen Etwas wie dies sollte dabei rauskommen 

cc -Wall    fwextract.c   -o fwextract
cc -Wall    fwcs.c   -o fwcs
Runing extract_head.pl now. If this fails, you might have to run it by hand
to specify the right sample bundle.
./extract_head.pl
Couldn't find bundle signature, maybe this is a NetXfer image? Yes, it is.
Don't forget to save the NetXfer bootstrap! See README for more information.
fwhead.h successfully created
cc -Wall fwpack.c -o fwpack
make: *** No rule to make target `fwupload', needed by `all'.  Stop.

Den Error wegen dem fwupload ignoriere ich mal getrost :D.

Entpacken des Bundels 

$ ./fwextract U96CPQ150.bin extrakt

Dabei sollte so was rauskommen 

This seems to be a NetXfer image, skipping the NetXfer bootstrap.
Offset    Size      Checksum  SysFlg  BiosFlag  Time      Filename
00000178  00040000  061b3e1a  010000  00010000  3b532e4f  ulc_code.ce
00040178  00000014  fdf207f8  010000  00020000  3b056f82  k
0004018c  00040000  8166c7a0  010000  00020000  3b2a67fe  ulc_code.bin
0008018c  00000005  cacae1ac  010000  00020000  3af73b79  os.ver
00080194  00003728  24dc5849  010000  00020000  3b1bed43  poweron.bmp
000838bc  01e40000  1cc6f0ac  010000  00020000  3b532e3e  filesys0.img
01ec38bc  01f40000  b7b46758  060003  00020000  3b532e3e  filesys1.img
03e038bc  01f40000  81312caf  060004  00020000  3b532e3e  filesys2.img

Damit ist dieser Teil schon mal erledigt! Vielen Dank noch ein mal an die Erschaffer der Tools!

GRUB

GRUB ist ein Multistage Boot-Loader . Er dient hier dazu das Etherbootimage zu starten.

Ich habe alle Schritte ausgeführt um GRUB zu ändern, die auf Kazaks Seite angegeben waren. Daraus habe ich diesen Patch erstellt. Damit ich mir merken kann wie man das macht 

$ diff -uNr grub.org grub | gzip -c -9 >  grub.patch.gz

Um den Patch anzuwenden muss man zuerst die GRUB Legacy Sourcen herunterladen, 

$ cvs -z3 -d:pserver:anonymous@cvs.savannah.gnu.org:/sources/grub co grub

um danach den Patch einzuspielen. 

$ zcat grub.patch.gz | patch -p0 2>&1 | tee patch.out

Nun die Datei compile-with-etherboot.sh ausführen. 

$ sh compile-with-etherboot.sh

Als nächstes müssen wir die Größe des Stage2 loaders herausfinden. Diese kann je nach verwendetem Compiler unterschiedlich groß sein. 

$ dd if=/path/to/grub/stage2/stage2 of=/tmp/test bs=512

Dabei sollte so etwas heraus kommen 

171+1 records in
171+1 records out
87828 bytes (88 kB) copied, 0.00172 seconds, 51.1 MB/s

Dies bedeutet, dass der Stage2 Loader 172(171+1) Blocks groß ist. Dieses Wissen benötigen wir gleich. Zuerst müssen wir aber noch die Größe des Etherbootimages heraus finden. 

$ dd if=/path/to/eb-5.4.2pre2-natsemi.zlilo of=/tmp/test bs=512

Die Größe wie oben notieren (bei mir war es 50 (49+1))

Nun machen wir ein "make clean". 

$ make clean

Dies löscht die compilierte Version von GRUB wieder. Dann müssen wir die Datei presetmenu.etherboot mit dem Lieblingseditor bearbeiten. 

default 0
timeout 0
title Etherboot
kernel 175+50

Mit der presetmenu.etherboot Datei sagen wir GRUB wo denn das Etherbootimage liegt. Die Option bei GRUB nennt sich block lists.

Die erste Zahl errechnet sich wie folgt:

  • Der Erste Sektor ist der MBR wird aber von dem BIOS ignoriert
  • Im 2. Sektor liegt der Stage 1 Bootloader (kommt bald da hin)
  • Bei mir ist der Stage2 loader 172 Sektoren groß
  • Daraus ergibt sich 1 + 1 + 172 = 174
  • Also muss unser Etherbootimage später einen Sektor danach anfangen = 175

Die zweite Zahl ist die Anzahl von Sektoren die das Etherbootimage beansprucht (bei mir 50).

Nun muss die Datei gespeichert werden.

Danach wieder mit 

$ sh compile-with-etherboot.sh

compilieren. Mit dem Unterschied, dass GRUB nun weiß was er machen muss.

filesys0.img zusammenbauen

Nun wird GRUB in das Image "installiert" Zuerst der Stage1 Loader: 

$ dd if=/path/to/grub/stage1/stage1 of=/path/to/bundle-tools/filesys0.img bs=512 seek=1

Dann der Stage2 

$ dd if=/path/to/grub/stage2/stage2 of=/path/to/bundle-tools/filesys0.img bs=512 seek=2

Hier am besten noch einmal die Ausgabe überprüfen die Zahl sollte immer noch 171+1 sein (oder was bei dir beim ersten mal raus kam). Stimmen die Zahlen nicht überein muss die presetmenu.etherboot Datei noch einmal angepasst, make clean und sh compile-with-etherboot.sh ausgeführt werden.

Danach ist das Etherbootimage an der Reihe 

$ dd if=/path/to/eb-5.4.2pre2-natsemi.zlilo of=/path/to/bundle-tools/filesys0.img bs=512 seek=175

seek=175 mit seek=Zahl die bei die heraus kam ersetzen

Da die filesys0.img unnötig groß ist 

$ mv filesys0.img filesys0.img.big
$ dd if=/path/to/bundle-tools/filesys0.img.big of=/path/to/bundle-tools/filesys0.img bs=512 count=225

count=225 mit count=Zahl die bei dir bei kernel 175+50 = 225 herauskommt austauschen

bootp.bin erstellen

In das bundle-tools Verzeichnis wechseln 

$ cd /path/to/bundle-tools

Damit kann man nun das Image erstellen 

$/path/to/bundle-tools/fwpack bundle.bin ulc_code.ce k ulc_code.bin /path/to/poweron.bmp filesys0.img

Als nächstes müssen wir den NetXfer Teil wieder an das Image kleben. 

$ cat netxfer > bootp.bin && cat bundle.bin >> bootp.bin

Herzlichen Glückwunsch das Image ist erstellt. Folge bitte nun den Anweisungen zu NetXfer.

Damn Small Linux vom USB Stick booten

Vorwort

Ziel ist, ein Image zu erstellen, das DSL von einem USB-Stick bootet. Natürlich bleiben, wenn ausreichen Platz auf dem USB-Stick ist, die urprünglichen Daten auf dem Stick erhalten.

USB-Stick vorbereiten

Zuerst laden wir ein DSL Iso-Image von hier herunter, holen die benötigten Dateien heraus und packen sie auf den USB-Stick, bzw. auf die Festplatte. 

$ mount -t iso9660 -o loop /mnt/share/download/dsl-3.0.1.iso /mnt/test
$ mount /dev/sda1 /mnt/sda1
$ cp -r /mnt/test/KNOPPIX /mnt/sda1/
$ cp /mnt/test/boot/isolinux/linux24 /mnt/test/boot/isolinux/minirt24.gz ./
$ umount /mnt/sda1
$ umount /mnt/test

Beim kopieren der des KNOPPIX-Verzeichnisses wird alles kleingeschrieben, das stört aber nicht.

GRUB

Wir erstellen nun GRUB analog wie Bernhard das bereits gezeigt hat. Allerdings nehmen wir diesen Patch grub-dsl.patch.gz 

cvs -z3 -d:pserver:anonymous@cvs.savannah.gnu.org:/sources/grub co grub
wget http://www.plasoft.de/downloads/grub-dsl.patch.gz
zcat grub-dsl.patch.gz | patch -p0 2>&1 | tee patch.out

Nun ist es also an der Zeit die Größe des Kernels und der Initrd, die wir auf das Flash packen wollen, herauszufinden. 

$ dd if=linux24 of=/tmp/test bs=512
1942+1 records in
1942+1 records out
994807 bytes (995 kB) copied, 0,038385 seconds, 25,9 MB/s

$ dd if=minirt24.gz of=/tmp/test bs=512
1568+1 records in
1568+1 records out
803325 bytes (803 kB) copied, 0,035994 seconds, 22,3 MB/s

Für die erste Näherungsberechnung compilieren wir nun GRUB einmal mit untenstehender presetmenu Datei (die Werte können stimmen, sollten aber auf jeden Fall nochmal auf dem hier gezeigten weg kontrolliert werden)

Hier die Datei grub/presetmenu.dsl 

default 0
timeout 0
title Damn Small Linux
kernel 170+1943 root=/dev/hda1 ro vga=788 host=t20 fromhd=/dev/sda1 toram noagp nopcmcia noapm noswap noscsi desktop=jwm waitusb frugal restore=sda1
initrd 2114+1569

$ cd grub
$ sh ./compile-with-dsl.sh

Jetzt können wir die exakte Größe von stage2 feststellen, stage1 ist immer 512 Byte groß. 

$ dd if=stage2/stage2 of=/tmp/test bs=512
166+1 records in
166+1 records out
85176 bytes (85 kB) copied, 0,000896 seconds, 95,1 MB/s


Jetzt haben wir alle Größeninfos die wir brauchen um GRUB zu erklären wo Kernel und Initrd auf dem Flash zu finden sind. Was noch fehlt sind die Startaddressen. 

		size	start
MBR		1	0
stage1		1	1
stage2		167	2
kernel		1943	170
initrd		1569	2114
			3684

Nach der Korrektur der Datei presetmenu.dsl, einfach nochmal compilieren. 

$ make clean
$ sh ./compile-with-dsl.sh

Das Originalimage entpacken

Mit den bundle-tools das Originalimage wie hier beschrieben zerlegen. Wer die bundle-tools schon hat: 

$ cd bundle-tools
$ ./fwextract U64CPQ150.bin extrakt

Welches Originalbundle man wählt ist hierfür völlig egal

Das Image erzeugen

Der MBR des Original filesys0.img;Stage1;Stage2;Kernel;Initrd 

$ cd ..
$ dd if=bundle-tools/filesys0.img of=filesys0.img bs=512 count=1 
$ dd if=grub/stage1/stage1 of=filesys0.img bs=512 seek=1
$ dd if=grub/stage2/stage2 of=filesys0.img bs=512 seek=2
$ dd if=linux24 of=filesys0.img bs=512 seek=170
$ dd if=minirt24.gz of=filesys0.img bs=512 seek=2114

Ein neues Bundle mit den bundle-tools erstellen und den netxfer Code nicht vergessen. Dann ab zum flashen. Wer ein schickeres Startbild möchte nimmt vielleicht dieses Poweron.bmp. Wichtig: Der Dateiname beim nächsten Schritt muß poweron.bmp sein, also alles klein geschrieben. 

$ cd bundle-tools
$ ./fwpack bundle.bin ulc_code.ce k ulc_code.bin poweron.bmp ../filesys0.img
$ cat netxfer > bootp.bin && cat bundle.bin >> bootp.bin
$ cp bootp.bin /var/lib/tftpboot/

Todo

  • Sound

Bemerkung: Hier könnte evtl. schon das alsa.dsl-Paket abhilfe schaffen (lt. Beschreibung ist das Paket für DSL 2.0/2.1) (http://gd.tuwien.ac.at/opsys/linux/damnsmall/mydsl/system/alsa.dsl)

  • Uhrzeit, die Büchse vergisst leider beim herunterfahren die Zeit (siehe unten)

KNOPPIX-Dateisystem erweitern

Vorraussetzungen

Bevor wir überhaupt das KNOPPIX-Compressed-FS bearbeiten können, benötigen wir das Modul cloop.

Zuerst die Quellen holen 

$ cd /usr/src
$ wget http://debian-knoppix.alioth.debian.org/sources/cloop_2.04-1.tar.gz

Dann entpacken und ins neue Verzeichnis wechseln 

$ tar xfz cloop_2.04-1.tar.gz
$ cd cloop-2.04

Sodann erstellen wir das neue cloop-Modul mit unserem Kernel 

$ make KERNEL_DIR=/usr/src/linux

und kopieren das neue Modul zu den anderen... 

$ mkdir -p /lib/modules/2.6.17/misc && cp cloop.ko /lib/modules/2.6.17/misc/

dann noch die Module aktualisieren 

$ depmod -a

und das neue Device erstellen 

$ mknod /dev/cloop b 240 0
$ mknod /dev/cloop1 b 240 1

zuletzt noch das cloop-Modul laden 

$ modprobe cloop

Die beiden Tools create_compressed_fs und extract_compressed_fs kopieren wir noch ins bin-Verzeichnis, da wir diese später noch brauchen. 

$ cp create_compressed_fs /usr/bin/
$ cp extract_compressed_fs /usr/bin/

Damit können wir auf das KNOPPIX-Image zugreifen.

DSL-KNOPPIX-Image mounten

Das DSL-KNOPPIX-Image ist ein komprimiertes Dateisystem. Wir können dies einfach in ein iso-FS umwandeln: 

$ extract_compressed_fs /PATH_TO_KNOPPIX/KNOPPIX > /tmp/KNOPPIX.iso

Aus den knapp 50 MB werden dann über 120 MB.

Das KNOPPIX.iso können wir wie gewohnt mounten 

$ mount -o loop KNOPPIX.iso /mnt

Wollen wir das komprimierte Dateisystem direkt mounten, so geben wir folgendes ein: 

$ mount -o ro,loop=/dev/cloop1 /PATH_TO_KNOPPIX/KNOPPIX /mnt

Per chroot können wir direkt in das DSL wechseln: 

$ chroot /mnt
$ mount -t proc none /proc

Hinweis: Vor dem Verlassen der chroot-Umgebung das Proc-FS wieder unmounten!

Damit wir Änderungen an dem Image vornehmen können müssen wir das gesamte Image auf die Festplatte kopieren und von da aus dann die Änderungen/Anpassungen vornehmen: 

$ mkdir /tmp/knoppix
$ cp -a /mnt/* /tmp/knoppix/

DSL-KNOPPIX erweitern

XFree86

Als erstes binden wir XFree86 ein, damit wir die volle Auflösung unserer T20 geniessen können ;-) 

 $ cd /tmp
 $ wget http://ftp.belnet.be/packages/damnsmalllinux/mydsl/system/XFree86.dsl
 $ cd /tmp/knoppix
 $ tar xfz ../XFree86.dsl

Damit der XFree86 auch genutzt wird, müssen wir noch einen Link neu setzen: 

$ cd /tmp/knoppix/etc/X11
$ rm X
$ ln -s /usr/bin/X11/XFree86 X

Die passende XF86Config-4 holen wir uns als Template von der VESA-Version 

$ cp ../../home/dsl/XFree86_config_files/XF86Config-4_vesa

und modifizieren die entsprechenden Stellen. Wichtig sind auf jeden Fall die Sektionen "Device" und "Screen": 

Section "Device"
        Identifier      "Video Karte"
        driver          "nsc"
        Option          "NoAccel" "True"
        Option          "FlatPanel" "True"
        VendorName      "Cyrix Corporation"
        BoardName       "5530 Video [Kahlua]"
        BusID           "PCI:0:18:4"
        VideoRam        3072
EndSection

Section "Screen"
        Identifier      "Screen0"
        Device          "Video Karte"
        Monitor         "My Monitor"
        DefaultDepth     16
        SubSection "Display"
               Depth 8
                Modes "1280x1024" "1024x768" "800x600" "640x480"
        EndSubSection

        Subsection "Display"
                Depth 16
                Modes "1024x768" "800x600" "640x480"
        EndSubSection
EndSection

NTPDate

Nun ergänzen wir unser DSL um die automatische Zeitsynchronisierung. Da es hierzu leider kein fertiges DSL-Paket gibt, verwende ich einfach das vom host: 

$ cp /etc/init.d/ntpdate /tmp/knoppix/etc/init.d/
$ cp /usr/sbin/ntpdate /tmp/knoppix/usr/sbin/

Falls auf dem Host noch kein ntpdate installiert wurde, einfach nachholen: 

$ apt-get install ntpdate

Damit die Zeit bei jedem Start automatisch synchronisiert wird, tragen wir den Aufruf noch entsprechend ein 

$ vi /tmp/knoppix/opt/bootlocal.sh

 #!/bin/bash
 # put other system startup command here
 /etc/init.d/ntpdate start

Zuletzt sollten wir noch den nameserver anpassen: 

$ vi /tmp/knoppix/etc/dhcpc/resolv.conf

Neues KNOPPIX-Image erstellen

Nachdem alle Änderungen im neuen KNOPPIX-Image enthalten sind, erstellen wir das neue compessed-FS: 

$  mkisofs -R -U -V "KNOPPIX" -hide-rr-moved -cache-inodes -no-bak -pad /tmp/knoppix | nice -5 /usr/bin/create_compressed_fs - 65536 > /tmp/KNOPPIX.neu

Danach liegt unter /tmp/KNOPPIX.neu unser neu erstelltes KNOPPIX-FS. Mit seinen 61 MB sollte es grade noch auf unser 64 MB-Flash passen :D

ToDo

  • Als letztes dann das neue KNOPPIX-compressed-fs auf den Flash des T20 bringen, damit dieser auch ohne USB-Stick vollständig bootet.

done, ich hab eine Firmware erstellt, die dsl-3.4.4 direkt aus dem flash in eine ramdisk laden kann, ganz ohne usb-stick.

Im Augenblick hab ich keinen Platz mehr auf meinem schnellen webspace und kann das nur mit kleinem dsl-upstream anbieten http://baldar.dyndns.org/Compaq_Evo_T20/ li-la

Drive-Image mit Filesystem im Flash erstellen (in Bearbeitung)

Vorwort (in Bearbeitung)

Voraussetzungen (in Bearbeitung)

Geeignetes Verzeichnis anlegen (/path-to) 

$ cd /path-to
$ cp /irgendwoher/U64CPQ163.bin /path-to/

Grub unter /path-to-grub/ 'auspacken' und mit compile-with-dhcp compilieren.

GRUB mit DHCP

GRUB ist ein Multistage Boot-Loader . Er dient dazu ein Betriebssystem zu starten und offeriert hierfür eine Menüstrucktur welche im Normalfall sogar Live editiert werden kann. Zwecks der grösseren Flexibilität wird er zur Zeit hier genutzt um ein Menü-File via TFTP von einem Server zu laden und dann, entsprechend dem Menü, den Kernel bzw. die Initrd via TFTP oder vom Flash zu laden. Mangels Tastatur (kein Support für USB-Tastaturen zu diesem Zeitpunkt) kann immer nur ein Eintrag automatisch via 'default=' geladen werden. Die Vorgehensweise entpricht der von Bernhard, mit der Ausnahme dass der Support für ext2fs in GRUB enabled wird und kein Etherboot-Image benötigt wird.

Zuerst sollt man sich die GRUB Legacy Sourcen herunterladen, 

$ mkdir -p /path-to-grub
$ cvs -z3 -d:pserver:anonymous@cvs.savannah.gnu.org:/sources/grub co /path-to-grub

Anschliessend kann man erstmal mit Bernhards Patch die nötigen Modifikationen, welche auf Kazaks Seite angegeben sind automatisch durchführen. 

$ zcat grub.patch.gz | patch -p0 2>&1 | tee patch.out

Nun die Datei 'compile-with-etherboot.sh' nach 'compile-with-dhcp.sh' kopieren und wie folgt modifizieren oder aus diesem Text mit Copy&Paste eine neue 'compile-with-dhcp.sh' erstellen. 

#!/bin/sh
./configure \
 --enable-preset-menu=presetmenu.dhcp \
        --enable-natsemi \
        --enable-pci-direct \
        --enable-ext2fs \
        --disable-fat --disable-ffs --disable-ufs2 \
        --disable-minix --disable-reiserfs --disable-vstatfs --disable-jfs \
        --disable-xfs --disable-iso9660\
        --disable-md5-password --disable-serial
make

Die zugehörige 'presetmenu.dhcp' sollte dann so aussehen: 

default 0
timeout 0
title Load config from DHCP
dhcp --with-configfile

Nun die Datei compile-with-dhcp.sh ausführen. 

$ sh compile-with-dhcp.sh

Als nächstes müssen wir die Größe des Stage2 loaders herausfinden. Diese kann je nach verwendetem Compiler unterschiedlich groß sein. Da wir mit den Vorschlägen im späteren Verlauf 'nur' 130048 byte (bzw. 254 Sektoren a 512 Byte) zur Verfügung haben, sollte die Stage2 nicht grösser sein. ;-) 

Achtung: Sollte dieser Fall jedoch eintreten muss der Anfang der (ersten) Partition
auf Zylinder 3 verlegt werden.!!

$ ls -al /path-to-grub/stage2/stage2

Dabei sollte eben ein Dateigrösse kleiner 130048 herauskommen.

GRUB mit statischer IP

Die Konfigurationsdatei für GRUB lässt sich auch ohne DHCP von einem TFTP Server laden, das presetmenu sieht dann so aus: 

default 0
timeout 0

title Load config from TFTP
ifconfig --address=192.168.0.3 --server=192.168.0.2 --gateway=192.168.0.1 --mask=255.255.255.0
configfile (nd)/grub.conf

address ist dabei die statische IP vom T20, server die IP des TFTP Servers, gateway die IP bspw. des DSL-Routers.

Erzeugen der virtuellen Festplatte

Beim flashen des Evo werden die Bereiche filesys0.img und filesys1.img ins NAND-Flash geschrieben und sind später, anscheinend als virtuelle Festplatte, über IDE ansprechbar. Deshalb wird nun, mit ein paar Besonderheiten, eine HDD-Struktur in einer Datei aufgebaut. 

$ dd if=/dev/zero of=filesys count=125952
$ losetup /dev/loop/0 filesys    # /dev/loop/0 beim ersten Aufruf mit udev 
                                 # sonst /dev/loop0 !!!

Erzeugen des MBR

Der Einfachheit halber wird stage1 von GRUB in den Sektor 0 kopiert. 

 $ dd if=/path-to-grub/stage1/stage1 of=/dev/loop0

Erzeugen der Partition

 Achtung! Die erste Partition gibt anscheinend die Grösse der späteren HDD
 (zumindest fuer GRUB) vor!!!

Zur Erstellung der Partition startet man einfach fdisk. 

$ fdisk /dev/loop0

Sollten hier irgendwelche Partitionen angezeigt werden sind diese alle mittels Taste [d] und entsprechender Angabe der Partition zu löschen.

Nun schaltet man mit Taste [x] in den Erweiterten Modus von Fdisk.

Hier stellen wir die Anzahl der Cylinder mittels Taste [c] und Eingabe von 492 um. Anschliessend erfolg die Umstellung der Anzahl der Köpfe mittels Taste [h] und Eingabe von 8 sowie die Anzahl der Sektoren/Spur mittels Taste [s] und Eingabe von 32.

Nun erfolgt der Rücksprung in den Standardmodus von Fdisk mittels Taste [r].

Nun wird mit der Tastenfolge [n], [p], [1], [2]*, [RETURN] eine primäre Partition von Zylinder 2 bis Zylinder 492 angelegt. (Automatisch Type 83 Linux)

*Hinweis: Sollte nach dem Kompilieren von GRUB die stage2 grösser als 130048 Byte sein darf die Partition erst ab einem späteren Zylinder beginnen. Für jeden Zylinder können weitere 131072 Byte angerechnet werden.

Mit der Taste [w] werden nun die Änderungen gespeichert und fdisk verlassen, wobei die Fehlermeldungen betreffen des Einlesens ignoriert werden können.

Da der Evo den MBR im Sektor 0 ignoriert muss der bereits gepatchte MBR inklusive Partitionstabelle aus Sektor 0 auch in den Sektor 1 kopiert werden. 

$ dd if=/dev/loop0 of=/dev/loop0 seek=1 count=1

Nun noch die gepatchte stage2 von GRUB beginnen mit Sektor 2 einfuegen. 

$ dd if=/path-to-grub/stage2/stage2 of=/dev/loop0 seek=2

Erstellen des Filesystems

Die erstellte Partition beginnt mit Cylinder 2*. Der Start der Partition kann sehr einfach über folgende Formel errechnet werden. 

8 Heads/Cylinder * 32 Sectors/Cylinder * 512 Byte/Sector = 131072 (offset)

*Für jeden Zylinder welche die Partition später beginnt (stage2 zu gross) werden weitere 131072 zum Offset hinzugezählt. 

$ losetup -o 131072 /dev/loop1 filesys
$ mkfs.ext2 /dev/loop1          # hier bestehten noch Optmierungsmoeglichkeiten
                                # (z.B. reserved blocks)
$ tune2fs -c 0 -i 0 /dev/loop1  # Schaltet die Laufwerkspruefung ab

Inhalt einspielen

Nun können die gewüschten Inhalte in das Filesystem eingespielt werden. Hierfür wird das Loop-Device der Partition (/dev/loop1) in ein Verzeichnis eingebunden. 

$ mount /dev/loop1 /mnt/
$ cp -a /irgendwas /mnt/       # z.B. /boot und /KNOPPIX aus dem DSL ISI Image
$ umount /dev/loop1

Anschliessend wird die virtuelle Festplatte wieder 'abgenabelt'. 

$ losetup -d /dev/loop1
$ losetup -d /dev/loop0

Drive-Image im orginal Bootp-File austauschen (in Bearbeitung)

Weil es so schön einfach ist wird jetzt die virtuelle Festplatte in das orginal Image eingefügt. 

$ losetup -o 834198 /dev/loop0 U64CPQ163.bin
$ dd if=filesys of=/dev/loop0
$ losetup -d /dev/loop0

Nach dem flashen des Evo mit diesem Überarbeiteten Image bezieht der Evo seine IP Adresse via DHCP und ruft die in der DHCP Konfiguration angegebene Menüdatei via TFTP ab. 

'''ToDo:''' Auszug aus dhcpd.conf einfüen !!!

Z.B kann mit folgenden Eintraegen in grub-menu.lst der Kernel und die Initrd des DSL Iso Image aus dem Flash geladen werden. 

 default 0
 timeout 0
 color white/blue black/light-gray
 title HP Thin Client
   clear
   geometry (hd0)
   root (hd0,0)
   kernel /boot/isolinux/linux24 root=/dev/hda1 ro vga=788 host=t20 fromhd=/dev/hda1 \
          toram noagp nopcmcia noapm noswap noscsi desktop=jwm waitusb frugal restore=sda1
   initrd /boot/isolinux/minirt24.gz

Zum Experimentieren bietet sich aber an den Kernel und das Initrd vom TFTP-Server zu laden. (spart viel Zeit für das flashen ;-) ) 

 default 0
 timeout 0
 color white/blue black/light-gray
 title HP Thin Client
   root (nd)
   kernel (nd)/tftpboot/kernel kernelparameter
   initrd (nc)/tftpboot/initrd

ToDo

  • Direktes Laden von stage2 aus Sektor 1 prüfen
  • Mehrfache logische Partitionen innerhalb einer primären Partition testen
  • Untersuchen warum der IDE Treiber des Kernels noch immer die falsche Geometrie der Festplatte ermittelt

Evo Infos

Administrator Zugang (WinCE und NTe)

- WinCE / NTe starten

- User selection Fenster mit folgender Tastatursequenz aufrufen: 

 <TAB>, <HOME>, <END>, <LEFT>, <RIGHT>

- Administrator mit folgenden Eingaben anmelden (Groß/Kleinschreibung beachten!!) 

 login   : Administrator
 password: Administrator   (mit A !!!)

Offset Informationen

U64CPQ163.bin /	U96CPQ163.bin
offset		offset		size		name
0000:0000	0000:0000	0004:8200	bootstrap
0004:8200			03e4:3896	'U64CPQ163.bin' bundle file
		0004:8200	05d4:38bc	'U96CPQ163.bin' bundle file
03e4:ba96			0000:0006	unknown part of U64CPQ163.bin
		05d8:babc	0000:0004	unknown part of U96CPQ163.bin
---------	---------
03e4:ba9c	05d8:bac0	end of bundle file (total filesize)
65.321.628	98.089.664	decimal

bundle file (offsets within the bundle file) 

U64CPQ163.bin /	U96CPQ163.bin
offset		offset		size		name
0000:0000			0000:0152	'64MB' bundle file information (directory?)
		0000:0000	0000:0178	'96MB' bundle file information (directory?)
0000:0152	0000:0178	0004:0000	ulc_code.ce	(BIOS)
0004:0152	0004:0178	0000:0014	k
0004:0166	0004:018c	0004:0000	ulc_code.bin
0008:0166	0008:018c	0000:0005	os.ver
0008:016e	0008:0194	0000:3728	poweron.bmp
0008:3896	0008:38bc	01e4:0000	filesys0.img	31.719.424	(61952 sectors)
01ec:3896	01ec:38bc	01f4:0000	filesys1.img	32.768.000	(64000 sectors)
		03e0:38bc	01f4:0000	filesys2.img	32.768.000	(64000 sectors)

bundle file (offset from the beginning of the file including the bootstrap) 

U64CPQ163.bin /	U96CPQ163.bin
offset		offset		size		name
0004:8200			0000:0152	'64MB' bundle file information (directory?)
		0004:8200	0000:0178	'96MB' bundle file information (directory?)
0004:8352	0004:8378	0004:0000	ulc_code.ce	(BIOS)
0008:8352	0008:8378	0000:0014	k
0008:8366	0008:838c	0004:0000	ulc_code.bin
000c:8366	000c:838c	0000:0005	os.ver
000c:836e	000c:8394	0000:3728	poweron.bmp
000c:ba96	000c:babc	01e4:0000	filesys0.img	31.719.424	(61952 sectors)
01f0:ba96	01f0:babc	01f4:0000	filesys1.img	32.768.000	(64000 sectors)
		03f0:babc	01f4:0000	filesys2.img	32.768.000	(64000 sectors)

Weblinks

http://baldar.dyndns.org/dokuwiki/doku.php/compaq_evo_t20_thinclient/ http://baldar.dyndns.org/dokuwiki/doku.php/compaq_evo_t20_thinclient/firmware_creation_using_grub4dos_on_ntfs_instead_of_a_patched_grub1

Abgerufen von „https://www.pug.org/mediawiki/index.php?title=Thin_Client_evo_T20&oldid=8100“