März 2015

You are browsing the site archives by month.

RPCEmu unter Linux – ein Kochbuch

Bekanntlich ist RPCEmu der beste frei verfügbare Emulator für IOMD-basierte Hardware (vulgo Risc PC und A7000), den es für die Geschmacksrichtung “Linux” gibt. Während es für die Windows-User ein “ready-to-install”-Paket gibt und auch ein ZIP-Paket, das man einfach irgendwo auf die Platte extrahiert, heißt es bei Linux traditionell “compile from source”.

Ich will hier für eine aktuelle Ubuntu-Installation kurz die Schritte skizzieren, die einen zu einem funktionsfähigen RPCEmu mit Netzwerkunterstützung führen – auf der RPCEmu-Seite sind die Hinweise doch etwas verstreut, und einiges muss man sich zusammenreimen.

Das verwendete RISC OS ist natürlich RISC OS 5 von RISC OS Open Ltd.

RPCEmu Quellcode beschaffen

Hier gibt es zwei Möglichkeiten: Sourcecodearchiv von der RPCEmu-Seite  herunterladen, oder per Mercurial direkt das Source-Repository anzapfen. Ersteres ist etwas komfortabler, weil im Archiv bereits viele Dinge unabhängig vom Quellcode an der richtigen Stelle liegen. Will man letzteres tun, muss man Mercurial (“hg”) auf die Kiste bekommen – der Paketmanager hält hier alles notwendige bereit (einfach “sudo apt-get install mercurial” ausführen geht am schnellsten). Auschecken des tip-Standes (anderswo “Head”, “Trunk” oder “Master” genannt) ist simpel:

hg clone http://www.home.marutan.net/hg/rpcemu rpcemu

Egal für welchen Weg man sich entscheidet, man sollte am Ende ein “rpcemu”-Verzeichnis auf der Platte liegen haben, in dem sich der Quellcode im Verzeichnis src befindet.

RPCEmu compilieren

Zunächst sollte man sein Linux mit den notwendigen Libraries ausstatten. Gott sei Dank sind die Abhängigkeiten hier überschaubar: es braucht nur Allegro (mindestens Version 4.2, aber nicht Version 5; derzeit aktuell ist 4.4) und pthread (aka libpthread). Letzteres war bei mir schon installiert, ersteres kam über “sudo apt-get install liballegro4-dev”.

Über das config-Skript parametriert man alle notwendigen Dinge, vor allem aktiviert man den dynamischen Recompiler (vulgo “JIT”), weil sonst die Emulation doch eher gemächlich läuft: ./configure –enable-dynarec

Danach kommt dann der eigentliche compile-Vorgang, den man wie üblich per “make” startet. Resultat ist ein Binary namens “rpcemu”, das theoretisch ausführbar wäre – aber es fehlt ja noch ein bisserl was.

RPCEmu vorbereiten

Hat man sich bei der Quellcode-Beschaffung vom Mercurial-Repository bedient, muss man etwas mehr tun. Dort, wo das rpcemu-Binary nun liegt, erzeugt man zwei Verzeichnisse: hostfs (dort liegt später das RISC OS-Dateisystem) und poduleroms (dort kommen RISC OS-Module rein, die RPCEmu dann automatisch ins ROM integriert, und zwar über den Podule-ROM-Mechanismus – genau so, wie z.B. bei physischer RISC OS-Hardware die Podules (Netzwerk, SCSI, IDE, USB…) ihre Treiber ins RISC OS einbinden). Ins poduleroms-Verzeichnis kopiert man jetzt die drei Dateien hostfs,ffa hostfsfiler,ffa SyncClock,ffa aus riscos-progs/HostFS und riscos-progs/SyncClock. Damit steht nun HostFS zum Booten zur Verfügung, und die RISC OS-Uhr wird regelmäßig mit der Uhr des Hostsystems abgeglichen.

Jetzt gilt es, die Konfiguration anzupassen. Das passiert in der Datei rpc.cfg. Damit unfallfrei gebootet werden kann, muss unbedingt
model = RPCSA
in dieser Datei stehen, da der “Dynamic Recompiler” zwingend die StrongARM-Emulation voraussetzt, ansonsten kommt es zu bösen Instabilitäten. Um für die spätere Netzwerkkonfiguration schon gerüstet zu sein, kann man hier schon die Zeile
username = <your standard username>
eintragen – den Platzhalter mit dem Benutzer ersetzen, der den Emulator später ausführen wird.

Alle anderen Konfigurationen – Sound aktiv oder nicht, wieviel RAM und VRAM etc. – kann man später bequem über das RPCEmu-Menü setzen (Strg+Ende blendet das Menü ein).

RISC OS installieren

Letzter Schritt ist die Installation von RISC OS. Seit RISC OS 3.5 ist RISC OS ja quasi zweigeteilt: einmal das ROM, und einmal die “disc based components”, auch gerne mal vereinfacht “!Boot” oder “Bootstruktur” genannt.

Das ROM bekommt man natürlich von RISC OS Open Ltd. https://www.riscosopen.org/content/downloads/riscpc – abenteuerlustige Naturen verwenden einen 5.21-Nightly Build, eher konservative Nutzer begnügen sich mit der als stabil gekennzeichneten Version 5.20. Beiden gemeinsam ist, dass man in den Tiefen des jeweiligen ZIP-Archivs fündig wird: soft/!Boot/Choices/Boot/PreDesk/!!SoftLoad/riscos ist die Datei der Wahl, die ins Verzeichnis roms des RPCEmu kopiert werden muss.

Passend zur ROM-Version braucht man jetzt noch das “HardDisc4”-Disk-Image. Hier https://www.riscosopen.org/content/downloads/common kann man das runterladen unter “Disc based components”. Um es nochmal zu wiederholen, weil Fehler hier oft sehr merkwürdige Auswirkungen haben – wichtig: passend zur ROM-Version! Ich empfehle die “self-extracting archives”, dann braucht man nicht extra noch einen Entpacker. Die Datei kopiert man nach “hostfs”, damit sie von innerhalb RISC OS zur Verfügung steht.

Jetzt ist es endlich soweit, und RPCEmu kann gestartet werden: einfach rpcemu ausführen. Standardmäßig ist im mitgelieferten cmos.ram ADFS als Bootdateisystem konfiguriert, deshalb kommt man nicht mal in den Desktop. Also schnell von der Kommandozeile in RISC OS konfigurieren:
*co. filesystem HostFS
Dann einfach
*desktop
tippen und man kommt in die graphische Oberfläche. Hier auf das HostFS-Laufwerksitem clicken, das vorher dort platzierte HardDisc4-File mit dem Filetype “Utility” ausstatten, doppelclicken und warten bis sich alles entpackt hat. Es entsteht ein Verzeichnis “HardDisc4” – den Inhalt dieses Verzeichnisses ins Root verschieben.

Netzwerk einrichten

Die Kür ist die Netzwerkinstallation. Die soll hier gar nicht im Detail behandelt werden, denn die RPCEmu-Doku ist hier sehr gut und erlaubt ein schrittweises Einrichten.

In Kurzform:

  • rpcemu künftig per sudo starten
  • per iptables und sysctl das Tunnelling konfigurieren
  • im RPCEmu-Menü das Netzwerk aktivieren (Strg+Ende, Settings -> Networking -> IP-Tunneling)
  • RISC OS-Netzwerktreiber installieren
  • RISC OS-TCP/IP-Konfiguration durchführen

Quellen

RPCEmu-Homepage http://www.marutan.net/rpcemu/
Linux compile from source http://www.marutan.net/rpcemu/linuxcompile.html
RPCEmu networking http://www.marutan.net/rpcemu/manual/network.html
Linux networking: binary config http://www.marutan.net/rpcemu/manual/net-lin.html
Linux networking: IP tunnelling http://www.marutan.net/rpcemu/manual/net-lin-tun.html
Networking: RISC OS network driver install http://www.marutan.net/rpcemu/manual/net-ro.html
Networking: RISC OS configuration for IP tunnelling http://www.marutan.net/rpcemu/manual/net-ro-tun.html

Der Expertentipp zum Abschluss

Wer wie ich mal probeweise die Linux-Maschine virtuell eingerichtet hat (z.B. via VirtualBox), sollte darauf achten, im BIOS die Virtualisierungsoptionen einzuschalten (VT-x, Intel VT, AMD-V oder ähnlich). Sonst ist die Performance eher unterirdisch, und man kann auch auf 64bit-Systemen nur 32bit-Gastsysteme betreiben.

 

Aemulor-Innereien

Adrian Lees, Autor von Aemulor (Pro) und Geminus, hat zwei Artikel ins Netz gestellt, die der eine oder andere vielleicht schon aus der Foundation RISC User kennt. Darin werden einige interessante Details zur Implementierung von Aemulor und Aemulor Pro beschrieben.

Wer die letzten zwölf Jahre unter einem Stein gelebt hat: Aemulor ist ein High-Performance-Emulator für 26bit-Software auf 32bit-only-Plattformen wie IYONIX pc, A9home, Raspberry Pi, BeagleBoard, PandaBoard und ARMX6. Aemulor Pro setzt noch einen drauf und bietet nicht nur eine Plattform für gewöhnliche WIMP-Anwendungen, sondern emuliert auch alles notwendige für Dateisysteme aller Art (Win95FS, LanMan98, CDROMFS) und bietet eine Emulation für sogenannte “low colour depth screen modes” – neuere Systeme fangen meist erst bei 8bpp an, während bis zum Risc PC noch alles bis runter zu 1bpp unterstützt wurde – und tatsächlich wurde das auch von Anwendungen wie Sibelius 7 verwendet.

Besonders zur Anfangszeit des IYONIX pcs war Aemulor beinahe unverzichtbar, weil die Konvertierung der Anwendungen von 26bit nach 32bit doch recht zäh war, und außerdem absehbar war, dass einige wichtige Anwendungen wohl noch eine lange Zeit nicht konvertiert werden würden (Impression-Familie, Artworks, Photodesk) – dass heute eigentlich bis auf Impression und Sibelius keine der “großen” Anwendungen mehr auf Aemulor angewiesen ist, sollte als positives Zeichen für die Plattform aufgefasst werden.

An dieser Stelle ein persönlicher Dank an Adrian Lees, der dieses Stück Software, das beinahe an Magie grenzt, über all die Jahre gehegt und gepflegt hat und den Nutzern der neuen Cortex-A8/A9-Plattformen kostenlos zur Verfügung stellt.

RISC OS-Projekte: ein kompetenter Browser

In der Reihe “RISC OS-Projekte” soll es um Anregungen gehen für Menschen mit zu viel Freizeit. Es sollen Projekte beschrieben werden, die sowohl interessant sind, technisch anspruchsvoll und mit hohem Mehrwert für die RISC OS-Community. Den Anfang macht quasi eines der größten denkbaren Projekte überhaupt.

Die Geschichte der Browser für RISC OS ist lang. Es begann mit ArcWeb und Webster im Bereich Freeware. Dann kam die lange Reihe an Versuchen, Browser zu verkaufen: Fresco (immer nur erhältlich im Gesamtpaket der ANT Internet Suite), Webite (als Teil von Termite Internet), WebsterXL, Acorn Browse, Oregano, Oregano 2. Ein kurzes Zwischenspiel gab es mit einer Portierung von Firefox 2, die aber recht langsam und instabil war und nicht wirklich in RISC OS integriert war. Aktuell ist nur einer übrig geblieben: NetSurf, der unter der GPL steht und ständig weiterentwickelt wird.

Das Problem: das Internet entwickelt sich weiterhin rasant weiter. HTML5 und CSS3 sind aktuell die Standards, dazu tiefe JavaScript-Integration zur DOM-Manipulation. Die ständig zunehmende Verwendung von komplexem JavaScript erfordert außerdem ausgefeilte Optimierungsmechanismen bei der JavaScript-Interpretation. NetSurf hinkt schon heute dem Stand der Technik weit hinterher und hat bis heute keine anständige JavaScript-Unterstützung. Die Ziele der NetSurf-Entwickler sind sicher weitgehend passend für RISC OS-Zwecke (speicherplatzsparend, schnell, kompakt, gutes schlankes UI), aber was hilft das, wenn moderne Webseiten schlicht nicht zugänglich sind? Das sollte nicht als Kritik an NetSurf missverstanden werden – die Entwicklerkapazitäten sind dort begrenzt, und der Wettlauf gegen die Aktualisierung der Standards ist kaum zu gewinnen ohne ein großes Vollzeit-Entwicklerteam.

Im RISCOSOpen-Forum gibt es dazu einen Thread mit einer recht interessanten Diskussion dazu.

Unterm Strich bleibt meines Erachtens nur eine sinnvolle Option: die Portierung von Firefox/Gecko oder WebKit/Blinks. Nur damit ist garantiert, dass der Browser anständig kompatibel ist und bleibt mit den aktuellen Inhalten des Webs. WebKit scheint rein vom Portierungsaufwand her die bessere Wahl zu sein – es ist die deutlich jüngere Codebasis, wurde schon auf viele auch spärlich ausgestattete Plattformen portiert, und scheint generell besser modularisiert zu sein als Firefox bzw. Gecko.

Also, frisch ans Werk. Es braucht jemand, der sowohl unter RISC OS als auch unter Linux zuhause ist. Jemand, der die UI-Toolkits unter Linux kennt und natürlich WIMP-Experte ist. Jemand, der C und C++ im Schlaf beherrscht. Jemand, der die notwendige Entwicklungsinfrastruktur aufsetzen kann und dann natürlich auch betreibt. Und jemand, der reichlich Freizeit hat, um das Projekt voranzutreiben. Mit anderen Worten: einer allein wird das wohl kaum schaffen.

Grobe Vorgehensweise: einen ausreichend leistungsfähigen Linux-Server anmieten. Die heutzutage notwendige Infrastruktur aufsetzen (Gerrit/Git, Jenkins, GCCSDK). Das WebKit-Git-Repo clonen. Die WebKit-Portierung finden, die RISC OS technisch am nächsten ist. Code branchen und anfangen, den technischen Minimaldurchstich zu implementieren (hier gibt es Hinweise dazu). Nach und nach die Lücken füllen – vermutlich wird es sinnvoll sein, einige der Mainstream-Libs zu portieren wie Cairo und Freetype. Die notwendigen Anpassungen für die RISC OS-Portierung als Patches upstream zur Verfügung stellen. Eine anständige RISC OS-GUI drumrumstricken. Herausfinden, dass WebKit inzwischen von Blink abgelöst wurde. Gehe zurück auf Los. Froh sein, dass man die Basislibs schon portiert hat.

Ein ironisch-sarkastischer Beitrag zum Browser-Thema findet sich hier. “Because there are four of you” könnte zum geflügelten RISC OS-Ausspruch werden. Das Original von Peter Naulls ist auch immer noch von gewisser Aktualität und zeigt, wie alt das “Browser-Problem” schon ist.