Logikbaustein 12275_BackMeUp -- BETA

[Taxus]

Und läuft .

Es liegt vermutlich
a) an der doch stark unterschiedlichen Größe der DOMs und
b) am verwendeten Werkzeug, man nimmt halt erstmal, was man auf der Platte hat. -

Es ist also vermutlich (Verzeihung: sicher ) so, dass die Files Deines Bausteins perfekt sind, wenn man diese auf DOMs gleicher oder ähnlicher Größe sichert. Das geeignetste Werkzeug (winimage oder dd oder ...?) wäre noch durch jemanden zu ermitteln, der gerade einen größeren Satz DOMs zur Hand hat .
Ich vermute, dass die Blockgröße (?) bei mir einfach zu stark abweicht. Mit den richtigen Parametern für dd (ich tippe bs und conv, aber da bin ich nicht zu Hause) könnte das ggf. auch problemlos klappen.

Gestern (oder war es schon heute ...) war auch auch das Klonen von KleinDOM auf GroßDOM mit Acronis (True Image Home PE 7.0) nicht erfolgreich.

Jetzt habe ich das derzeit nach kostenloser Registrierung hier erhältliche Paragon Backup & Recovery 10 Free Edition verwendet. Außer 'weiter-weiter-weiter-...' gibt es keine Optionen, also narrensicher. Damit war das Sichern und Übertragen in wenigen Minuten erledigt. Das Programm sucht im letzten Schritt der Wiederherstellung relativ lange nach einem bootbaren Windows ;-), um dann wohl den MBR selbst zu schreiben - mit Erfolg.

@Nils, die Arbeit mit dem alternativen kernel.sys brauchst Du Dir sicher nicht mehr zu machen. Ich bin überzeugt, dass bald jemand hier mit der Ausgabe Deines Bausteins auf ein 'identisches' Flash-DOM und WinImage Erfolg hat. Danke für die tolle Arbeit!

Ich war schon kurz vor der Installation eines grub, ... Platz ist ja noch genug auf dem Flash .

[stefju]

Hallo,

super Sache dieser Backup. Doch irgendwie stehe ich auf dem Schlauch.
Wie kann man mit WinImage das clone.img schreiben?

Ich benutze das WinImage 8.50. Ich öffen das clone.img ....

und dann??

Ist es Virtuelle Festplattenabbildung auf ... zurückspielen?? Funktioniert nicht...

Kann mir mal jemand einen Tipp geben. Danke.

Gruß Stefan

[NilsS]

Update V0.76

Nichts desto trotz würde ich doch gerne wissen woran es nun liegt.

Ich lade nochmal die Version hoch, die die Partitionstabelle anzeigt. (mbr.txt)
wenn mal jemand mit dem 1GB Dom mir seine Partitionstabelle (nur den BASE64) schicken könnte.

Eigentlich muss es denn auch so gehen, ich mache sowas ähnliches nämlich sonst öfters in einer anderen Liga und da gibts keine Probleme. (ESXi mittels dd auf nen USB Stick, dort passt die Partitionstabelle auch nicht zum Medium, aber da keine Probleme)

https://knx-user-forum.de/downloads.php?do=file&id=343

[NilsS]

Will den Source von den Teilen die das DOM kopieren mal veröffentlichen, da es sich ja um Systemkomponenten handelt die da geändert werden.

class hddDUp:
        def __init__(self):
            self.setGeom()
            self.getCHS=lambda byte0,byte1,byte2: (((byte1 >> 6) << 8 | byte2),byte0,(byte1 & 0x3F))
            self.setCHS=lambda cyl,head,sect: (head,(sect | (cyl >> 8 <<6)),(cyl & 0xff))

        def setGeom(self,geom=[16,32]):
            self.DOMgeometry=[] + geom + [1]
            self.LBA2CHS=lambda lba,mHead=self.DOMgeometry[0],SectPT=self.DOMgeometry[1]: ((lba / SectPT)/mHead,(lba / SectPT)%mHead,(lba % SectPT)+1)


        def decodePTable(self,partentry):
            ( status, sCHS_byte0, sCHS_byte1, sCHS_byte2, part_type, eCHS_byte0, eCHS_byte1, eCHS_byte2, lba, blocks) = __import__('struct').unpack( "<BBBBBBBBLL", partentry ) 
            (scyl,shead,ssect) = self.getCHS(sCHS_byte0,sCHS_byte1,sCHS_byte2)
            (ecyl,ehead,esect) = self.getCHS(eCHS_byte0,eCHS_byte1,eCHS_byte2)
            mbrfailure=0
            if self.DOMgeometry[2] == 0:
                self.DOMgeometry = [ehead,esect,1]
            else:
                if self.DOMgeometry[:2] != [ehead,esect]:
                    ###DEBUG###print "Partitionfailure "+repr(self.DOMgeometry[:2]) +" !=  "+repr([ehead,esect])
                    mbrfailure=1
            
            return mbrfailure,status,scyl,shead,ssect,part_type,ecyl,ehead,esect,lba,blocks

        def encodePTable(self,lba,blocks,part_type,boot=False):
            if boot:
                status = 0x80
            else:
                status = 0
            (sCHS_byte0, sCHS_byte1, sCHS_byte2) = self.LBA2CHS(lba)
            (sCHS_byte0, sCHS_byte1, sCHS_byte2) = self.setCHS(sCHS_byte0, sCHS_byte1, sCHS_byte2)
            (eCHS_byte0, eCHS_byte1, eCHS_byte2) = self.LBA2CHS(lba+blocks-1)
            (eCHS_byte0, eCHS_byte1, eCHS_byte2) = self.setCHS(eCHS_byte0, eCHS_byte1, eCHS_byte2)
            return __import__('struct').pack( "<BBBBBBBBLL", status, sCHS_byte0, sCHS_byte1, sCHS_byte2, part_type, eCHS_byte0, eCHS_byte1, eCHS_byte2, lba, blocks ) 


        def readMBR(self):
            ## System finden
            hdddrive = self.MC.StammDat[:-1]
            ### Jetzt den MBR lesen
            try:
                hnd = open(hdddrive,"rb")
                ###DEBUG###print "Read MBR"
                mbr = hnd.read(512)
            finally:
                hnd.close()
            return mbr
        
        def getPartInfo(self,mbr=False):
            self.DOMgeometry[2] = 0
            if not mbr:
                mbr = self.readMBR()
            partition_table = mbr[446:510]
            PARTENTRYSIZE = 16
            partition_info = []
            partitionfailure = 0
            for part in range(4):
                offset = PARTENTRYSIZE*part
                info = self.decodePTable(partition_table[offset:offset+PARTENTRYSIZE])
                partitionfailure += info[0]
                partition_info.append(info[1:])
            return partitionfailure,partition_info
            


        def getMBR(self,stream=False):
            html = ""
            count = 0
            mbr = self.readMBR()
            failed, partitions = self.getPartInfo(mbr)
            for part in partitions:
                count += 1
                html += "Partition #%i\\n" % (count)
                ( status,scyl,shead,ssect,part_type,ecyl,ehead,esect,lba,blocks ) = part
                if status == 0x80: 
                    html+= "Bootable\\n"
                elif status: 
                    html+= "Unknown status [%s]\\n" % hex(status)
                html+= "Type=0x%x\\n" % part_type 
                html+= " (Start: Heads:%i\tCyl:%i\tSect:%i) \\n" % (shead,scyl,ssect)
                html+= " (End: Heads:%i\tCyl:%i\tSect:%i) \\n" % (ehead,ecyl,esect)
                html+= " LBA:" +repr(lba ) + "\\n"
                html+= " Blocks:" +repr(blocks) +"\\n"
                html+="\\n\\n\\n"
            html+= " Partiontabelle: "+__import__('re').sub("\\n","",__import__('base64').encodestring(mbr[446:510]))+"\\n\\n"
            #html += "\\n\\n:Tabelle: "+ __import__('base64').encodestring(partition_table) +"\\n\\n"
            if stream:
                stream.write(html)
                return len(html)
            return html

        
        def hddHS2Backup(self,stream=False):
            self.hddFBackup(stream,pTable=[4320,16640,20736,20736])
        
        def hddHS3Backup(self,stream=False):
            self.hddFBackup(stream,pTable=[4320,20224,50176,53248])

        def hddFS3Backup(self,stream=False):
            self.hddFBackup(stream,pTable=[5088,97280,204800,204800])

        def hddFBackup(self,stream=False,pTable=False):
            mbr = self.readMBR()
            failed, partitions = self.getPartInfo(mbr)
            changeTable = True
            if not pTable:
                changeTable = False
                pTable = map(lambda x:x[-1],partitions)
                ###DEBUG###print "Using old Partitiontable: "+repr(pTable)

            fullsize=32
            ENDPART=[]
            for block in pTable:
                fullsize+=block
                ENDPART.append(fullsize)
                
            
            compress_size = 0
            calcCRC = __import__('zlib').crc32
            CRC = calcCRC("")
            file_size = 0
            
            ##Write GZIP-Header
            stream.write("\\037\\213\\010\\x00" + __import__('struct').pack("<L", long(__import__('time').time())) + "\\002\\377")
            
            ## Compression Objekt
            compobj=__import__('zlib').compressobj(4,__import__('zlib').DEFLATED,-__import__('zlib').MAX_WBITS,__import__('zlib').DEF_MEM_LEVEL, 0)


            hdddrive = self.MC.StammDat[:-1]
            
            StartSector = 32
            if changeTable:
                newpTable = ""
                self.setGeom([((fullsize > 262144) and 16 or 8),32])
                isBoot = [1,0,0,0]
                partitionType= [1,6,6,6]
                ## Partitionstabelle erstellen
                for newP in range(4):
                    ###DEBUG###print "Add Entry "+str(newP) + " Partitiontable"
                    newpTable += self.encodePTable(StartSector,pTable[newP],partitionType[newP],isBoot[newP])
                    StartSector += pTable[newP]

                ## Partitionstabelle in den MBR bauen
                mbrnew = mbr[:446] + newpTable + mbr[510:512]
                ###DEBUG###print "new Partitiontable:" +repr(self.getPartInfo(mbrnew))
            else:
                mbrnew = mbr
            ## leeren Sektor 
            blank_sektor = "".join(["\\x00" for i in range(512)])
            
            ## Zähler für die gelesenen Sektoren a 512bytes
            lba=1
            
            ###DEBUG###print "OLDMBR: "+str(len(mbr))+ "  NEWMBR: "+str(len(mbrnew))

            ## Checksummen berechnen und komprimieren
            CRC = calcCRC(mbrnew, CRC)
            buf = compobj.compress(mbrnew)
            compress_size += len(buf)
            file_size += len(mbrnew)
            
            ## an CLient senden
            stream.write(buf)
            
            while lba<32:
                CRC = calcCRC(blank_sektor, CRC)
                buf = compobj.compress(blank_sektor)
                file_size += len(blank_sektor)
                compress_size += len(buf)
                stream.write(buf)
                lba+=1
            
            for partition in range(4):
                ###DEBUG###nextdebugbyte=1000000
                ## Jetzt die Partition kopieren
                nodata = 0
                try:
                    ###DEBUG###print "Read Partition " +str(partition+1)
                    hnd = open(hdddrive+str(partition+1),"rb")
                    while lba<(ENDPART[partition]):
                        try:
                            r = hnd.read(4096)
                        except IOError:
                            pass
                        if not r:
                            ###DEBUG###print "Out of Data"
                            break
                        ## gezipped an Client
                        if len(r)<4096:
                            print "Missing Bytes: "+str(4096-len(r))
                            #r+="".join(["\\x00" for i in range(4096-len(r))])
                            
                        file_size += len(r)
                        buf = compobj.compress(r)
                        CRC = calcCRC(r, CRC)
                        compress_size += len(buf)
                        ###DEBUG###if compress_size > nextdebugbyte:
                            ###DEBUG###print "ZIPSIZE: "+str(compress_size)+ " - Filesize: "+str(file_size)
                            ###DEBUG###nextdebugbyte+=1000000
                        stream.write(buf)
                        lba+=(len(r)/512)
                        #if filter(lambda x: ord(x)<>0,r) == "":
                        #    nodata += 1
                        #else:
                        #    nodata = 0
                        #if nodata>100:
                        #    ###DEBUG###print "break - only 0x00 Data"
                        #    break

                finally:
                    hnd.close()
                
                ## mit 00 auffüllen bis zum Start von Partition 1
                ###DEBUG###print "Fill with 00 till start of Partition " +str(partition+1)
                ###DEBUG###print "adding " +str(ENDPART[partition]-lba)+" blank Sektors"
                while lba < (ENDPART[partition]):
                    CRC = calcCRC(blank_sektor, CRC)
                    buf = compobj.compress(blank_sektor)
                    file_size += len(blank_sektor)
                    compress_size += len(buf)
                    stream.write(buf)
                    lba+=1
                ###DEBUG###print "DONE: lba=" +str(lba)
                ###DEBUG###print "Image now "+str((lba*512))+" bytes" 
                
                
            while lba < fullsize:
                CRC = calcCRC(blank_sektor, CRC)
                buf = compobj.compress(blank_sektor)
                file_size += len(blank_sektor)
                compress_size += len(buf)
                stream.write(buf)
                lba+=1

            buf = compobj.flush()
            compress_size += len(buf)
            stream.write(buf)
            if CRC<0:
                CRC += 0x100000000L
            stream.write(__import__('struct').pack("<L",CRC))
            stream.write(__import__('struct').pack("<L",file_size))
            return compress_size

evtl. mach ich die 1:1 Kopie als ein einmaliges lesen von hdx und nicht von den einzelnen Partitionen

[NilsS]

Gerade gefunden,


How to create a FreeDOS bootable CF card

Image copy See freedos.zip for an example image. This works for the cf128al CF card, but not for cards with a different geometry. Use Linux dd, or dd for Windows (special version included in the package). chrysocome.net - dd for windows

LBA image Courtesy of sbyoon / pfsense forum. Download freedos3.zip image file, unzip and write the image to CF card using physdiskwrite. Update any files as needed, then install the CF card on ALIX. Enter setup (press S during memory test), enter L (LBA) Q (quit) Y (yes). The system should boot from the CF card, run sb.com to reprogram flash.

Caveats: Make a backup of the blank CF card with dd if you want to reuse it - repartitioning CF cards is tricky. The LBA image works on CF cards of 16 MB or larger, but only gives you 16 MB total space no matter what size your card is.

Ist also ein Freedos bekanntes Problem

[Taxus]

wenn mal jemand mit dem 1GB Dom mir seine Partitionstabelle (nur den BASE64) schicken könnte.

Bittesehr:

Partiontabelle: gAAhAAQFBQIgAAAA4BAAAAAFBgIEDQ0KABEAAABBAAAADQ4KBBYWFABSAAAAUQAAABYXFAQfHx4AowAAAFEAAA==

Mir ist im Klartextteil aufgefallen, dass - offenbar durch Paragon BuR - der Partitionstyp von 0x01 auf 0x04 geändert wurde.

[NilsS]

So ich hab jetzt auch mal auf 1GB gecloned und mir dann mal angesehen was fdisk dazu sagt.

Da sieht das nicht so aus wie das was Paragon Schießmichtot daraus gemacht hat. ich werd mal testen. Da sind 64 Sektoren und nicht 32.

[NilsS]

Testversion die 63 (nicht 64 ) Sektoren verwendet.

Die ist jetzt für 1GB DOMs optimiert.
--ungetestet--

[stefju]

Hallo Nils,

könntest Du uns kurz sagen wie Du mit winimage Dein gesichertes
clone.ing auf ein DOM schreibst?

Gruß Stefan

[NilsS]

Das clone.img.gz mit 7zip entpacken

WinImage starten und im 2.Screenshot gezeigt auf physikalischen Datenträger wiederherstellen.

https://knx-user-forum.de/120408-post16.html

[MarcNaroska]

Der Trick ist, dass man bei der Image-Dateiauswahl als Dateityp "All files (*.*)" auswählen muss, damit die Images auch angezeigt werden...

[NilsS]

Evtl. je nach Adaptertyp den Hacken bei Include non removable Disk setzen.

ACHTUNG: NICHT DIE FALSCHE PARTITION WÄHLEN, sonst ists Windows Futsch.

[marlan99]

Habs jetzt mit meinem 4GB Transcend DOM auch zum laufen gebracht.
Falls es interessiert hier die Partitionstabelle:

Partiontabelle: gAEBAAbyMQE/AAAAQXoAAAAAAQIG/j8Egn0AAEO8AAAAAAEFBv4/+8U5AQA3jDwAAAAB/Ab+f/L8xT0AN4w8AA==

Gruss
Marcel

[Taxus]

Habs jetzt mit meinem 4GB Transcend DOM auch zum laufen gebracht.

@Marcel, und mit welchen Werkzeugen?



@Nils, hier meine Tests (vor dem Schreiben auf den DOM habe ich diesen für reproduzierbare Ergebnisse immer per dd ge-/dev/zero-ed, ebenso jeweils einmal mit WinImage beschrieben und getestet, dann nochmal dasselbe mit dd).

1. Ausgangsbasis: HS2 mit dem gestern zum Laufen gebrachten 1GB-DOM mit dem Image der vier Partitionen und dem von Paragon angelegten MBR.
2. Alle *.img per Baustein 0.77 gesichert
3. clone.img auf das (selbe) DOM übertragen -> ok. Das ist der wahre Backupfall, also perfekt.
4. 32MB-DOM wieder aus dem Keller geholt , eingesetzt, Projekt mit aktuellem Baustein 0.77 übertragen, alle *.img gesichert.
5. clone.img auf den 1GB-DOM übertragen -> bootet nicht, bleibt wie gestern schon bei F1..F4 hängen.

Ich habe jetzt wieder das Image aus Step 3 installiert.

PS: ich hatte den DOM-Tausch gleichzeitig als einen 24h-ohne-HS-Selbstversuch hergenommen: ich bin froh, dass er wieder am Bus hängt; der Komfortverlust war doch deutlich. Es hat sich aber ausgezahlt, doch den einen oder anderen Taster, Aktoren mit Handbedienung, und auch eine zusätzliche Treppenhausautomatik in den Aktoren hinterlegt zu haben.

[EPIX]

Bitte...

kann jemand einmal ganz kurz beschreiben wie man das Ergebnis des bausteins "im Klartext" lesen kann?