Freetz für 6490?

[f666]

Beim Vergleichen der beiden Versionen fiel mir, speziell im Hinblick auf mein Setup, auf, dass der NFS Server auf dem Atom Kern komplett abgeschaltet wurde (Userspace Tools fehlen und die ganzen NFS Strings sind auch nicht mehr im Kernel). Blöd, mal sehen wie ich das wieder reingefummelt bekomme.

 

[fesc]

Ja, aergerlich. Fuer meine Zwecke (daten zwischen arm und atom kopieren) mache ich das jetzt ueber das rpc kommando.
Zumindest ein nfs client waere gut, entweder per kernel-modul oder via fuse. Ein kernel module hatte ich schon erfolgreich uebersetzt und am laufen (cdc-acm), aber bei komplizierteren bin ich gescheitert (bei mir war es alsa, ich weiss nicht wie es mit nfs/nfs kernel-server steht).

Um das thread-thema nochmal aufzugreifen. Nachdem man ja den arm core (fast) nicht mehr braucht (ich eigentlich nur noch um Daten in /nvram abzulegen) kann man freetz evtl. doch wieder in Angriff nehmen.

 

[f666]

Ich habe auch Interesse an freetz für die 6490. Leider habe ich keine eigene Box. Die einzige 6490, auf welche ich Zugriff habe, ist 260km entfernt und vermittelt dort den einzigen Internetzugang.
Ich kann aber mal im Laufe der nächsten Wochen "auf dem Reißbrett" schauen, was so geht.
Mit dem Atom Kern anzufangen, scheint der einfachste Einstieg zu sein.

 

[noob_noob]

@fesc:
thxs 4 v15. it's wörking ...

 

[f666]

So, habe endlich die GPL Sourcen für die 06.83 erhalten - auf einem per Benutzername/Kennwort geschütztem ftp Server (ftp://fritzbox-support.eu). Warum tut AVM sich das an?
Die Datei ist 1GB groß, ich habe keinen Webspace um die abzulegen. Heute Abend schau ich mal rein. Ich will dahin kommen, dass ein eigener Kernel mit NFS-Server auf meiner Box läuft.

Bzgl. Freetz:
Momentan lese ich mich immer noch in alles ein. fwmod ist der letzte Brocken, sollte ich diese oder nächste Woche durchdrungen haben. Was ich bisher an Arbeitspaketen sehe:

• tools/ ertüchtigen: z.B. das unpack_kernel / repack_kernel Skript erweitern - der ARM Kernel funktioniert schon jetzt, der x86 Kernel ist ein normaler bzImage Kernel im TI_AR7 Container

• modellspezifische config Datei für die 6490 erzeugen - am Anfang würde nur die Berücksichtigung des x86 Teils die Arbeit vereinfachen

• in irgendeinem Makefile ist die Kernel Architektur fest auf MIPS gestellt, muss wahrscheinlich korrigiert werden

• x86 Toolchain einpflegen & ausprobieren

• die ac_config_xxx Werte auf einer 6490 ermitteln, irgendwo liegt ein Paket dafür

• die ganzen Pakete kompilieren und eventuell MIPS spezifische Patches anpassen / erstellen

• die ganzen Pakete auf der 6490 ausprobieren

• fwmod Anpassen, dass es mit den beiden Dateisystemen (ARM, x86) zurecht kommt

 

[PeterPawn]

Wieviel Zeit ist denn zwischen Deiner Anforderung bei AVM und deren Antwort vergangen?

Ich gehe mal fest davon aus, daß das auch nicht die zukünftige Verfahrensweise mit den OpenSource-Paketen werden soll ... ansonsten bitte ich hiermit jeden Interessenten an Freetz (auch wenn das auf der 6490/6590 noch nicht machbar ist) oder auch jeden Benutzer irgendeiner von mir bereitgestellten Lösung darum, sich bei AVM zu melden und diese Quellen sowohl für die 6490 als auch die 6590 anzufordern.

Nach der GPLv2 ist der Besitz eines passenden AVM-Routers gar keine Voraussetzung für einen solchen Wunsch und mit meiner Aufforderung verbinde ich auch nicht die Erwartung, daß jeder, der meiner Bitte nachkommt, damit auch etwas anfangen kann.

Mein Ziel wäre es ganz ausdrücklich, den Arbeitsaufwand für AVM an dieser Stelle in einer Art und Weise zu steigern, daß so etwas wie der oben von @f666 beschriebene Ansatz gar nicht erst in den Verdacht gerät, sich in irgendeiner Form für AVM zu rentieren.

Es ist ohnehin schon so, daß von AVM lange nicht alles das bereitgestellt wird, was die GPLv2 fordert - das beste Beispiel sind die fehlenden Quellen für den Konfigurationsbereich im Kernel; ähnliches gilt für die Tools zum Erstellen des Dateisystem-Images.

Wenn man das oben von @f666 beschriebene Vorgehen jetzt als Community "klaglos" hinnimmt (selbst wenn man selbst gar keines der Cable-Modelle besitzt), geht das demnächst bei den DSL-Modellen weiter und dann wäre wirklich fast jede weitergehende Beschäftigung mit der FRITZ!Box und der darauf von AVM ausgeführten Software genauso gefährdet, wie die Möglichkeiten eigener Modifikation (bzw. der Aufwand dafür würde extrem gesteigert).

Wer sich hingegen (als FRITZ!Box-Besitzer/-Benutzer) der Illusion hingibt, daß mit der "Geheimhaltung" von FOSS-Quellen am Ende die Sicherheit irgendeiner Firmware tatsächlich verbessert würde, dem kann ich nur versichern, daß das Gegenteil der Fall wäre.

@f666:
Setze Dich mal bitte mit mir per E-Mail in Verbindung (passende Adressen findest Du in meinem GPG-Key im GitHub-Repo) ... unabhängig von der Verpflichtung für AVM zur Bereitstellung dieser Daten (die besteht weiterhin und ich halte auch meine o.a. Aufforderung "an die Community" unabhängig davon aufrecht) stelle ich gerne den Webspace zur Verfügung, um dieses Paket zu hosten.

 

[noob_noob]

@peter: mail an avm zur anforderung der sourcen ist raus.
@f666: auch ich biete dir gern den webspace zum hosten der datei(n)

 

[homie_4711]

Habe meine 6490 geschrottet. Kann mir jemand wieder ein funktionierendes Betriebsystem auf die AVM Fritz 6490 Cabel draufspielen?

LG
H

 

[noob_noob]

Habe meine 6490 geschrottet.

willkommen im forum. ist hier nicht so der richtige platz für diese nachfrage.
was hast du den damit gemacht?
[ gelöst ] 6490 per ftp/bootloader flashen und FritzBox 6490 Netzwerk-Setup zurücksetzen könntest du mal lesen wollen.

 

[PeterPawn]

So, mein Dank geht an @f666 für die notwendigen Daten, um die AVM-Datei auf meinem Server bereitstellen zu können.

Das erfolgt unter der folgenden URL:

http://yourfritz.de/6490/source-files-FRITZ.Box_6490_Cable-06.83.zip für die Quellen der 06.83 ...

und weil ich davon ausgehe, daß irgendwann in naher Zukunft die anderen Quelltext-Archive vom AVM-Server verschwinden werden, habe ich auch gleich noch die von der 06.61 (das war die letzte Version, wo der ARM-Teil noch wichtige Teile des FRITZ!OS enthielt - inzwischen ist das ja in großen Teilen nur noch die von Intel bereitgestellte Firmware auf diesem Core) daneben abgelegt:

http://yourfritz.de/6490/source-files-FRITZ.Box_6490_Cable-06.61.tar.gz
http://yourfritz.de/6490/source-files-FRITZ.Box_6490_Cable.atom-06.61.tar.gz

Ich will noch einmal explizit darauf hinweisen, daß es sich bei diesen Dateien nicht um AVM-Firmware-Images handelt, sondern um die nach der GPL von AVM für jeden Interessenten bereitzustelllenden Quelltext-Pakete, die entsprechenden Lizenzen (welche ihrerseits wiederum diese Bereitstellung zur Verpflichtung für jeden machen, der sich aus diesem Fundus bedient bei seinen eigenen Produkten) unterliegen.

PS: Ich habe selbst noch gar keine Zeit gehabt, mir die AVM-Datei anzusehen ... ich gehe aber nicht davon aus, daß da irgendwelche ZIP-Bomben o.ä. enthalten sind - auch wenn ich so etwas grundsätzlich erst einmal in einer geschützten Umgebung entpacke.

"Der Ordnung halber" hier noch die SHA-256-Hashes für die Dateien:

e314d8423cbb4821376422a741e49468cd41602afa54f6de5a0008811d0026b1  source-files-FRITZ.Box_6490_Cable-06.61.tar.gz
aa2d7c581ebfbba964e326c51226e9f66cb984181444d9a91bd5eb0b6ddfe8af  source-files-FRITZ.Box_6490_Cable-06.83.zip
a3ab9c3bc4f2a9a17e58b1d8ec582d2825a1f8ca757e8913a3ba00ae3d155ea9  source-files-FRITZ.Box_6490_Cable.atom-06.61.tar.gz

 

[noob_noob]

http://freifunk-nordheide.de/html/avm/source/6490/ liegt dort nun auch

 

[f666]

Könnte mir bitte jemand mit einer 06.83 die Ausgaben von /proc/kallsyms zur Verfügung stellen? Im Idealfall von beiden Cores (x86 & ARM).
Ich probiere gerade das Kompilieren von einem eigenen Kernel bzw. ob ich den von AVM reproduzieren kann.
Dummerweise bekomme ich es nicht hin, die Symbole direkt aus der Kernel Datei zu extrahieren (und auf der einzigen 6490 auf die ich Remotezugriff habe, läuft noch die 06.63).

 

[PeterPawn]

Hast Du den Kernel zuerst entpackt?

Ansonsten gibt es Tools, die auch aus einem "offline"-Kernel (solange der ungepackt ist) diese Symbole extrahieren können (irgendwo in den Kernel-Quellen) - die Symbole werden in komprimierter Form gespeichert (das hat nichts mit dem Packen des Kernels an sich zu tun).

Das bezieht sich natürlich jetzt alles nur auf den letzten Satz in der Anfrage ... wenn ich mich richtig erinnere, gab es bei der 6490 ein echtes Problem beim "cat /proc/kallsyms" - da stürzte das System sang- und klanglos ab. Ich weiß allerdings nicht, welche Version das genau betraf - aber ich will/kann das jetzt auch nicht ausprobieren (falls das Problem noch existiert) ... die Box muß laufen.

Gefunden: https://www.ip-phone-forum.de/threa...schiedene-artikelnummern.287537/#post-2180043

 

[f666]

Momentan bearbeite ich nur den x86 Kernel. Entpacken ist da einfach, es ist ein ganz normales bzImage in einem "EVA Container" mit zusätzlicher TI Prüfsumme.
Leider ist der Kernel gestrippt. nm, objdump, readelf beißen sich da die Zähne aus. Das mksysmap Skript aus den Kernel Quellen benutzt selbst wiederum nm.

cat /proc/kallsyms auf dem x86 Core hat auf der 06.63 getan. Auf dem ARM Core hat es reproduzierbar zu einem Absturz geführt.
Falls jemand einen Absturz seiner/ihrer Box riskieren kann, wäre auch die Ausgabe nur vom x86 Core vorerst für mich topp.

 

[stoney]

@f666 würde eine stellen, zwar mit alten certs was ja nichts ausmachen sollte ?!

 

[f666]

Zwischenstand:
Habe jetzt eine funktionsfähige Box, mit (vorerst) einer seriellen Konsole und der 06.83 drauf.
Mit der AVM Toolchain habe ich mir einen eigenen x86 Kernel inklusive NFS Unterstützung gebaut. Dieser bootet auf der Box und die Box scheint auch sonst zu funktionieren.

Hier ein Vorschlag, wie die passenden Tools für den Umgang mit 6490 Kerneln aussehen könnten.
Ich habe versucht, meine Änderungen klein zu halten und alles vom Stil her zu übernehmen. Ich habe aber keinerlei Ambitionen, dass das so bleiben muss. Gerne ändern.

Spoiler: unpack-kernel

Index: unpack-kernel
===================================================================
--- unpack-kernel       (Revision 14346)
+++ unpack-kernel       (Arbeitskopie)
@@ -184,31 +184,31 @@
 }
 
 getTiRecordLen() {
-       local tiRecordOfset=$1
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + 4))
+       local tiRecordOffset=$1
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + 4))
 }
 
 getLoadAddr() {
-       local tiRecordOfset=$1
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + 8))
+       local tiRecordOffset=$1
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + 8))
 }
 
 getEntryAddr() {
-       local tiRecordOfset=$1
-       local tiRecordLen=$(getTiRecordLen $tiRecordOfset)
+       local tiRecordOffset=$1
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)
 
-       local tiRecordEntryZero=$(getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 16)))
+       local tiRecordEntryZero=$(getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 16)))
        if [ "$tiRecordEntryZero" -ne 0 ]; then                                                                                                                                                                  
                echo >&2 "WARNING: entry address is expected to be prefixed with one 32-bit zero word"                                                                                                           
        fi                                                                                                                                                                                                       
                                                                                                                                                                                                                 
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 20))                                                                                                                                    
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 20))                                                                                                                                   
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
 getTiRecordChecksum() {                                                                                                                                                                                         
-       local tiRecordOfset=$1                                                                                                                                                                                   
-       local tiRecordLen=$(getTiRecordLen $tiRecordOfset)                                                                                                                                                       
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 12))                                                                                                                                    
+       local tiRecordOffset=$1                                                                                                                                                                                  
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)                                                                                                                                                      
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 12))                                                                                                                                   
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
                                                                                                                                                                                                                 
@@ -220,7 +220,7 @@                                                                                                                                                                                              
 #                                                                                                                                                                                                               
 # returns offset of the magic sequence by setting the global variable TI_RECORD_OFFSET                                                                                                                          
 #                                                                                                                                                                                                               
-findAndProcessTiRecord() {                                                                                                                                                                                      
+findAndUnLzmaTiRecord() {                                                                                                                                                                                       
        local magic="$1"                                                                                                                                                                                         
        local tiRecordName="$2"                                                                                                                                                                                  
        local tiRecordPrefix=$(echo -n "$tiRecordName" | tr -c '_a-zA-Z0-9' '_')                                                                                                                                 
@@ -252,15 +252,62 @@                                                                                                                                                                                            
        TI_RECORD_OFFSET=$tiRecordOffset                                                                                                                                                                         
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
+#                                                                                                                                                                                                               
+# $1 - magic sequence (in little-endian notation)                                                                                                                                                               
+# $2 - TI-record name                                                                                                                                                                                           
+# $3 - name of the file output to be written to                                                                                                                                                                 
+# $4 - tight lower bound of the magic sequence match, optional                                                                                                                                                  
+#                                                                                                                                                                                                               
+# returns offset of the magic sequence by setting the global variable TI_RECORD_OFFSET                                                                                                                          
+#                                                                                                                                                                                                               
+findAndExtractTiRecord() {                                                                                                                                                                                      
+       local magic="$1"                                                                                                                                                                                         
+       local tiRecordName="$2"                                                                                                                                                                                  
+       local tiRecordPrefix=$(echo -n "$tiRecordName" | tr -c '_a-zA-Z0-9' '_')
+       tiRecordPrefix=${tiRecordPrefix}${tiRecordPrefix:+.}
+       local outputFile="$3"
+       local lowerBound="$4"
+
+       # unset return value
+       TI_RECORD_OFFSET=""
+
+       local tiRecordOffset="", tiRecordLzmaRecordOffset=""
+       { tiRecordOffset=$(getDecOffsetOf1stMagicSequenceMatch $magic "$tiRecordName" 1 $lowerBound); } || return 1
+       echo "${tiRecordPrefix}RecordOffset=$(print08X $tiRecordOffset)"
+       local tiRecordLoadAddr=$(getLoadAddr $tiRecordOffset)
+       echo "${tiRecordPrefix}LoadAddress=$(print08X $tiRecordLoadAddr)"
+       local tiRecordEntryAddr=$(getEntryAddr $tiRecordOffset)
+       echo "${tiRecordPrefix}EntryAddress=$(print08X $tiRecordEntryAddr)"
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)
+       echo "${tiRecordPrefix}RecordLength=$(print08X $tiRecordLen)"
+       local tiRecordChecksum=$(getTiRecordChecksum $tiRecordOffset)
+       echo "${tiRecordPrefix}RecordChecksum=$(print08X $tiRecordChecksum)"
+
+       if [ "$METHOD" == "info" ]; then
+               return 0
+       fi
+
+       dd if="$INPUT_FILE" bs=1 skip=$(($tiRecordOffset + 12)) count=$(($tiRecordLen)) of="$outputFile" 2>/dev/null
+
+       [ $? -ne 0 ] && { echo >&2 "ERROR: failed to extract kernel"; return 1; }
+
+       # set return value
+       TI_RECORD_OFFSET=$tiRecordOffset
+}
+
 ##
 
 TI_AR7_MAGIC=FEED1281
 DUAL_KERNEL_MAGIC=FEED9112
 TI_AR7_2ND_MAGIC=FEEDB007
+TI_PUMA6_MAGIC=FEED8112
 EVA_LZMA_RECORD_MAGIC=075A0201
 
 # 1st kernel (all boxes)
-findAndProcessTiRecord $TI_AR7_MAGIC "TI-AR7" "$OUTPUT_FILE" || exit 1
+if ! findAndUnLzmaTiRecord $TI_AR7_MAGIC "TI-AR7" "$OUTPUT_FILE"; then
+       findAndExtractTiRecord $TI_PUMA6_MAGIC "TI-AR7" "$OUTPUT_FILE" || exit 1
+       exit 0
+fi
 feed1281_Offset=$TI_RECORD_OFFSET
 
 # 2nd kernel (GRX5 boxes only)
@@ -285,6 +332,6 @@
        feedb007_LowerBound=$((feed1281_Offset + $(getTiRecordLen $feed1281_Offset)  + 24))
        feedb007_LowerBound=$((feedb007_LowerBound + (4 - feedb007_LowerBound%4)%4)) # pad to a 4-byte boundary
 
-       findAndProcessTiRecord $TI_AR7_2ND_MAGIC "TI-AR7-2ND" "${OUTPUT_FILE}.2ND" $((feedb007_LowerBound-1)) || exit 1
+       findAndUnLzmaTiRecord $TI_AR7_2ND_MAGIC "TI-AR7-2ND" "${OUTPUT_FILE}.2ND" $((feedb007_LowerBound-1)) || exit 1
        feedb007_Offset=$TI_RECORD_OFFSET
 fi

Spoiler: eva2bzimage.c

/*
    eva2bzimage 
    Copyright (C) 2017  Sebastian Frei <[email protected]>
    derived from eva2lzma, derived from
    lzma2eva - convert lzma-compressed file to AVM EVA bootloader format
    Copyright (C) 2007  Enrik Berkhan <[email protected]>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
*/

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

void
usage(void)
{
  fprintf(stderr, "usage: eva2bzimage <evafile> <bzimagefile>\n");
  exit(1);
}

void
pexit(const char *msg)
{
  perror(msg);
  exit(1);
}

int
main(int argc, char *argv[])
{

  FILE *in = NULL, *out = NULL;
  uint8_t buf;

  uint32_t magic = 0xfeed1281L;
  uint32_t reclength = 0;
  uint32_t loadaddress = 0;
  uint32_t checksum = 0;
  uint32_t checksum_calc = 0;
  uint32_t compsize = 0;

  uint32_t zero = 0;
  uint32_t entry = 0;

  if (argc != 3)
    usage();

  /* "parse" command line */
  in = fopen(argv[1], "rb");
  if (!in)
    pexit("fopen");
  out = fopen(argv[2], "w+b");
  if (!out)
    pexit("fopen");

  /* read EVA header */
  if (1 != fread(&magic, sizeof magic, 1, in))
    pexit("fread");
  printf("MAGIC=0x%X\n", magic);
  if (1 != fread(&reclength, sizeof reclength, 1, in))
    pexit("fread");
  printf("RECLENGHT=0x%X\n", reclength);
  if (1 != fread(&loadaddress, sizeof loadaddress, 1, in))
    pexit("fread");
  printf("LOADADDR=0x%X\n",loadaddress);

  checksum_calc = reclength + loadaddress;

  /* copy data, calculate crc32 */
  while (compsize < reclength) {
    if (1 != fread(&buf, sizeof buf, 1, in))
      pexit("fread");
    compsize++;
    if (1 != fwrite(&buf, sizeof buf, 1, out))
      pexit("fwrite");
    checksum_calc += buf;
  }

  checksum_calc = ~checksum_calc + 1;
  printf("CHECKSUM_CALC=0x%X\n", checksum_calc);

  if (1 != fread(&checksum, sizeof checksum, 1, in))
    pexit("fread");
  printf("CHECKSUM=0x%X\n", checksum);

  if (1 != fread(&zero, sizeof zero, 1, in))
    pexit("fread");
  printf("ZERO=0x%X\n", zero);
  if (1 != fread(&entry, sizeof entry, 1, in))
    pexit("fread");
  printf("ENTRY=0x%X\n", entry);

  fclose(in);

  if (fclose(out))
    pexit("fclose");

  return 0;

Spoiler: bzimage2eva.c

/*
        bzimage2eva
        Copyright (C) 2017  Sebastian Frei <[email protected]>
        derived from

    lzma2eva - convert lzma-compressed file to AVM EVA bootloader format
    Copyright (C) 2007  Enrik Berkhan <[email protected]>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
*/

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

void
usage(void)
{
  fprintf(stderr, "usage: bzimage2eva <loadadddr> <entry> <bzimagefile> <evafile>\n");
  exit(1);
}

void
pexit(const char *msg)
{
  perror(msg);
  exit(1);
}

int
main(int argc, char *argv[])
{

  const char *infile, *outfile;
  FILE *in, *out;
  uint8_t buf[4096];
  size_t elems;

  uint32_t magic = 0xfeed8112L;
  uint32_t reclength = 0;
  fpos_t reclengthpos;
  uint32_t loadaddress = 0;
  uint32_t checksum = 0;

  uint32_t compsize = 0;

  uint32_t zero = 0;
  uint32_t entry = 0;

  if (argc != 5)
    usage();

  /* "parse" command line */
  loadaddress = strtoul(argv[1], 0, 0);
  entry = strtoul(argv[2], 0, 0);
  infile = argv[3];
  outfile = argv[4];

  in = fopen(infile, "rb");
  if (!in)
    pexit("fopen");
  out = fopen(outfile, "w+b");
  if (!out)
    pexit("fopen");

  /* write EVA header */
  if (1 != fwrite(&magic, sizeof magic, 1, out))
    pexit("fwrite");
  if (fgetpos(out, &reclengthpos))
    pexit("fgetpos");
  if (1 != fwrite(&reclength, sizeof reclength, 1, out))
    pexit("fwrite");
  if (1 != fwrite(&loadaddress, sizeof loadaddress, 1, out))
    pexit("fwrite");

  /* copy compressed data */
  while (0 < (elems = fread(&buf, sizeof buf[0], sizeof buf, in))) {
    compsize += elems;
    if (elems != fwrite(&buf, sizeof buf[0], elems, out))
      pexit("fwrite");
  }
  if (ferror(in))
    pexit("fread");
  fclose(in);

  /* re-write record length */
  reclength = compsize;
  if (fsetpos(out, &reclengthpos))
    pexit("fsetpos");
  if (1 != fwrite(&reclength, sizeof reclength, 1, out))
    pexit("fwrite");

  /* calculate record checksum */
  checksum += reclength;
  checksum += loadaddress;
  if (fseek(out, 4, SEEK_CUR)) // skip loadaddress
    pexit("fseek");
  while (0 < (elems = fread(&buf, sizeof buf[0], sizeof buf, out))) {
    size_t i;
    for (i = 0; i < elems; ++i)
      checksum += buf[i];
  }
  if (ferror(out))
    pexit("fread");
  if (fseek(out, 0, SEEK_CUR))
    pexit("fseek");

  checksum = ~checksum + 1;
  if (1 != fwrite(&checksum, sizeof checksum, 1, out))
    pexit("fwrite");

  /* write entry record */
  if (1 != fwrite(&zero, sizeof zero, 1, out))
    pexit("fwrite");
  if (1 != fwrite(&entry, sizeof entry, 1, out))
    pexit("fwrite");

  if (fclose(out))
    pexit("fclose");

  return 0;
}

Als nächstes werde ich mich etwas der AVM ARM Toolchain widmen (auch wenn das für freetz vorerst zweitrangig ist). Einfach um alles etwas besser zu verstehen.

 

[f666]

Zwischenstand:

Beide (GPL) Toolchains von AVM laufen und produzieren eigene Kernel, welche auch auf der Box laufen.
Die Toolchains auf einem aktuellen System zum Laufen zu bekommen, war einigermaßen umständlich, da die ganzen Tools doch recht alt sind und auf einem modernen System Probleme machen.
Zusätzlich gibt es noch diverse Tools, welche notwendig sind, aber AVM nicht mitliefert oder verwirrend benennt (z.B. lzma was bei AVM 7zip heißt). Außerdem müssen noch verschiedene Environmentvariablen passend erzeugt werden, bis alles tut.
An sich sind es aber recht "normale" Toolchains ohne größere Besonderheiten.

Der zweite Part, alles auf die Box zu bekommen, war dann wieder recht einfach. Spezielle Klimmzüge waren nicht notwendig (wie z.B. avm_config_area oder so).

Insgesamt bin ich optimistisch, dass man Freetz auf den x86 Kern der 6490 bekommt.
Nächste Schritte:
- Konfigurationsdateien für die 6490 erstellen
- Toolchain von Freetz bauen lassen
- ac_config Testprogramme ausführen und Ergebnisse in die Konfigurationsdateien zurückfließen lassen
- fwmod an die Besonderheiten der 6490 anpassen

Allerdings bin ich jetzt 1,5 Monate im Urlaub und werde in dieser Zeit nichts weiter dran tun.

 

[stoney]

Will auch 1,5 Monate Urlaub machen

Danke fürs Zwischenupdate

 

[f666]

Eigentlich ist es kein Urlaub und wenn ich die Kosten, die in den nächsten 18 Jahren auf mich zu kommen zusammen rechne, kommt die arbeitsfreie Zeit zu einem verdammt hohen Preis.

 

[stoney]

Der Storch kommt ? GW

Da sei dir mal mit 18 Jahren nicht so sicher