Das fertige Ergebnis sollte folgendermaßen aussehen (In Anlehnung an den rechts dargestellten Baum – die Nummerierung erfolgt von links nach rechts):

[Wurzel] + [Blatt 1, Ebene 1] + [Blatt 1, Ebene 2] + [Blatt 1, Ebene 3]
         |                    |                    ` [Blatt 2, Ebene 3]
         |                    ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
         |                                         ` [Blatt 4, Ebene 3]
         `[Blatt 2, Ebene 1] + [Blatt 3, Ebene 2] + [Blatt 5, Ebene 3]
                             |                    ` [Blatt 2, Ebene 3]
                              ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
                                                    ` [Blatt 4, Ebene 3]

Wir zeichnen also bei jeder Verzweigung ein Plus, dann den Namen des Blattes und immer so weiter, bis ein Blatt erreicht ist, dass sich nicht mehr verzweigt. Dann wird eine neue Zeile begonnen und so lange unter jedes Plus ein “|” geschrieben, bis man wieder auf dem Level angelangt ist, zu dem das Blatt gehört. Soweit so gut, ist ja nicht so komplex.

Die Probleme fingen bei mir an, als ich diese Idee in Code umsetzen musste: Ich hatte eine Liste mit Objektinstanzen, aus denen ein Baum generiert werden sollte.

Jedes Objekt hatte drei für die Ausgabe relevante Attribute:

Objekt* child1; //Der Pointer auf das erste Blatt dieser Objektinstanz
Objekt* child2; //Der Pointer auf das zweite Blatt dieser Objektinstanz
string name; // Der Name dieser Objektinstanz
//Die Pointer beziehen sich jeweils auf andere, in der Liste vorhandene Instanzen.

Also hatte ich folgende fixe Idee: Ich baue in das Objekt eine Funktion ein, die mir den String zusammenbastelt und sich, um die Verschachtelung darzustellen, wieder selbst aufruft. Damit muss ich nicht festhalten, welche Information von welchem Blatt nun ausgegeben werden soll. Fassen wir diese Idee in Pseudo-Pseudocode zusammen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# Die Funktion erhält eine Liste, in der jeder Index eine Zeile symbolisiert
# Zeile 1 also Index 0 usw...
def generate_tree (list_of_strings):
 # An die aktuelle Zeile den Namen unseres Blattes dranhängen
 list_of_strings.back().append( name )
 
# Wenn unser Objekt ein Kind hat, dann müssen wir ein 
# Plus dranhängen und die Rekursion anstoßen.
# Die Unterscheidung ob "+" oder "-" ist nicht notwendig, 
# sieht aber am Ende schicker aus:
 if has_child1:
  if has_child2:
   list_of_strings.back().append( "+" )
  else:
   list_of_strings.back().append("-")
 
  # Hiermit starten wir die Rekursion
  # Das Folgende soll einen Memberaufruf symbolisieren :)
  child1.generate_tree( list_of_strings )
 
 if has_child2: # Ein Objekt kann ja bis zu zwei Kinder haben
  buffer = "" #Einen Buffer anlegen
  # Die Position des letzten Plusses rausfinden
  p = list_of_strings.back().find_last_of( "+" ) 
  # Die Position des letzten Strichs rausfinden
  k = list_of_strings.back().find_last_of( "|" ) 
 
  if p < k: #Den höheren Wert der beiden müssen wir nehmen
   p = k
 
# Von 0 bis p in Einerschritten durchgehen
  for i=0 | i <= p | i++
   if i < p:
    if list_of_strings.back()[i] == "+" or list_of_strings.back()[i] == "|":
     buffer.append( "|")
    else:
     buffer.append( " " )
   else if i == p:
    buffer.append( "`" )
 
  list_of_strings.append( buffer )
 
  # Wieder eine Rekursion starten
  # Das ist auch ein Memberaufruf
  child2.generate_tree( list_of_strings )
# ENDE der Funktion

So…diese Zeilen verlangen ein wenig nach Erklärung:
Zeile 1: Wir hängen den Namen des Blattes an das letzte Element in der Liste dran. Es ist egal ob die aktuelle Instanz jetzt Wurzel ist oder nicht. Wichtig ist nur, dass die übergebene Liste nicht leer ist. Dafür muss beim Aufruf der Funktion beim Wurzelelement gesorgt sein.

Zeile 11-15: Hier wird nur unterschieden, ob die aktuelle Instanz ein oder zwei Blätter hat und dementsprechend das Verbindungszeichen gewählt

Zeile 19/20: Hier wird die Funktion generate_tree bei dem ersten Kind aufgerufen, mit Übergabe der auch von dieser Funktion verwendeten Liste. Dadurch ist gewährleistet, dass alle ersten Kinder des jeweils vorhergehenden Blatts in einer Zeile stehen.

Zeile 21: Nun ist die Funktion für das erste Kind durchgelaufen, wenn es ein zweites Kind gibt, wird es nun etwas schwieriger, einen String zusammenzubauen.

Zeile 22-26: Es wird ein Puffer angelegt (er wird am Ende die neue Zeile enthalten, die wir zusammengebaut haben), der Index des letzten Plusses und der Index des letzten senkrechten Striches herausgefunden. Zur Erinnerung: Striche sollten die Verzweigung über mehrere Zeilen hinweg kenntlich machen. Plusse sollten zeigen, dass dieses Blatt mehr als ein Kind hat.

Zeile 28-Ende: Die Zuweisung in Zeile 29 macht nur Sinn, wenn man sich die for-Schleife danach anschaut. Wir gehen jeden einzelnen Index der letzten Zeile in der Liste bis p durch. p ist der Index des letzten Plusses/letzten Striches, je nachdem welcher Index höher ist. Solange i < p gilt, wird unter jeden Strich/jedes Plus ein weiterer Strich gehängt (indem man dieses Zeichen an den Puffer hängt). Haben wir p erreicht, so wird ein “`” an den Puffer gehängt, weil jetzt endlich der Name des zweiten Kindes kommen kann.
Dazu hängen wir den Buffer an die Liste dran (er symbolisiert ja eine neue Zeile) und rufen generate_tree bei dem zweiten Kind auf, mit unserer Liste als Parameter.

—–

Eine Implementierung dieses Algorithmus in C++ könnte folgendermaßen aussehen: *klick*

Die Funktion funktioniert allerdings nur unter zwei Bedingungen:

• Verwendung eines Monospace-Fonts bei der Ausgabe
• Die übergebene Liste ist beim Aufruf der Funktion beim Wurzelelement NICHT leer. Sie muss mindestens einen leeren String enthalten.

Genauer gesagt ging der Stecker nicht, das lies sich dadurch feststellen, dass durch drehen, bzw. leichtes Herausziehen die Qualität des Audiosignals deutlich geschwankt hatte oder überhaupt nicht mehr hörbar war.

Falls jemand ein ähnliches Problem hat, will ich hier kurz erklären, wie man dieses lösen kann.

Benötigt:

- Kopfhörer mit kaputtem Stecker

- alter Kopfhörer, bei dem der Stecker noch geht (der Rest darf ruhig hinüber sein) mit einem ähnlichaussehenden Leiter

- Lötkolben

- Schrumpfschlauch (Tape tut es auch, sieht aber nicht so schön aus)

- Abisolierzange/Schere

- Feuerzeug

- Tesafilm

Vorgehensweise:

- Beide Kopfhörer am Leiter so abschneiden, dass die gewünschte Länge erreicht wird + etwa 2 cm auf jeder seite zum verlöten

- die Leiterenden von den Stücken, die verwendet werden, abisolieren mit einer Abisolierzange (oder mit einer Schere ganz leicht einschneiden und die Isolierung herunterziehen)

- jetzt sollten bei beiden 3 Leiter in verschiedenen Farben sichtbar sein, falls nicht, anderen Stecker verwenden wenn noch welche vorhanden sind und auch abisolieren

- einen Schrumpfschlauch auf ca 3 cm zuschneiden und über einen der beiden Leiter weg von dem isolierten Bereich ziehen, damit er später verwendet werden kann

- die drei Leiter jeweils in verschiedene Richtungen biegen und vorsichtig mit einem Feuerzeug den Lack für ca. 1,5 cm wegbrennen

- beide kupferfarbenen (Masse) Leiter zusammendrehen

- die übrigen Leiter stehen für rechts bzw. links. Welcher welcher ist muss jetzt ausprobiert werden (zwei zusammendrehen, Kopfhörer an Player anstecken, hören wo rechts und links ist z.B. indem man die Balance auf dem Player in eine Richtung schiebt)

- die Leiter sollten jetzt richtig zusammengedreht (tipp: drehsinn beibehalten!) sein, noch immer in 3 verschiedene Richtungen senkrecht zu dem jetzt verbundenen Leiter wegstehen und Musik sollte angeschlossen und in gewohnter, guter Qualität hörbar sein

-  jetzt werden diese drei verdrehten Leiter festgelötet, wobei man zur überprüfung die Musik ruhig weiterlaufen lassen kann

- die drei werden alle in eine Richtung (z.B. in die des Steckers) gebogen und mit Tesafilm so übereinander geklebt, dass sie jeweils komplett voneinander isoliert sind.

- Falls man den Schrumpfschlauch verwendet hat, wird dieser nun über die Verbindungsstelle geschoben, so dass diese vollständig abgedeckt ist

- Der Schrumpfschlauch wird mit dem Feuerzeug erhitzt, damit er sich zusammenzieht und die Verbindungsstelle z.B. vor Regen schützt

…und das wärs auch schon. Viel Spaß mit dem reparierten Kopfhörer

PS: 135° Stecker halten nach meiner Erfahrung am besten.

Mein System lief auf einem 1GB USB-Stick und lief eigentlich ziemlich super. Lief. Ja. Das ist der Knackpunkt: Mein USB-Stick ist ziemlich tot.

Das äußert sich darin, dass plötzlich irgendwelche Befehle nicht mehr tun, ich kryptische Errors um den Kopf geworfen bekomme und das System nicht mehr bootet, weil das ext2-fs so stark beschädigt ist, dass es nicht durch den routinemäßigen Check beim boot repariert werden kann, sondern manuell per e2fsck gefixt werden muss (von einem anderen pc aus).

Die Ursache dafür liegt darin, dass die in USB-Sticks und SD-Karten verbauten Flash-Chips zwar praktisch unendlich viele Lesevorgänge, aber nur ca. 10.000 – 100.000 Schreibzyklen pro Sektor verkraften. Das ist normalerweise absolut kein Problem, wenn man einfach nur “Daten” auf diesen Sticks zwischenspeichert. Außerdem versuchen die Hersteller meist, die Schreibvorgänge auf mehrere Sektoren zu verteilen, um ein Überschreiben von immergleichen Sektoren zu vermeiden. Letzteres kann aber natürlich nicht funktionieren, wenn der Stick quasi voll ist.

Wenn man aber ein Betriebssystem auf dem Stick betreibt, können diese Zyklen relativ schnell erreicht sein, vor allem durch Logfiles, Lockfiles und temporäre Daten. Auf diese Weise hat sich wie eingangs schon erwähnt mein (zugegeben ziemlich billiger und schon länger gebrauchter) USB-Stick verabschiedet.

Da viele Teile dermaßen beschädigt waren, dass das Reparieren verdammt aufwändig geworden wäre, habe ich das System von Neuem hochgezogen. Dabei habe ich mir die Frage gestellt: Wie kann ich vermeiden, dass das System wieder meinen Stick screwed? Als erstes kam mir die Idee, einfach das rootfs read-only zu mounten. Das hat aber zur Folge, sämtliche Schreiboperationen im RAM zu cachen. Da die Dockstar nur 128MB RAM hat, schied diese Möglichkeit aus. Als zweites kam mir die Idee, die ich jetzt auch umgesetzt habe:

Flüchtige Daten in einer Ramdisk halten

Das heißt, ich mounte mir einen Teil des spärlich vorhandenen RAMs als Datenträger und mappe ihn als Ersatz für die Verzeichnisse

• /var/log (Logfiles)
• /var/lock (Sperr-Files)
• /var/run (Daemon-PIDs)
• /var/tmp (Temporäre Dateien)
• /tmp (Temporäre Dateien).

Dadurch fange ich fast alle Schreibzugriffe ab, welche im Dauerbetrieb eben anfallen. Änderungen an Configfiles etc. werden aber immernoch sofort auf den Stick geschrieben. Falls das System sich aufhängt, abstürzt oder ähnliche Scherze passieren, ist der “zusätzliche” Datenverlust also gering (nur die neueren Logfiles). Trotzdem: Hier werden einige Dateien nur im RAM vorgehalten. Wenn das System crasht oder die Daten vorm Ausschalten nicht von der Ramdisk auf den Stick gesichert werden, sind sie weg!

Bevor ich mit der Anleitung beginne, sei hier die Seite cat brain.stuff > wordpress als Quelle genannt, da fast alle Informationen von dort stammen. Ich habe es lediglich zu Arch Linux / Plugbox Linux “geportet” und an meine Bedürfnisse angepasst.

Anlegen der Verzeichnisse

mkdir /var/log-bak

mkdir /var/lock-bak

mkdir /var/run-bak

mkdir /var/tmp-bak

mkdir /tmp-bak

mkdir /run-bak

mkdir /mnt/ramdisk

Den Daemon anlegen

Die Datei /etc/rc.d/ramdisk erstellen und folgendes hineinpasten:

#!/bin/bash

. /etc/rc.conf
. /etc/rc.d/functions

case “$1″ in
start)
stat_busy “Copying files to ramdisk”

rm -Rf {/var/log-bak,/var/lock-bak,/var/run-bak,/var/tmp-bak,/tmp-bak,/run-bak}

mount –move /var/log /var/log-bak
mount –move /var/lock /var/lock-bak
mount –move /var/run /var/run-bak
mount –move /var/tmp /var/tmp-bak
mount –move /tmp /tmp-bak
mount –move /run /run-bak

mkdir /mnt/ramdisk/var
mkdir /mnt/ramdisk/var/log
mkdir /mnt/ramdisk/var/lock
mkdir /mnt/ramdisk/var/run
mkdir /mnt/ramdisk/var/tmp
mkdir /mnt/ramdisk/tmp
mkdir /mnt/ramdisk/run
mkdir /mnt/ramdisk/run/lock
chmod 1777 /mnt/ramdisk/tmp
chmod 1777 /mnt/ramdisk/var/lock
chmod 1777 /mnt/ramdisk/var/tmp
chmod 1777 /mnt/ramdisk/run

mount –bind /mnt/ramdisk/var/log /var/log
mount –bind /mnt/ramdisk/var/lock /var/lock
mount –bind /mnt/ramdisk/var/run /var/run
mount –bind /mnt/ramdisk/var/tmp /var/tmp
mount –bind /mnt/ramdisk/tmp /tmp
mount –bind /mnt/ramdisk/run /run

cp -a -v /var/log-bak/* /var/log/ >> /var/log/ramdisk_sync.log
cp -a -v /var/lock-bak/* /var/lock/ >> /var/log/ramdisk_sync.log
cp -a -v /var/run-bak/* /var/run/ >> /var/log/ramdisk_sync.log
cp -a -v /var/tmp-bak/* /var/tmp/ >> /var/log/ramdisk_sync.log
cp -a -v /tmp-bak/* /tmp/ >> /var/log/ramdisk_sync.log
cp -a -v /run-bak/* /run/ >> /var/log/ramdisk_sync.log

echo [`date +"%Y-%m-%d %H:%M"`] Ramdisk synced from HD >> /var/log/ramdisk_sync.log
if [ $? -gt 0 ]; then
stat_fail
else
add_daemon ramdisk
stat_done
fi
;;
stop)
stat_busy “Switching off ramdisk, direct hdd write”
rsync -av –delete /var/log/ /var/log-bak/
rsync -av –delete /var/lock/ /var/lock-bak/
rsync -av –delete /var/run/ /var/run-bak/
rsync -av –delete /var/tmp/ /var/tmp-bak/
rsync -av –delete /tmp/ /tmp-bak/
rsync -av –delete /run/ /run-bak/

# Unmount ramdisk bind
umount /mnt/ramdisk/var/log
umount /mnt/ramdisk/var/lock
umount /mnt/ramdisk/var/run
umount /mnt/ramdisk/var/tmp
umount /mnt/ramdisk/tmp
umount /mnt/ramdisk/run

# Unmount move
umount /var/log-bak
umount /var/lock-bak
umount /var/run-bak
umount /var/tmp-bak
umount /tmp-bak
umount /run-bak

# Deleting directories
rm -Rf /mnt/ramdisk/*

echo [`date +"%Y-%m-%d %H:%M"`] Ramdisk synced to HD >> /var/log/ramdisk_sync.log
if [ $? -gt 0 ]; then
stat_fail
else
rm_daemon ramdisk
stat_done
fi
;;
sync)
echo “Syncing log and lock files to harddisk”
rsync -av –delete /var/log/ /var/log-bak/
rsync -av –delete /var/lock/ /var/lock-bak/
rsync -av –delete /var/run/ /var/run-bak/
rsync -av –delete /var/tmp/ /var/tmp-bak/
rsync -av –delete /tmp/ /tmp-bak/
rsync -av –delete /run/ /run-bak/

echo [`date +"%Y-%m-%d %H:%M"`] Ramdisk synced to HD >> /var/log/ramdisk_sync.log
;;

restart)
$0 stop
$0 start
;;

*)
echo “usage: $0 {start|stop|sync}”
esac
exit 0

Die /etc/fstab anpassen

Dort eine Zeile hinzufügen à la

tmpfs                   /mnt/ramdisk    tmpfs   size=64m        0       0

Ich benutze hier bewusst tmpfs und nicht ramfs, da tmpfs bei akutem Ram-Mangel auf swap ausweicht, ramfs dies aber nicht tut. Weiterhin limitiere ich die Größe für die Ramdisk auf 64MB. Die Ramdisk wächst aber dynamisch, belegt also nur Platz, welchen sie auch braucht. Die 64MB sind nur ein grob geschätzter Maximalwert.

/etc/rc.conf anpassen

Hier sollte der Daemon als erster gestartet werden, damit so wenige Applikationen wie möglich den (sehr) kurzen Ausfall der oben genannten Verzeichnisse verkraften müssen. Euer DAEMONS-Array könnte also so aussehen:

DAEMONS=(ramdisk syslog-ng network openntpd netfs crond sshd)

Logrotate anpassen

Ein Punkt, der sich erst nach einiger Benutzung als wichtig herausgestellt hat: Die Logfiles können sehr groß werden und damit den RAM füllen. Um das zu verhindern, sollten die Logs in kurzen Zeitabständen rotiert werden.

Dazu passen wir die /etc/logrotate.conf an. Meine sieht so aus:

daily

rotate 3

size 16M

create

compress

tabooext + .pacorig .pacnew .pacsave

include /etc/logrotate.d

/var/log/wtmp {

weekly

create 0664 root root

rotate 1

}

Abschließende Worte

Soweit, so gut. Beim nächsten Neustart sollte euer System also nun den größten Teil der Schreiboperationen im RAM vorhalten. Ganz eilige können auch einfach den Daemon starten, es sollte auch so funktionieren. Was passiert, wenn ein Prozess genau dann der Meinung ist, ein Logfile schreiben zu müssen, wenn der Daemon gerade Verzeichnisse herumschiebt, kann ich absolut nicht vorhersagen.

Wenn ihr Verbesserungsvorschläge, Tipps, Kritik oder sonstigen Senf zum Zugeben habt, immer her damit.

Hardware:

- Marvell 88F6281 SoC mit 1,2 GHz Sheeva CPU
- 128MB DDR2
- 256MB NAND-Flash
- 3x USB 2.0 Ports
- 1x Mini-USB für Seagate Go Festplatten
- 100/1000 MBit Ethernet

Wer sich nicht mit den durch den Pogoplug-Dienst gegebenen Einstellungen/Einschränkungen zufriedengeben möchte, kann aber auch mit ein paar Tricks ein vollständig funktionstüchtiges PlugBoxLinux(eine auf Arch basierende Distro) an den Start bringen

Bevor es losgeht, möchte ich auf die Gefahr hinweisen, dass man mit manchen dieser Schritte das Gerät bricken, also unnutzbar machen kann. Alles geschieht auf eigene Verantwortung.

——

Aber no risk, no fun, also los gehts:

1. )Seagate Dockstar ans Netzwerk anschließen, aber darauf achten dass sie keinen Zugriff auf das Internet erhält.(Adi64 und ich haben einfach einen kleinen Switch genommen) Noch ist nämlich ein Service aktiv, der Updates installiert. Unter anderem eines, das ssh deaktiviert und das root-Passwort ändert…

2.)Die IP des Gerätes herausfinden.
Bei uns hat es gereicht, die letzten beiden Byte der MAC-Addresse(steht unten drauf) zu kennen.
Angenommen diese beiden Bytes wären AB(=171) und CD(=205), dann ist die IP

169.254.171.205

Wenn das bei euch nicht so sein sollte, kommt ihr nicht darum, die Dockstar per nmap zu suchen:

nmap -sP 169.254.0.0/16

3.)Per ssh einlogggen:

ssh root@169.254.171.205
root@169.254.171.205's password: stxadmin #ist für alle gleich  

4.)Den Pogoplug-Updateservice abschießen und aus dem Startup rausnehmen:

killall hbwd
mount -o remount,rw / #root als writeable remounten
vi /etc/init.d/rcS
#Jetzt die Zeile mit "/etc/init.d/hbmgr.sh start" auskommentieren
mount -o remount,ro /
#Jetzt kann man das Gerät theoretisch gefahrlos ans Netz anschließen

5.)Backup, Backup, Backup. USB-Stick anschließen und danach die Daten sicher verwahren:

cd /tmp
mkdir usb
mount /dev/sda1 /tmp/usb
wget http://plugapps.com/os/pogoplug/uboot/nanddump
chmod +x nanddump
./nanddump -nf usb/mtd0 /dev/mtd0
./nanddump -nf usb/mtd1 /dev/mtd1
./nanddump -nf usb/mtd2 /dev/mtd2
umount /dev/sda1

6.)Das U-Boot, den Bootloader, installieren. Das ist an sich der gefährlichste Teil, weil ein Teil der Flash-Speichers bearbeitet wird. Ein Neustart danach ist nicht notwendig, es gibt ja noch nichts Besseres wo man reinbooten könnte

cd /tmp
wget http://plugapps.com/os/pogoplug/uboot/install_uboot_mtd0.sh
chmod +x install_uboot_mtd0.sh
./install_uboot_mtd0.sh

7.)Einen USB-Stick(1GB sollte drin sein) formatieren, mit einer mindestens 512MB großen ext2-Partition. Das Formatieren muss nicht unbedingt auf dem DockStar erfolgen.

8.)PlugBox Linux herunterladen, auf dem USB-Stick speichern:

#cd auf den USB-Stick
wget http://plugapps.com/os/1.1/Plugbox-Linux-1.1-rootfs.tar.gz

9.)Das heruntergeladene Archiv auf dem USB-Stick extrahieren, danach das Archiv löschen. Dies sollte auf der DockStar erfolgen, sonst drohen Berechtigungsprobleme (Danke an GerhardSchr!)

tar -xzvf Plugbox-Linux-1.1-rootfs.tar.gz # Dauert ein bisschen auf der Plugbox, ~15min
rm Plugbox-Linux-1.1-rootfs.tar.gz

10.)Den USB-Stick einstecken, falls nicht schon geschehen und die Box neustarten. Auf das Beste hoffen ;D

/sbin/reboot

11.)Nach dem Neustart ist die alte IP natürlich nicht mehr gültig. Die Box bezieht sie über DHCP, sofern ein entsprechender Router/Server vorhanden ist. Bewaffnet mit der MAC könnt ihr ja mal im Listing der auf dem Router angemeldeten Geräte nachschauen. Keys und DynDNS werden Vielnutzer von ssh bestimmt kennen und schätzen. Wenn nicht – es ist definitiv einen Versuch wert.

——

Weiterführendes findet ihr hier. Debian-Fans finden hier etwas – hat bei Adi64 und mir leider nicht funktioniert.

Wer Gentoo ausprobieren möchte, wird hier fündig.

Diejenigen, die etwas mit ihrer LED tun möchten, werden hier glücklich.

Beispiel: Mit folgenden 3 Befehlen blinkt die LED bei jeder ssh-Aktion auf der Box orange:

modprobe xt_LED #Treiber laden
iptables -A INPUT -p tcp --dport 22 -j LED --led-trigger-id web --led-delay 100
echo netfilter-web > /sys/class/leds/dockstar\:orange\:misc/trigger

]]> http://adrian.holfter.de/blog/2010/09/archlinux-auf-der-seagate-dockstar/feed/ 33 http://adrian.holfter.de/blog/2010/06/bootsplash-einrichten/ http://adrian.holfter.de/blog/2010/06/bootsplash-einrichten/#comments Wed, 23 Jun 2010 14:07:09 +0000 n0stradamus http://adrian.holfter.de/blog/?p=237 Nach meinem Wechsel von Ubuntu zu Arch habe ich den Startvorgang etwas aufpeppen wollen und versucht, einen Splash beim Boot anzeigen zu lassen.

Zuerst einmal hat man die Wahl zwischen splashy und fbsplash. Ich habe mich für fbsplash entschieden und werde es in diesem Artikel behandeln.

fbsplash findet man im AUR und im Wiki eine sehr gute Einführung dazu. Ich bin den Leitfaden mehrere Male durchgegangen und immer wieder auf die gleiche Problematik gestoßen:

• Beim Hochfahren bekomme ich eine Fehlermeldung: ‘fbsplash was unable to start…theme not found’
• Beim Herunterfahren funktioniert der Splash

Abhilfe lässt sich mit folgender kleinen Änderung an den Kernelargumenten schaffen:

logo.nologo quiet console=tty1 vga=792 splash=silent,fadein,
fadeout,theme:<theme-name>

Den oben rot markierten Framebuffer-Wert gilt es nun mit dem gewünschten (und vom  Theme unterstützten!) Auflösungswert zu ersetzen, damit der Framebuffer auf den Wert gesetzt ist für den das Theme in /etc/conf.d/splash konfiguriert wurde – sonst startet fbsplash einfach nicht und es gibt die bekannte Fehlermeldung. Über diesen gesuchten Wert gibt uns folgender Befehl Aufschluss:

# hwinfo --framebuffer

hwinfo im AUR

In meinem Fall sähe die geänderte Argumentzeile folgendermaßen aus:

logo.nologo quiet console=tty1 vga=0x0324 splash=silent,fadein,
fadeout,theme:archax

Natürlich kann man die 0×0324 auch in 804 konvertieren und hinter vga= schreiben, das ist aber reine Geschmackssache.

Ich vermute, dass die Startschwierigkeiten entweder mit meiner x86_64-Version von Arch zusammenhängen oder mit meiner Hardware:

AMD Phenom II X4 955 BE

4GB OCZ DDR3-1600

ATI Radeon HD 4870 Vapor-X 2GB von Sapphire

Im Wiki ist nämlich auch ein Wikipedia-Artikel mit den Framebuffer-Codes verlinkt, die für 1280×1024 funktionieren sollen – bei mir tun sie es _nicht_: *klick*

Nachdem fbsplash nun bei mir startete, flackerte es kurz nach seinem Start und wurde nach links verschoben – irgenwdie unschön. Die einzige Lösung die ich dafür finden konnte, war folgende Änderung an /etc/mkinitcpio.conf vorzunehmen und damit den Start von fbsplash hinter die Änderung der Bildschirmauflösung durch den Kernel zu legen:

HOOKS=”base udev fbsplash autodetect pata scsi sata filesystems”

ändern zu

HOOKS=”base udev autodetect pata scsi sata filesystems fbsplash“

Es funktioniert, aber man sieht eben mehr von der Konsole und weniger vom Splash.

Für jegliche Lösungsvorschläge bin ich dankbar!

Für alle, die an einem nicht so wirklich richtig funktionieren Paketmanager gescheitert sind, ist hier der Leitfaden:

1.  Qwt Libraries runterladen und entpacken in Verzeichnis X:

http://www.qwt.sourceforge.net

tar -xzf foo.tar.gz

2. Dann folgende Konsolenschritte:

cd ‘X‘ //Pfad in dem sich das extrahierte Qwt findet

qmake

sudo make

sudo make install

3. Damit sei es getan, könnte man meinen, doch ich musste die qwt-Libraries noch vermerken und zwar in /usr/local/lib/libc.conf

/usr/local/qwt-Name/lib

/*Name war in meinem Fall qwt-5.2.0*/

4. Und zum Schluss:

sudo ldconfig

Teilt mir bitte Fehler mit, ich habe die Methode bisher nur ein paar Mal verwendet.

Das Theme, das ich auf dem Blog verwende, ist generell sehr beliebt und daher wird es auch dementsprechend oft benutzt. Da musste ein eigener Touch ran und der Header ist das Feature, das einen Blog im Endeffekt von anderen distanziert.

Bastelanleitung:

Man nehme das AMD Athlon 64-Logo und lässt es von einem Freund in Inkscape nachzeichnen – Fertig ist die 64 und man hat keine Urheberrechte verletzt.

Als Hintergrund ist fast alles erlaubt, ich habe Showtime 2 von *Venom339 genommen.

Dann noch mit der Schriftart Infinite Justice das Adi vor die 64 geknallt, Konturen, Schatten, runde Ecken etc. dazu und voilà!

Danke an Alle, deren Arbeit ich verwenden durfte!

Die Liste wird wahrscheinlich ständig erweitert, also mal öfters reinschauen

.iso:

mount -t iso9660 -o ro,loop image.iso /media/virtualcd

.mdf (Media Descriptor Format, Alcohol 120%), .img,  .ccd (Clone CD) und viele andere Formate:

Benutze AcetoneIso, um die Images in .iso zu konvertieren und mit oben genannten Befehl zu mounten.