Kapitel – 11
Sicherungen erstellen
Warum Sicherungen?
„ Vorbeugen ist immer besser als heilen “. Das Erstellen von Backups ist auch ein wichtiger Teil der Verhinderung von Datenkatastrophen, die uns helfen können, den Festplattencrash oder jede andere Art von Datenverlust zu überwinden. In diesem Kapitel werden wir besprechen, wie wir die Daten auch nach einigen schwerwiegenden Festplattencrashs wiederherstellen können, nur mit Hilfe von zuvor erstellten Backups.
Die Wiederherstellung durch die zuvor gespeicherten Sicherungen erfolgt fast immer zu 100 Prozent, jedoch können die verschiedenen Arten von Festplattencrashs in einigen besonderen Fällen zu Abweichungen in den Wiederherstellungsergebnissen führen.
Die Wiederherstellung von Daten mit Hilfe von Backups ist recht einfach, schnell und zuverlässig und kann die besten Ergebnisse liefern, während die Datenwiederherstellung ohne Backups ein schwieriger, komplizierter Prozess ist, der viel Zeit in Anspruch nehmen kann, und selbst dann haben wir Angst, dies nicht zu erreichen 100-Prozent-Daten in mehreren Fällen.
Wann und was gesichert werden soll
Es gibt verschiedene Bereiche auf der Festplatte, die einmal oder in unterschiedlichen Zeitabständen gesichert werden sollten. Die folgende Tabelle gibt einen Überblick über vollständige Backup-Maßnahmen und hilft herauszufinden, wann und was gesichert werden muss:
| What to Backup |
When to be Backed up |
| Backup of MBR |
Once after FDISK. The MBR is Created By the FDISK command of DOS. You can take backup of MBR After FDISK, however even after the FORMAT of partitions created by FDISK, The MBR remains Unchanged. |
| Backup of DBR |
Back up the DBRs for each logical drive once, after FORMAT. |
| Backup of FAT and Directory entries. |
FAT and Directory Entries are changed every time when you create of delete files or directories. Therefore it is recommended that you should take backup daily. |
| Backup of User Data |
Should be taken regularly. This type of backup causes the disk imaging to take place. However it is time taking yet most of the companies which have very sensitive data in their disks like to spend their time on disk imaging because by doing this they can backup all of the information described above. |
Außerdem sollten Sie eine Notfall-Bootdiskette für das System erstellen. Wenn es mit den Daten auf Ihrer Festplatte zu einer Katastrophe kommt, können Sie Ihr System mit Hilfe dieser Diskette booten und die Festplatte auf Fehler analysieren.
Sicherung des MBR (Master Boot Record) und dessen Verwendung
Der Master Boot Record (MBR) oder manchmal auch als Master Partition Table (MPT) bezeichnet, enthält ein kleines Programm zum Laden und Starten der aktiven (oder bootfähigen) Partition von der Festplatte. Der Master Boot Record enthält Informationen zu allen vier primären Partitionen.
Eine ausführliche Studie über MBR finden Sie im Kapitel, “Logischer Ansatz für Festplatten und Betriebssystem”, An früherer Stelle in diesem Buch besprochen.
Der MBR befindet sich bei Absolute Sector 0 oder wir können sagen bei Zylinder 0, Kopf 0 und Sektor1. Es wird auf der Festplatte erstellt, indem der Befehl FDISK.EXE von DOS ausgeführt wird.
Warum Sicherungs-MBR:
MBR ermöglicht es dem Bootsektor der aktiven Partition, die Kontrolle zu übernehmen, wenn das System gestartet wird.
Nach dem Power-On Self Test (POST) lädt das BIOS den MBR (Master Boot Record) von der Festplatte in den Speicher und führt ihn dann aus. Zuerst überprüft der MBR die Festplatte auf eine aktive Partition, dann lädt er den DOS Boot Record (DBR) in den Speicher und übergibt die Kontrolle an den Boot-Code des Betriebssystems, und dann lädt der Boot-Record-Code des Betriebssystems den Rest des Betriebssystems hinein Erinnerung.
Daher können wir sagen, dass, wenn der MBR der Festplatte beschädigt ist, die Festplatte fast tot ist und das System nicht mehr booten oder das Betriebssystem ausführen kann. In einem solchen Zustand werden alle auf der Festplatte gespeicherten Daten unzugänglich. Allgemein Die Fehlermeldungen werden wie folgt angezeigt:
“Ungültige Partitionstabelle” “Fehler beim Laden des Betriebssystems” “Fehlendes Betriebssystem"
Was kann mit der MBR-Sicherung wiederhergestellt werden?
Die Sicherung des MBR kann Ihnen helfen, die oben genannten Fehlermeldungen zu beseitigen. Mit dem Backup können folgende Probleme behoben werden:
- Fehler beim Laden des Betriebssystems aufgrund eines beschädigten IPL (Initial Program Loader).
- Verlorene primäre Partition(en).
- Beschädigte Partitionsinformationen.
- Ungültige magische Zahl.
Schreiben des Programms zum Erstellen einer Sicherung des MBR:
/* Programm zum Backup des MBR */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo; /* Structure to Hold the
information of disk Parameters */
int result;
int count=0;
char filename[80]; /* Stores the File name given by
User */
static char dbuf[512]; /* Data Buffer of 512 Bytes */
FILE *fp;
dinfo.drive = 0x80; /* drive number for First Hard
Disk */
dinfo.head = 0; /* disk head number */
dinfo.track = 0; /* track number */
dinfo.sector = 1; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
printf("\n Enter The Filename and path to store the
Backup of MBR \n ");
gets(filename);
// Öffnen Sie die Datei zum Speichern der MBR-Sicherung \\
if((fp=fopen(filename,"wb"))==NULL)
{
printf("Could not Create File, Press any key to
Exit...");
getch();
exit(0);
}
printf("Attempting to read from Hard disk drive :\n");
//// Lesen Sie den angegebenen Festplattensektor \\\\
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Disk read from hard disk drive :
successful.\n");
/// Schreiben Sie 512 Bytes MBR in die Datei \\\\
while(count<512)
{
fprintf(fp,"%c",dbuf[count] & 0xff );
count++;
}
fclose(fp);
}
else
printf("Cannot read Hard Disk drive, status = 0x%02x\n", result);
return 0;
}
Bemerkungen zur Programmcodierung:
In der zuvor angegebenen Programmcodierung gehen wir im Wesentlichen Schritt für Schritt vor, um die folgenden Aufgaben auszuführen:
- dinfo zeigt auf die diskinfo_t-Struktur, die die Parameterinformationen enthält, die für die von der _bios_disk-Funktion ausgeführte Operation erforderlich sind.
- Da wir den ersten Sektor der Festplatte lesen möchten, ist die Position des Sektors wie folgt:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive. |
| dinfo.head = 0 |
It points to head number 0 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
>Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- Öffnen Sie einen Dateistream mit dem vom Benutzer angegebenen Dateinamen und Pfad, um die Sicherung des MBR mit genau 512 Bytes zu speichern. Dateiname und Pfad werden im Zeichenarray filename gespeichert.
- _bios_disk(_DISK_READ, &dinfo) liest den ersten Sektor der Festplatte (80H), angegeben durch dinfo.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für eine erfolgreiche Operation anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Programm zum Wiederherstellen des MBR aus der Sicherung:
Wenn der MBR irgendwie beschädigt ist, hilft das als nächstes angegebene Programm, den MBR wieder herzustellen.
Es sollte immer bedacht werden, dass die illegale oder unwissentliche Verwendung dieses Programms Ihre Dateninformationen auf der Festplatte zerstören und die gesamten Daten unzugänglich machen kann. Sie sollten sich sicher sein, was Sie tun werden. Andernfalls können Sie das Problem noch komplizierter machen.
Programm zum Wiederherstellen des MBR aus der Sicherung:
Die Codierung des Programms ist wie folgt:
/* Programm zum Wiederherstellen der MBR-Sicherung aus der Sicherungsdatei */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo;
int result;
int count=0;
char filename[80]; /* Stores the File name given
by User */
static char dbuf[512]; /* Data Buffer of 512 Bytes
*/
FILE *fp;
/* Rufen Sie die Benutzereingabe für den Pfad der MBR-Sicherungsdatei ab */
printf("\n Enter The Filename and path of Backup File of
MBR \n ");
gets(filename);
if((fp=fopen(filename,"rb"))==NULL)
{
printf("Could not open Backup File, Press any key
to Exit...");
getch();
exit(1);
}
/* MBR-Daten sollten aus genau 512 Bytes bestehen */
while(count<512)
{
fscanf(fp,"%c",&dbuf[count]);
count++;
}
fclose(fp);
printf("Attempting to Write to Hard disk drive :\n");
dinfo.drive = 0x80; /* drive number for First
Hard Disk */
dinfo.head = 0; /* disk head number */
dinfo.track = 0; /* track number */
dinfo.sector = 1; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
result = _bios_disk(_DISK_WRITE, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Restoring the Backup of MBR to The Disk
Sector: successful.\n");
}
else
printf("Cannot Write on Hard Disk drive, status =
0x%02x\n", result);
return 0;
}
Bemerkungen zur Programmcodierung:
In der oben angegebenen Programmcodierung gehen wir im Wesentlichen Schritt für Schritt vor, um die folgenden Aufgaben auszuführen:
- dinfo zeigt auf die diskinfo_t-Struktur, die die Parameterinformationen enthält, die für die von der _bios_disk-Funktion ausgeführte Operation erforderlich sind.
- Da wir auf den ersten Sektor der Festplatte schreiben möchten, ist die Position des Sektors wie folgt:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive. |
| dinfo.head = 0 |
It points to head number 0 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- Der vom Benutzer angegebene Dateiname und Pfad der MBR-Sicherung wird im Zeichenarray filename gespeichert. Es sollte beachtet werden, dass die MBR-Informationen aus genau 512 Bytes bestehen sollten.
- _bios_disk(_DISK_WRITE, &dinfo) schreibt die Daten auf den ersten Sektor der Festplatte (80H), spezifiziert durch diinfo.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für eine erfolgreiche Operation anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Sicherung von DBR (DOS Boot Record) und dessen Verwendung
Nach der Partitionstabelle ist der DOS Boot Record (DBR) oder manchmal auch DOS Boot Sector genannt, die zweitwichtigste Information auf Ihrer Festplatte.
Eine ausführliche Studie über DBR finden Sie im Kapitel, “Logischer Ansatz für Festplatten und Betriebssystem”, An früherer Stelle in diesem Buch besprochen.
Der erste logische Sektor jeder DOS-Partition enthält einen DOS Boot Record (DBR) oder DOS Boot Sector. Die Aufgabe des DBR besteht darin, das Betriebssystem von der Festplatte in den Hauptspeicher des Computers zu laden und dem geladenen Programm die Kontrolle über das System zu geben.
Der DOS Boot Record (DBR) für die erste Partition auf einer Festplatte befindet sich normalerweise im absoluten Sektor 63 (dem 64. Sektor auf dem Laufwerk) oder in CHS-Form können wir sagen: C–H–S = 0–1–1 für die meisten Laufwerke.
Diese Position kann jedoch je nach SPT (Sektoren pro Spur) des Laufwerks variieren. Beispielsweise befand sich auf einem alten 245-MB-Laufwerk mit nur 31 SPT der Boot Record im 32. Sektor (Absolute Sector 31).
Der DBR wird mit dem FORMAT-Befehl von DOS erstellt, nachdem die Partitionierung mit dem FDISK-Befehl durchgeführt wurde. Der Sektor, auf dem sich DBR befindet, wird für das DOS zum logischen Sektor 1 dieser bestimmten Partition. Die von DOS verwendete Sektornummer beginnt mit dem physischen Sektor, auf dem sich DBR befindet.
Der DBR enthält ein kleines Programm, das von dem ausführbaren Programm Master Boot Record (MBR) ausgeführt wird. Alle DOS-Partitionen enthalten den Programmcode zum Booten der Maschine, d. h. zum Laden des Betriebssystems, aber nur diese Partition erhält die Kontrolle durch den Master Boot Record, der als aktive Partition im Partitionstabelleneintrag angegeben ist.
Warum Backup-DBR:
Der DBR enthält einige wichtige Informationen über die Plattengeometrie. Diese Informationen befinden sich im ersten Sektor jeder Partition, wie zum Beispiel:
- Sprungcode + NOP
- OEM-Name und -Version
- Bytes pro Sektor
- Sektoren pro Cluster
- Reservierte Sektoren
- Anzahl der FAT-Kopien
- Maximale Root-Verzeichniseinträge (aber nicht verfügbar für FAT32)
- Anzahl der Sektoren in Partition kleiner als 32 MB (daher nicht verfügbar für FAT32)
- Media Descriptor (F8H für Festplatten)
- Sektoren pro FAT (in älteren FAT-Systemen und nicht verfügbar für FAT32)
- Sektoren pro Spur
- Anzahl der Köpfe
- Anzahl der versteckten Sektoren in der Partition
- Anzahl der Sektoren in der Partition
- Anzahl der Sektoren pro FAT
- FAT-Informationsdeskriptor-Flags
- Version des FAT32-Laufwerks
- Clusternummer des Beginns des Stammverzeichnisses
- Sektornummer des Dateisystem-Informationssektors
- Sektornummer des Backup-Bootsektors
- Reserviert
- Nummer des logischen Laufwerks der Partition
- Erweiterte Signatur (29H)
- Seriennummer der Partition
- Volume-Name der Partition
- FAT-Name
- Ausführbarer Code
- Ausführbarer Marker oder magische Zahl (AAH 55H)
Im Allgemeinen werden die folgenden Fehlermeldungen auf dem Bildschirm angezeigt:
“Fehler beim Booten der Festplatte”
“Nicht-Systemdiskette oder Festplattenfehler”
“Ungültiger Systemdatenträger oder Datenträger-E/A-Fehler”
“Tauschen Sie die Diskette aus und drücken Sie dann eine beliebige Taste…”
Was kann mit dem Backup von DBR wiederhergestellt werden?
Die Sicherung von DBR kann Ihnen helfen, die oben genannten Fehlermeldungen loszuwerden. Diese Fehlermeldungen auf dem Bildschirm warten darauf, dass der Benutzer eine bootfähige Diskette mit den oben genannten Programmen in das Diskettenlaufwerk einlegt und eine Taste drückt.
Das Laufwerk sollte zugänglich sein, wenn Sie das System von der bootfähigen Diskette oder CD booten. Die Festplatte ist zwar nicht bootfähig, aber im Allgemeinen sollte dies den Zugriff auf die Daten des Laufwerks nicht beeinträchtigen. Nach dem Booten des Systems mit der bootfähigen Diskette können Sie auf die Daten zugreifen.
Durch Wiederherstellen der Sicherung von DBR können Sie die oben erwähnten Probleme überwinden.
Programme zum Erstellen und Wiederherstellen von Backups von DBR:
Die Programme zum Erstellen von Backups von DBRs und zum Wiederherstellen sind den Programmen zum Sichern und Wiederherstellen von MBRs fast ähnlich.
Wenn Sie beispielsweise Programme schreiben, um eine Sicherung des DBR des ersten logischen Laufwerks der Festplatte zu erstellen und ihn wiederherzustellen, werden die von der dinfo-Struktur angegebenen Parameter wie folgt geändert:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive> |
| dinfo.head = 1 |
It points to head number 1 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
Hier sehen wir, dass nur die Position des zu lesenden/schreibenden Sektors geändert wird. Hier wird C-H-S als 0-1-1 angegeben, da hier der DBR des ersten logischen Laufwerks gespeichert wird.
Vollständiges Disk-Imaging
Diese Art der Datensicherung wird heutzutage immer beliebter und wird am meisten von solchen Organisationen bevorzugt, die sehr sensible Daten in ihren Systemen haben. Sie können nicht einmal ein Prozent des Datenverlusts riskieren.
Solche Organisationen erstellen ihre Backups regelmäßig als vollständiges Disk-Image. Es dauert zwar einige Zeit, gibt Ihnen aber die Gewissheit, dass Sie nichts verpassen werden. Aufgrund ihrer zunehmenden Popularität haben Programmierer ihr Bestes gegeben, um die Disk-Imaging-Software immer schneller zu machen, um die Zeitdauer des Imaging-Prozesses zu minimieren.
Disk-Imaging ist eine gute Idee, denn nur wenn Sie einige zehn Minuten damit verbringen, können Sie sich darauf verlassen, dass Sie ein Backup von allem in Ihrer Tasche haben. Alle Faktoren wie MBR, BDR, FATs, Stammverzeichnisse werden unverändert auf die Zielfestplatte kopiert.
Was wir für Disk-Imaging brauchen, ist eine identische (oder fast identische) Zielfestplatte mit unserer Quellfestplatte, auf der wir unsere wertvollen Daten haben. Dabei ist immer zu beachten, dass die Zielfestplatte nicht kleiner als die Quellfestplatte sein sollte.
Wenn Sie nach dem Erstellen des vollständigen Images das System mit der Zielfestplatte booten, auf der Sie das Festplattenimage erstellt haben, erhalten Sie im Allgemeinen alle Daten so, wie sie sind.
Schreiben des Programms für vollständiges Disk-Imaging
Als nächstes wurde das Programm für Disk-Imaging angegeben. Das Programm verwendet die INT 13H-Erweiterungen, daher kann es auch große Festplatten unterstützen.
Das Programm erstellt das Image der ersten physischen Festplatte (0x80) auf der zweiten physischen Festplatte (0x81). Bevor Sie das Backup-Image erstellen, sollten Sie daher bedenken, dass alle Daten auf der Zielfestplatte (0x81) überschrieben werden die Daten der Quellfestplatte (0x80) im Sektor-für-Sektor-Muster.
Die Codierung des Programms wurde als nächstes angegeben:
/* Programm zum Erstellen des Images der ersten Festplatte (0x80) auf der zweiten Festplatte (0x81) */
#include<stdio.h>
#include<dos.h>
#include<conio.h>
/* Von der getdrivegeometry-Funktion zu verwendende Struktur unter Verwendung von INT 13H-Erweiterung, Funktionsnummer 0x48. */
struct geometry
{
unsigned int size ; /* (call) size of Buffer */
unsigned int flags ; /* Information Flags */
unsigned long cyl ; /* Number of Physical
Cylinders on Drive */
unsigned long heads ;/* Number of Physical
Heads on Drive */
unsigned long spt ; /* Number of Physical
Sectors Per Track */
unsigned long sectors[2] ; /* Total Number of
Sectors on Drive */
unsigned int bps ; /* Bytes Per Sector */
} ;
/* Struktur des Plattenadresspaketformats, das von den Funktionen readabsolutesectors und writeabsolutesectors verwendet werden soll */
struct diskaddrpacket
{
char packetsize ; /* Size of Packet, generally 10H */
char reserved ; /* Reserved (0) */
int blockcount ; /* Number of Blocks to Transfer */
char far *bufferaddress ; /* address to Transfer
Buffer */
unsigned long blocknumber[2] ; /* Starting Absolute
Block Number */
} ;
///// Funktion zum Abrufen von Antriebsparametern \\\\\
unsigned long getdrivegeometry (int drive)
{
union REGS i, o ;
struct SREGS s ;
struct geometry g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
i.h.ah = 0x48 ; /* Function Number 0x48 of INT 13H
Extensions See the Comments
Below */
i.h.dl = drive; /* Drive Number */
i.x.si = FP_OFF ( (void far*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Rufen Sie die angegebene Funktionsnummer der INT 13H-Erweiterung mit Segmentregisterwerten auf */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n", g.heads, g.spt, g.cyl);
/* Wenn die Funktion zum Abrufen der Antriebsgeometrie fehlschlägt, Fehlermeldung anzeigen und beenden */
if(g.spt==0)
{
printf("\n Get Drive Geometry Function Fails....");
printf("\n Extensions Not Supported, Press any Key to
Exit...");
getch();
exit(1);
}
return *g.sectors; /* Return The Number of Sectors
on Drive */
}
////// Beginn des Mains \\\\\\
void main()
{
unsigned long loop=0, Sectors_in_HDD1=0, Sectors_in_HDD2=0;
unsigned char buffer[61440]; /* Data buffer of 61440
Bytes to Read/Write 120 Sectors of 512 Bytes at a time to save time. */
char choice;
clrscr();
/* Wenn Gesamtnr. der angeschlossenen Festplatten ist weniger als zwei. Fehlermeldung anzeigen und beenden. */
if(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n You Must Have At least Two Hard Disks
Attached to your Computer To Run This");
printf("\n Program. Press any Key to Exit... ");
getch();
exit(1);
}
/// Parameter der ersten Festplatte abrufen (0x80) \\\
Sectors_in_HDD1 = getdrivegeometry (0x80);
printf(" Total Sectors in First Hard Disk = %lu\n\n",
Sectors_in_HDD1);
/// Parameter der zweiten Hsrd-Festplatte abrufen (0x81) \\\
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk = %lu\n\n",
Sectors_in_HDD2);
/// Erst bestätigen, dann fortfahren \\\
printf("\n All The Data in Second Hard Disk will be
lost !!!");
printf("\n Press \'Y\' to Continue, Else any key to
Exit... ");
choice = getche();
switch(choice)
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
/* Das Ziel sollte nicht kleiner als die Quelle sein */
if(Sectors_in_HDD2<Sectors_in_HDD1)
{
printf("\n\n Destination Disk should not be Smaller
than Source Disk");
printf("\n Press any Key to Exit...");
getch();
exit(0);
}
/* Wenn alles in Ordnung ist, kopieren Sie alle Sektoren der Quellfestplatte auf die Zielfestplatte */
gotoxy(10,15);printf("Copying Absolute Sector: ");
for(loop=0;loop< =Sectors_in_HDD1;loop=loop+120)
{
readabsolutesectors ( 0x80, loop, 120, buffer );
writeabsolutesectors ( 0x81, loop, 120, buffer );
gotoxy(36,15); printf("%ld",loop);
if(kbhit())
{
exit(0);
}
}
//// Zeigen Sie die Abschlussmeldung an \\\
printf("\n\n Disk Imaging is Now Completed, Press any Key
To Exit...");
getch();
}
//// Ende der Hauptsache
Kommentare zur Codierung:
Bei der Codierung des zuvor angegebenen Programms für das Disk-Imaging gehen wir vor, indem wir die folgenden Aufgaben ausführen:
- Die Struktur, Geometrie wird von der getdrivegeometry-Funktion unter Verwendung der INT 13H-Erweiterung, Funktionsnummer 0x48 verwendet. Eine ausführliche Beschreibung der INT 13H-Erweiterungen finden Sie im Kapitel „Umgang mit großen Festplatten“, das weiter vorne in diesem Buch besprochen wurde.
Die Datentypen, die mehrere Parameter der Festplatte darstellen, haben die folgenden Bedeutungen:
| Data Type |
Size in Bytes |
Description |
| unsigned int size |
2 Bytes |
Size of Buffer |
| unsigned int flags |
2 Bytes |
Information Flags |
| unsigned long cyl |
4 Bytes |
Number of Physical Cylinders on Drive |
| unsigned long heads |
4 Bytes |
Number of Physical Heads on Drive |
| unsigned long spt |
4 Bytes |
Number of Physical Sectors Per Track |
| unsigned long sectors[2] |
8 Bytes |
Total Number of Sectors on Drive |
| unsigned int bps |
2 Bytes |
Bytes Per Sector |
- Die Struktur diskaddrpacket wird von den Funktionen readabsolutesectors und writeabsolutesectors verwendet. Das Format des Plattenadressenpakets ist in der folgenden Tabelle angegeben:
| Data Type |
Size in Bytes |
Description |
| char packetsize |
1 Byte |
Size of Packet, generally 10H |
| char reserved |
1 Byte |
Reserved (0) |
| int blockcount |
2 Bytes |
Number of Blocks to Transfer |
| char far *bufferaddress |
4 Bytes |
address to Transfer Buffer |
| unsigned long blocknumber[2] |
4 Bytes |
Starting Absolute Block Number |
- Die Funktion getdrivegeometry wird verwendet, um die Parameter des angegebenen Laufwerks abzurufen. Die Funktion getdrivegeometry verwendet die Funktionsnummer 0x48 von INT 13H Extensions.
Die Bedeutung der Parameter ist in der folgenden Tabelle beschrieben:
| Parameter |
What it means |
| i.h.ah = 0x48 |
Function Number 0x48 of INT 13H Extensions |
| i.h.dl = drive |
Drive Number |
| i.x.si = FP_OFF ( (void far*)&g ) |
ds:si address to buffer for drive parameters as discussed earlier |
| s.ds = FP_SEG ( (void far*)&g ) |
ds:si address to buffer for drive parameters as discussed earlier |
Die Funktion int86x(0x13, &i, &o, &s) ruft den Interrupt 13H mit Segmentregisterwerten auf. Die Funktion getdrivegeometry gibt die Gesamtzahl auf dem Laufwerk zurück.
- In der Funktion main() (char)peekb(0x0040, 0x0075); (die Funktion peekb ist in DOS.H definiert) gibt die Anzahl der an das System angeschlossenen Festplatten zurück.
Die Anzahl der an das System angeschlossenen Festplatten wird durch das auf Speicherplatz 0040H:0075H (Segment 0040H: Offset 0075H) gespeicherte Byte dargestellt. Wenn die Anzahl der an das System angeschlossenen Festplatten geringer ist, zeigt das Programm zwei die Fehlermeldung und wird beendet.
Sectors_in_HDD1 = getdrivegeometry (0x80); Ruft die Parameter der ersten Festplatte (0x80) ab und gibt die Gesamtzahl der Sektoren auf der ersten Festplatte zurück.
Ähnlich Sectors_in_HDD2 = getdrivegeometry (0x81); Ruft die Parameter der zweiten Festplatte (0x81) ab und gibt die Gesamtzahl der Sektoren auf der zweiten Festplatte zurück.
Überprüfen Sie nach der Bestätigung durch den Benutzer, mit dem Imaging fortzufahren, zunächst die Bedingung, dass die Größe der Quellfestplatte nicht größer sein sollte als die Größe der Zielfestplatte. Wenn das Ziel kleiner ist, Fehlermeldung anzeigen und beenden.
Wenn alles richtig läuft, kopieren Sie die Sektoren der Quellfestplatte auf die Zielfestplatte. Hier lesen und schreiben wir 61440 Bytes (120 Sektoren mit jeweils 512 Bytes) gleichzeitig, um den Imaging-Prozess zu beschleunigen.
Wenn Sie mehr Sektoren gleichzeitig verwenden möchten, sogar über die Grenze von 64 KB hinaus, können Sie dies tun, indem Sie „Huge Pointer” im großen Speichermodell. Das Beispiel der Spezifikation ist wie folgt:
char riesiges Array [100000L];
- Die Funktion readabsolutesectors ( 0x80, loop, 120, buffer ); liest die 120 Sektoren der ersten Festplatte (0x80), beginnend mit der durch unsigned long integer loop spezifizierten Sektornummer und speichert die Daten im Datenpuffer.
- Die Funktion, writeabsolutesectors ( 0x81, loop, 120, buffer ); schreibt die Daten des Datenpuffers in 120 Sektoren der zweiten Festplatte (0x81), beginnend mit der Sektornummer, die durch die vorzeichenlose lange Ganzzahlschleife angegeben ist.
Die Kodierung der Funktionen readabsolutesectors ( ) and writeabsolutesectors ( ) have been given next:
//// Funktion zum Lesen absoluter Sektoren \\\\
int readabsolutesectors ( int drive,
unsigned long sectornumber,
int numofsectors,
void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* packet size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ; /* Number of sectors
to read */
/* für Datenpuffer */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void
far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Sector number
to read */
pp.blocknumber[1] = 0 ; /* Block number */
i.h.ah = 0x42 ; /* Function Number*/
i.h.dl = drive ; /* Physical Drive Number */
i.x.si = FP_OFF ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
/* Rufen Sie die angegebene Funktion von INT 13H mit Segmentregisterwerten auf */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /*failure */
else
return 1 ; /* success */
}
//// Funktion zum Schreiben absoluter Sektoren \\\\
int writeabsolutesectors ( int drive,
unsigned long sectornumber,
int numofsectors,
void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* Packet Size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ; /* Number of Sectors
to be written */
/* für Datenpuffer */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void
far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ;/* Sector number
to be written */
pp.blocknumber[1] = 0 ; /* Block number = 0 */
i.h.ah = 0x43 ; /* Function Number */
i.h.al = 0x00 ; /* Write Flags, see
comments */
i.h.dl = drive ; /* Physical Drive number*/
/* ds:si for buffer Parameters */
i.x.si = FP_OFF ( (void far*)&pp ) ;
/* ds:si for buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ;
/* Rufen Sie die angegebene Funktion von INT 13H mit Segmentregisterwerten auf */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /* failure */
else
return 1 ; /* success */
}
Kommentare zur Codierung:
Die von beiden Funktionen verwendeten Parameter haben folgende Bedeutung:
| Parameter |
Size in Bytes |
Description |
| pp.packetsize = 16 ; |
1 Byte |
Size of packet = 10H |
| pp.reserved = 0 ; |
1 Byte |
Reserved = 0 |
| pp.blockcount = numofsectors ; |
2 Bytes |
Number of sectors to read |
| pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer)); |
----- |
for Data buffer or Transfer Buffer |
| pp.blocknumber[0] = sectornumber ; |
4 Bytes |
Sector number to read/write (generally, we need only this). Only alone This can support up to 2.1 Terabytes. |
| pp.blocknumber[1] = 0 ; |
4 Bytes |
Block number. Use this, If accessing the disk of greater then 2.1 Terabytes in size. |
| i.h.ah = 0x42 ; or i.h.ah = 0x43 ; |
2 Bytes |
Function Number of INT 13H Extensions |
| i.h.al = 0x00 ; |
1 Byte |
Write Flags used in write function only,00H, 01H are used for Write Without Verify and 02H is used for write with verify |
| i.h.dl = drive ; |
2 Bytes |
Physical Drive Number |
| i.x.si = FP_OFF ( (void far*)&pp ) ; |
------ |
ds:si for buffer Parameters |
| s.ds = FP_SEG ( (void far*)&pp ) ; |
------ |
ds:si for buffer Parameters |
| int86x ( 0x13, &i, &o, &s ) ; |
------ |
Invoke the specified Function of INT 13H with segment register values |
Seite Geändert am: 08/03/2022
Zuhause