Kapitel – 10
Datenwiederherstellung von beschädigter Diskette
Datenwiederherstellung von beschädigter Diskette
Die Diskette ist eine der unzuverlässigsten Quellen für die Datenspeicherung. Wenn Sie zu einer Organisation gehen, die Computersysteme verwendet, und ihre Mitarbeiter nach den Problemen fragen, die durch Disketten verursacht werden, werden Sie sehr häufig das Problem hören, dass der Mitarbeiter der Organisation einige wichtige Daten auf seiner Diskette hatte und die Diskette jetzt nicht mehr vom Computer lesbar und eine Nachricht wird angezeigt, etwa
“Kann die Festplatte nicht lesen”
“Spur 0 Schlecht”
“Ungültiges Laufwerk oder Kapazität”
“Der Datenträger ist nicht formatiert. Willst du es jetzt formatieren?”
Dies ist das alltägliche Problem für Organisationen, die Computersysteme und Disketten verwenden. Das Problem wird kritisch, wenn Sie feststellen, dass für die Daten, die auf der beschädigten Diskette verloren zu sein scheinen, keine Sicherung erstellt oder verfügbar war.
Das größte Problem soll auftreten, wenn Sie eine Sicherungskopie Ihrer kritischen Informationen auf der Diskette erstellen, Disketten des Antivirenprogramms retten, um den Virenangriff zu überwinden, oder Aufzeichnungen oder andere Sicherungen (es kann eine Reihe von Möglichkeiten geben) auf einer Diskette und Wenn Sie die Sicherung von der Diskette wiederverwenden möchten, gibt es einen Lesefehler.
In einem solchen Zustand sind Sie im Begriff, Ihre wichtigen Informationen und Daten zu verlieren, oder in einigen Fällen sogar, wenn Sie den Mangel an Backups und Wiederherstellungsprogrammen für Ihre Computerstartinformationen und Rettungsprogrammen für Virenangriffe spüren. strong> usw., können Sie einen großen Datenverlust in Form eines Betriebssystemabsturzes erleiden, der aufgrund des Mangels an Informationen auf der Diskette gespeichert ist, die jetzt vom Computer nicht lesbar sind.
In solchen Fällen wird es zur wichtigsten Anforderung, die Daten wiederherzustellen von der Diskette, die von Ihrem Computersystem als fehlerhaft deklariert wurde.
Warum die Diskette nicht lesbar ist
Das häufigste Problem, das dazu führt, dass eine Diskette solche Fehlermeldungen anzeigt, ist die Beschädigung des DOS-Startdatensatzes (DBR) der Diskette, wodurch der Computer die logische Identifizierung der Diskette erkennen kann.
Der DBR ist ein kleines Programm, das in Spur 0, Kopf 0 und Sektor 1 gespeichert ist und wichtige Informationen über die Diskette enthält, wie zum Beispiel:
- Anzahl Bytes pro Sektor
- Sektor pro Cluster
- Anzahl der FATs
- Maximale Anzahl Root-Verzeichnisse etc.
Da Floppy kein logisches Partitionssystem hat, ist daher kein MBR in Floppy verfügbar. Der erste Sektor von Floppy enthält den DBR. Dies ist auch ein Hauptunterschied, um die logische Struktur einer Festplatte mit einer Diskette zu vergleichen.
Wenn wir die Bootsektorinformationen einer Diskette mit Hilfe eines beliebigen Diskbearbeitungsprogramms lesen, werden Informationen wie in der folgenden Abbildung angezeigt.
Die folgende Abbildung zeigt die 512 Bytes Information des DBR eines 1.44MB, 3½ Zoll Diskette.
Wenn diese Informationen auf irgendeine Weise beschädigt oder unlesbar werden, verursacht die Diskette solche Lesefehlermeldungen. Dies kann auf eine physische oder logische Beschädigung des ersten Sektors der Festplatte zurückzuführen sein.
Die logische Beschädigung schließt die Fälle ein, in denen die Information des ersten Sektors der Diskette geändert wird, ein logisch fehlerhafter Sektor oder der DBR auftritt die Diskette ist aus irgendeinem anderen Grund beschädigt.
Die Physical Corruption soll stattfinden, wenn Physical Bad Sectors (dh Sektor 1 ist physisch beschädigt) auf dem ersten Sektor der Diskette vorhanden sind. Das Problem wird ernster, wenn Sie feststellen, dass die Diskette mehr als einen fehlerhaften Sektor in Spur 0 hat.
Wie man sich erholt
Da wir beide Ursachen der Korruption kennengelernt haben, hoffe ich, dass Sie das Problem jetzt verstehen können. Es ist nicht sehr schwierig, Daten nach logischer Beschädigung wiederherzustellen, aber die Wiederherstellung nach physischer Beschädigung erfordert etwas mehr Aufwand.
Method – 1
Speichern Sie das Boot-Image jeder neuen Diskette
Wenn das Problem logisch ist, verstehen wir jetzt, wie wir die Daten wiederherstellen können. Was wir tun müssen, ist nur, den entsprechenden Boot-Datensatz von einer anderen Diskette mit derselben Größe und Kapazität zu erhalten und ihn in den ersten Sektor der nicht lesbaren Diskette einzufügen. Obwohl das Problem durch den schlechten Startdatensatz verursacht wurde, sollte es jetzt funktionieren.
Dieses Verfahren umfasst zwei Schritte, mit denen wir unsere Daten von einer nicht lesbaren Diskette wiederherstellen:
- Das Image des DOS Boot Record einer guten Diskette erstellen
- Einfügen des Boot-Images in den ersten Sektor einer nicht lesbaren Diskette
Das Image des DOS Boot Record einer guten Diskette erstellen
Um das Image des Boot-Records einer neuen Diskette zu speichern, muss das Programm die folgenden drei Aufgaben ausführen:
- Lesen Sie genau die ersten 512 Bytes der guten Diskette
- Überprüfen Sie den erfolgreichen Lesevorgang (am wichtigsten)
- Speichern Sie diese 512 Byte unter dem angegebenen Dateinamen und Zielpfad
Der Sektor der Diskette ist 512 Byte groß und es ist notwendig, das exakte Bild des Sektors zu kopieren. Es ist der wichtigste und notwendige Schritt bei jeder Art von Operationen, die auf Diskette angewendet werden, um zu überprüfen, ob die Operation erfolgreich war oder nicht.
Auch bei einer guten und frischen Diskette kann es zu Initialisierungsproblemen kommen. Deshalb wird in den meisten Fällen, wenn die Operation auf Disketten durchgeführt wird, zuerst die Initialisierung von Disketten in der Programmierung mit der Diskettenoperation zurücksetzen (Funktion 00 H von INT 13H) durchgeführt.
Wenn auch nach der Initialisierung die neu eingelegte Diskette oder die geänderte Diskette einen Lesefehler verursacht, wird Ihnen empfohlen, das Programm erneut auszuführen, höchstwahrscheinlich funktioniert es dieses Mal.
Das folgende Programm soll diese spezifizierten Aufgaben ausführen. Mal sehen, wie es weitergeht:
/* Speichern Sie das Boot-Image in einer Datei von einer frischen Diskette */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo;
union REGS regs;
int result;
int count=0, i;
char fname[80];
static char dbuf[512];
FILE *fp;
dinfo.drive = 0x00; /* drive number for A: */
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 */
clrscr();
gotoxy(10,3);cprintf("Enter The File Name And Path To
Store Boot Image");
gotoxy(5,5);
gets(fname);
fp=fopen(fname,"wb");
if((fp=fopen(fname,"wb"))==NULL)
{
highvideo();
gotoxy(10,10);cprintf("File Could Not Be created");
getch();
exit(0);
}
gotoxy(10,9);
cprintf("Attempting to read from Floppy disk drive :\n");
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
while(count<512)
{
fprintf(fp,"%c",dbuf[count] & 0xff );
count++;
}
fclose(fp);
gotoxy(10,14);cprintf("Disk read from Floppy disk drive
: successful.\n");
}
else
{
gotoxy(10,14);
cprintf("Cannot read drive A, status = 0x%02x\n", result);
switch(result)
{
case 0x00:
cprintf("\n\n STATUS: No Error!!");
break;
case 0x01:
cprintf("\n\n STATUS: Bad command");
break;
case 0x02:
cprintf("\n\n STATUS: Address mark not found");
break;
case 0x03:
cprintf("\n\n STATUS: Attempt to write to write-protected disk");
break;
case 0x04:
cprintf("\n\n STATUS: Sector not found");
break;
case 0x06:
cprintf("\n\n STATUS: Disk changed since last operation");
break;
case 0x08:
cprintf("\n\n STATUS: Direct memory access (DMA) overrun");
break;
case 0x09:
cprintf("\n\n STATUS: Attempt to perform DMA across 64K boundary");
break;
case 0x0C:
cprintf("\n\n STATUS: Media type not found");
break;
case 0x10:
cprintf("\n\n STATUS: Bad CRC/ECC on disk read");
break;
case 0x20:
cprintf("\n\n STATUS: Controller has failed");
break;
case 0x31:
cprintf("\n\n STATUS: No media in drive (IBM/MS INT 13H extensions)");
break;
case 0x32:
cprintf("\n\n STATUS: Incorrect drive type stored in CMOS (Compaq)");
break;
case 0x40:
cprintf("\n\n STATUS: Seek operation failed");
break;
case 0x80:
cprintf("\n\n STATUS: Attachment failed to respond(Disk Timed-out)");
break;
case 0xB0:
cprintf("\n\n STATUS: Volume not locked in drive (INT 13H extensions)");
break;
case 0xB1:
cprintf("\n\n STATUS: Volume locked in drive (INT 13H extensions)");
break;
case 0xB2:
cprintf("\n\n STATUS: Volume not removable (INT 13H extensions)");
break;
case 0xB3:
cprintf("\n\n STATUS: Volume in use (INT 13H extensions)");
break;
case 0xB4:
cprintf("\n\n STATUS: Lock count exceeded (INT 13H extensions)");
break;
case 0xB5:
cprintf("\n\n STATUS: Valid eject request failed (INT 13H extensions)");
break;
default: cprintf("\n\n STATUS: UNKNOWN Status CODE For Floppy Errors");
}
}
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 = 0x00 |
It indicates the drive 0 that is floppy disk drive (a:) |
| 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 Boot-Image-Informationen von genau 512 Byte zu speichern. Dateiname und Pfad werden im Zeichenarray fname gespeichert.
- Initialisieren Sie das Plattensystem mit dem Interrupt 13H (Funktion 00h), wobei regs.h.ah = 0x00 auf die Funktion 00 H zeigt und regs.h.dl = 0x00 für eine: Diskette verwendet wird. Und int86(0x13, ®s, ®s) ruft den MS-DOS-Interrupt-Service INT 13 H auf.
- _bios_disk(_DISK_READ, &dinfo) liest den angegebenen Sektor der Diskette.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für einen erfolgreichen Vorgang anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Einfügen des Boot-Images in den ersten Sektor einer nicht lesbaren Diskette
Um das Boot-Image aus der Datei in den ersten Sektor der nicht lesbaren Diskette einzufügen, müssen wir die folgenden drei Hauptaufgaben in unserem Programm ausführen:
- Liest die genauen 512 Bytes Informationen des Startdatensatzes einer neuen Diskette aus einer zuvor gespeicherten Datei.
- Schreiben Sie diese Informationen in den ersten Sektor der Diskette, der derzeit nicht lesbar ist.
- Überprüfen Sie den erfolgreichen Abschluss des Schreibvorgangs (am wichtigsten).
Da der Sektor der Diskette 512 Byte groß ist, muss das genaue Boot-Image in den Sektor eingefügt werden. Es ist der wichtigste und notwendige Schritt bei jeder Art von Operationen, die auf Diskette angewendet werden, um zu überprüfen, ob die Operation erfolgreich war oder nicht.
Während des Betriebs kann es zu Initialisierungsproblemen mit der Diskette kommen, deshalb müssen Sie die Diskette initialisieren, indem Sie das Diskettensystem zurücksetzen (mit Funktion 00H von INT 13H).
Wenn auch nach der Initialisierung die neu eingelegte Diskette oder die geänderte Diskette einen Lesefehler verursacht, wird Ihnen empfohlen, das Programm erneut auszuführen, höchstwahrscheinlich funktioniert es dieses Mal.
Das folgende Programm soll diese spezifizierten Aufgaben ausführen. Mal sehen, wie es weitergeht:
/* Boot-Image auf die nicht lesbare Diskette laden */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo;
union REGS regs;
int result;
int count=0, i;
char fname[80];
char dbuf[512];
FILE *fp;
clrscr();
gotoxy(5,3);cprintf("Enter The File Name And Path, In Which Boot image of Floppy Is Stored");
gotoxy(5,5);
gets(fname);
fp=fopen(fname,"rb");
if((fp=fopen(fname,"rb"))==NULL)
{
highvideo();
gotoxy(10,10);cprintf("File Could Not Be Opened");
getch();
exit(0);
}
gotoxy(10,9);
cprintf("Attempting to Recover Floppy disk drive :\n");
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
while(count<512)
{
fscanf(fp,"%c",&dbuf[count]);
count++;
}
dinfo.drive = 0x00; /* drive number for A: */
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)
{
fclose(fp);
gotoxy(10,14);cprintf("Successful!!! I Hope Floppy May
Work Now.\n");
}
else
{
gotoxy(10,14);
cprintf("Cannot read drive A, status = 0x%02x\n",result);
gotoxy(10,16);
switch(result)
{
case 0x00:
cprintf("\n\n STATUS: No Error!!");
break;
case 0x01:
cprintf("\n\n STATUS: Bad command");
break;
case 0x02:
cprintf("\n\n STATUS: Address mark not found");
break;
case 0x03:
cprintf("\n\n STATUS: Attempt to write to write-protected disk");
break;
case 0x04:
cprintf("\n\n STATUS: Sector not found");
break;
case 0x06:
cprintf("\n\n STATUS: Disk changed since last operation");
break;
case 0x08:
cprintf("\n\n STATUS: Direct memory access (DMA) overrun");
break;
case 0x09:
cprintf("\n\n STATUS: Attempt to perform DMA across 64K boundary");
break;
case 0x0C:
cprintf("\n\n STATUS: Media type not found");
break;
case 0x10:
cprintf("\n\n STATUS: Bad CRC/ECC on disk read");
break;
case 0x20:
cprintf("\n\n STATUS: Controller has failed");
break;
case 0x31:
cprintf("\n\n STATUS: No media in drive (IBM/MS INT 13H extensions)");
break;
case 0x32:
cprintf("\n\n STATUS: Incorrect drive type stored in CMOS (Compaq)");
break;
case 0x40:
cprintf("\n\n STATUS: Seek operation failed");
break;
case 0x80:
cprintf("\n\n STATUS: Attachment failed to respond(Disk Timed-out)");
break;
case 0xB0:
cprintf("\n\n STATUS: Volume not locked in drive (INT 13H extensions)");
break;
case 0xB1:
cprintf("\n\n STATUS: Volume locked in drive (INT 13H extensions)");
break;
case 0xB2:
cprintf("\n\n STATUS: Volume not removable (INT 13H extensions)");
break;
case 0xB3:
cprintf("\n\n STATUS: Volume in use (INT 13H extensions)");
break;
case 0xB4:
cprintf("\n\n STATUS: Lock count exceeded (INT 13H extensions)");
break;
case 0xB5:
cprintf("\n\n STATUS: Valid eject request failed (INT 13H extensions)");
break;
default: cprintf("\n\n STATUS: UNKNOWN Status CODE For Floppy Errors");
}
}
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 die Informationen auf den ersten Sektor der Festplatte schreiben werden, ist die Position des Sektors wie folgt:
- Öffnen Sie die Datei, in der die Boot-Image-Informationen von 512 Bytes einer neuen Diskette vom vorherigen Programm gespeichert wurden. Dateiname und Pfad werden im Zeichenarray fname gespeichert.
- Initialisieren Sie das Plattensystem mit dem Interrupt 13H (Funktion 00h), wobei regs.h.ah = 0x00 auf die Funktion 00 H zeigt und regs.h.dl = 0x00 für eine: Diskette verwendet wird. Und int86(0x13, ®s, ®s) ruft den MS-DOS-Interrupt-Service INT 13 H auf.
- _bios_disk(_DISK_WRITE, &dinfo) schreibt die Startinformationen aus der angegebenen Datei in den ersten (angegebenen) Sektor der Diskette.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für einen erfolgreichen Vorgang anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
| Parameter |
What it means |
| dinfo.drive = 0x00 |
It indicates the drive 0 that is floppy disk drive (a:) |
| 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 write operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
Lassen Sie es uns mit einem einzigen Programm tun
Ich hoffe, Sie haben jetzt das Konzept hinter einer solchen Art der Datenwiederherstellung von der Diskette verstanden. Stellen wir uns danach ein einzelnes Programm vor, das die gleichen Ergebnisse liefert, die wir mit Hilfe der zuvor besprochenen zwei Programme erhalten haben.
Wir haben die folgenden Aufgaben mit den kürzlich besprochenen Programmen erledigt:
- Speichern Sie die Startinformationen von einer guten Diskette in einer Datei
- Fügen Sie diese Informationen in den ersten Sektor der derzeit nicht lesbaren Diskette ein. Die Datei, die wir zum Speichern des Boot-Images verwendet haben, fungierte als Zwischenbrücke, um die Operationen beider Programme zu verbinden. Aber wenn wir diese Boot-Informationen in unserer Programmcodierung selbst definieren, brauchen wir keine Datei zu erstellen und wir brauchen auch nicht die Boot-Informationen der Diskette aus der Datei zu lesen.
In unserem nächsten Programm teilen wir unserem Programm mit, was es in den ersten Sektor der nicht lesbaren Diskette schreiben soll, und können so vermeiden, dass zwei verschiedene Programme dieselbe Aufgabe ausführen, und wir können unsere Daten wiederherstellen. strong> wie bisher aus dem neuen Single-Programm.
Dadurch wird das Programm mit weniger Codierung einfach und wir können die Wahrscheinlichkeit des Auftretens von Fehlern beim Lesen, Schreiben oder Erstellen von Dateien verringern. Wir erledigen die folgenden vier wichtigen Aufgaben in diesem Programm:
Glauben Sie nicht, dass das Programm schwer zu schreiben und zu verstehen ist, wenn Sie sich die 512 Byte hexadezimaler Informationen von dbuf[512] ansehen. Später werden wir die einfache Art des Schreibens besprechen diese Informationen für Ihre Programmcodierung.
- Definieren Sie die DOS-Boot-Record-Informationen im Hexadezimalsystem, die in den ersten Sektor einer derzeit nicht lesbaren Diskette geschrieben werden sollen.
- Setzen Sie das Plattensystem zurück, um die Diskette zu initialisieren (INT 13H, Funktion 00H).
- Schreiben Sie den DOS Boot Record in den ersten Sektor der Diskette
- Überprüfen Sie den erfolgreichen Abschluss des Vorgangs und Fehler, falls aufgetreten.
Lassen Sie uns das Programm untersuchen:
/* Einzelnes Programm zum Laden des Standard-Startabbilds auf eine nicht lesbare Diskette */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo;
union REGS regs:
int result, i;
/* Boot-Image, das in das Diskettenlaufwerk geladen werden soll */
static char dbuf[512]=
{
0xEB,0x3E,0x90,0x2B,0x29,0x6E, 0x70,0x32,0x49,0x48,0x43,0x0,0x2 ,0x1 ,0x1 ,0x0,
0x2,0xE0,0x0,0x40,0xB,0xF0,0x9,0x0,0x12, 0x0 ,0x2 ,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x29, 0x24,0x3B,0xDB, 0x16,0x4E, 0x4F, 0x20, 0x4E,0x41,0x4D,0x45,
0x20, 0x20, 0x20,0x20,0x46,0x41, 0x54,0x31, 0x32,0x20,0x20, 0x20,0xF1,0x7D, 0xFA,
0x33, 0xC9,0x8E,0xD1, 0xBC,0xFC,0x7B, 0x16,0x7 ,0xBD,0x78,0x0 ,0xC5,0x76,0x0,
0x1E,0x56,0x16,0x55, 0xBF,0x22,0x5 ,0x89,0x7E,0x0 ,0x89,0x4E,0x2 ,0xB1,0xB,0xFC,
0xF3,0xA4,0x6 ,0x1F,0xBD,0x0,0x7C ,0xC6,0x45,0xFE,0xF,0x8B, 0x46,0x18,0x88,0x45,
0xF9,0xFB,0x38,0x66, 0x24,0x7C,0x4,0xCD,0x13, 0x72,0x3C,0x8A,
0x46,0x10,0x98,0xF7,
0x66,0x16,0x3, 0x46,0x1C,0x13,0x56, 0x1E,0x3 ,0x46,0xE,0x13,
0xD1,0x50,0x52,0x89,
0x46,0xFC,0x89, 0x56,0xFE,0xB8,0x20,0x0, 0x8B,0x76,0x11,0xF7,
0xE6,0x8B,0x5E,0xB ,
0x3 ,0xC3,0x48,0xF7,0xF3,0x1,0x46,0xFC, 0x11,0x4E,0xFE,0x5A,
0x58,0xBB,0x0 ,0x7 ,
0x8B,0xFB,0xB1,0x1, 0xE8,0x94,0x0 ,0x72,0x47,0x38,0x2D,0x74, 0x19,0xB1,0xB,0x56,
0x8B,0x76,0x3E, 0xF3,0xA6,0x5E,0x74,0x4A,0x4E, 0x74,0xB,0x3 , 0xF9,0x83, 0xC7, 0x15,
0x3B, 0xFB,0x72,0xE5,0xEB,0xD7,0x2B, 0xC9,0xB8,0xD8, 0x7D, 0x87, 0x46, 0x3E,0x3C,
0xD8,0x75,0x99, 0xBE,0x80,0x7D,0xAC, 0x98,0x3,0xF0,0xAC,0x84 ,0xC0,0x74,0x17,0x3C,
0xFF,0x74,0x9 ,0xB4,0xE ,0xBB,0x7 ,0x0,0xCD,0x10,0xEB, 0xEE,0xBE,0x83,0x7D, 0xEB,
0xE5, 0xBE, 0x81,0x7D, 0xEB,0xE0, 0x33,0xC0,0xCD,0x16,0x5E,0x1F,0x8F,0x4 ,0x8F,0x44,
0x2,0xCD, 0x19,0xBE,0x82,0x7D,0x8B,0x7D,0xF, 0x83,0xFF,0x2,0 x72,0xC8, 0x8B,0xC7,0x48,
0x48,0x8A,0x4E,0xD,0xF7,0xE1,0x3 ,0x46,0xFC, 0x13,0x56,0xFE,0xBB,0x0 ,0x7 ,0x53,0xB1,0x4 ,
0xE8,0x16,0x0, 0x5B,0x72,0xC8, 0x81,0x3F,0x4D,0x5A, 0x75,0xA7,0x81,0xBF, 0x0,0x2 ,0x42,0x4A,
0x75,0x9F,0xEA,0x0 ,0x2 ,0x70,0x0,0x50,0x52, 0x51, 0x91, 0x92, 0x33, 0xD2,0xF7,0x76,0x18,0x91,
0xF7,0x76, 0x18,0x42, 0x87, 0xCA, 0xF7, 0x76,0x1A,0x8A,0xF2,0x8A,0x56, 0x24,0x8A,0xE8,
0xD0, 0xCC,0xD0,0xCC,0xA, 0xCC,0xB8,0x1,0x2, 0xCD,0x13,0x59,0x5A, 0x58, 0x72,0x9,0x40,
0x75,0x1,0x42,0x3, 0x5E,0xB,0xE2,0xCC,0xC3,0x3 ,0x18 ,0x1 ,0x27,0xD ,0xA,0x49, 0x6E,
0x76,0x61,0x6C,0x69,0x64,0x20, 0x73, 0x79, 0x73, 0x74, 0x65,0x6D,0x20,0x64,0x69,0x73,
0x6B,0xFF,0xD ,0xA,0x44,0x69, 0x73,0x6B,0x20, 0x49,0x2F, 0x4F,0x20, 0x65,0x72, 0x72,0x6F,
0x72,0xFF,0xD ,0xA,0x52, 0x65,0x70,0x6C,0x61,0x63, 0x65,0x20,
0x74,0x68, 0x65, 0x20,
0x64, 0x69,0x73, 0x6B,0x2C,0x20,0x61, 0x6E,0x64,0x20,0x74, 0x68, 0x65, 0x6E, 0x20,0x70,
0x72,0x65, 0x73,0x73, 0x20,0x61, 0x6E,0x79,0x20,0x6B,0x65,0x79,0xD,0xA, 0x0,0x49,0x4F,
0x20,0x20,0x20,0x20, 0x20,0x20,0x53,0x59,0x53,0x4D, 0x53, 0x44, 0x4F, 0x53,0x20,0x20,
0x20,0x53, 0x59,0x53, 0x80,0x1,0x0 ,0x57,0x49, 0x4E,0x42, 0x4F,0x4F,0x54,0x20,0x53, 0x59
,0x53,0x0,0x0,0x55,0xAA};
clrscr();
dinfo.drive = 0x00; /* drive number for A: */
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 */
gotoxy(10,9);
cprintf("Attempting to read from Floppy disk drive :\n");
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
result = _bios_disk(_DISK_WRITE, &dinfo);
if ((result & 0xff00) == 0)
{
gotoxy(10,14);
cprintf("Disk Write Status :successful.\n");
}
else
{
gotoxy(10,14);
cprintf("Cannot read drive A, status = 0x%02x\n",
result);
gotoxy(10,16);
switch(result)
{
case 0x00:
cprintf("\n\n STATUS: No Error!!");
break;
case 0x01:
cprintf("\n\n STATUS: Bad command");
break;
case 0x02:
cprintf("\n\n STATUS: Address mark not found");
break;
case 0x03:
cprintf("\n\n STATUS: Attempt to write to write-
protected disk");
break;
case 0x04:
cprintf("\n\n STATUS: Sector not found");
break;
case 0x06:
cprintf("\n\n STATUS: Disk changed since last operation");
break;
case 0x08:
cprintf("\n\n STATUS: Direct memory access (DMA) overrun");
break;
case 0x09:
cprintf("\n\n STATUS: Attempt to perform DMA across 64K boundary");
break;
case 0x0C:
cprintf("\n\n STATUS: Media type not found");
break;
case 0x10:
cprintf("\n\n STATUS: Bad CRC/ECC on disk read");
break;
case 0x20:
cprintf("\n\n STATUS: Controller has failed");
break;
case 0x31:
cprintf("\n\n STATUS: No media in drive (IBM/MS INT 13H extensions)");
break;
case 0x32:
cprintf("\n\n STATUS: Incorrect drive type stored in CMOS (Compaq)");
break;
case 0x40:
cprintf("\n\n STATUS: Seek operation failed");
break;
case 0x80:
cprintf("\n\n STATUS: Attachment failed to respond(Disk Timed-out)");
break;
case 0xB0:
cprintf("\n\n STATUS: Volume not locked in drive (INT 13H extensions)");
break;
case 0xB1:
cprintf("\n\n STATUS: Volume locked in drive (INT 13H extensions)");
break;
case 0xB2:
cprintf("\n\n STATUS: Volume not removable (INT 13H extensions)");
break;
case 0xB3:
cprintf("\n\n STATUS: Volume in use (INT 13 extensions)");
break;
case 0xB4:
cprintf("\n\n STATUS: Lock count exceeded (INT 13H extensions)");
break;
case 0xB5:
cprintf("\n\n STATUS: Valid eject request failed (INT 13H extensions)");
break;
default: cprintf("\n\n STATUS: UNKNOWN Status CODE For Floppy Errors");
}
}
return 0;
}
In dieser Programmcodierung gehen wir im Wesentlichen Schritt für Schritt vor, um die folgenden Aufgaben auszuführen:
- Der statische Zeichendatenpuffer dbuf[512] liefert die Informationen von 512 Bytes im Hexadezimalsystem, die in den ersten Sektor einer nicht lesbaren Diskette geschrieben werden sollen. dbuf[512] teilt dem Computer während der Operation mit, welche Informationen in den ersten Sektor der Diskette geschrieben werden sollen. (Siehe nächstes Programm)
- 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 die Informationen auf den ersten Sektor der Festplatte schreiben werden, ist die Position des Sektors wie folgt:
| Parameter |
What it means |
| dinfo.drive = 0x00 |
It indicates the drive 0 that is floppy disk drive (a:) |
| 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 write operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- Initialisieren Sie das Plattensystem mit dem Interrupt 13H (Funktion 00h), wobei regs.h.ah = 0x00 auf die Funktion 00 H zeigt und regs.h.dl = 0x00 für eine: Diskette verwendet wird. Und int86(0x13, ®s, ®s) ruft den MS-DOS-Interrupt-Service INT 13 H auf.
- _bios_disk(_DISK_WRITE, &dinfo) schreibt die Startinformationen aus der angegebenen Datei in den ersten (angegebenen) Sektor der Diskette.
Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für einen erfolgreichen Vorgang anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Speichern des Boot-Images in HEXADEZIMAL-Zeichen zur Verwendung in unserem vorherigen Programm
Es wird eine sehr schwierige Aufgabe sein, alle 512 Zeichen des DOS-Boot-Records der Diskette manuell im Hexadezimalsystem ohne Fehler in dem Programm zu schreiben, das wir kürzlich besprochen haben. Wenn wir es sogar genau schreiben können, wird es eine schwierige und zeitaufwändige Aufgabe sein, dies zu tun. Lassen Sie uns einen kniffligen Verstand verwenden, um die Daten für den Datenpuffer dbuf[512] in einer Datei zu speichern.
Wir wissen, dass in der C-Programmierung die hexadezimalen Zeichen mit 0x dargestellt werden, sodass wir, wenn das hexadezimale Zeichen A9 H ist, dies in unserem C-Programm als 0xA9 schreiben. Unser nächstes Programm macht dasselbe. Es speichert die Daten, die wir in unserem vorherigen Programm schreiben müssen, als die Daten des Datenpuffers dbuf[512].
Was Sie tun müssen, ist nur, eine frische und neue Diskette zu nehmen, um das Image ihres DBR zu erstellen und die Ausgabe dieses Programms aus der angegebenen Zieldatei zu kopieren und diese Daten in Ihr Programm einzufügen. Nehmen Sie bei Bedarf eine Formatierung vor. Lassen Sie uns sehen, wie es funktioniert:
/* Programm, um das Boot-Image der Diskette in HEX-Zeichen zu erstellen */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo;
union REGS regs;
int result,i;
int count=0;
char fname[80];
static char dbuf[512];
FILE *fp;
dinfo.drive = 0x00; /* drive number for A: */
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 */
clrscr();
gotoxy(10,3);cprintf("Enter The File Name And Path To
Store The Boot Image in HEX System");
gotoxy(5,5);
gets(fname);
fp=fopen(fname,"wb");
if((fp=fopen(fname,"wb"))==NULL)
{
highvideo();
gotoxy(10,10);cprintf("File Could Not Be created");
getch();
exit(0);
}
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
gotoxy(10,9); cprintf("Attempting to read from Floppy
disk drive :\n");
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
gotoxy(10,14);
cprintf("Disk read from Floppy disk drive :
successful.\n");
while(count<512)
{
fprintf(fp,"0x%X, ",dbuf[count] & 0xff );
count++;
}
fclose(fp);
}
else
{
gotoxy(10,14);
cprintf("Cannot read drive A, status = 0x%02x\n",
result);
}
return 0;
}
Anmerkungen zur Codierung des Programms:
Somit werden die Daten in der angegebenen Datei gespeichert. Kopieren Sie einfach die Daten in Ihr Programm und führen Sie einige erforderliche Formatierungen durch. Die folgenden Tipps sollten Sie während des gesamten Verfahrens nie vergessen:
- Stellen Sie sicher, dass der Betrieb des Programms erfolgreich war und die in der Zieldatei gespeicherten Daten korrekt sind.
- Sie sollten den Vorgang vollständig auf das Auftreten erwarteter Fehler überprüfen.
- Sie müssen die Diskette mit dem Programm initialisieren, bevor Sie ihren Bootsektor lesen. Sie können zu diesem Zweck die Funktion 00H von INT 13H verwenden.
Method – 2
Was tun, wenn Methode – 1 funktioniert nicht?
Wenn die Methode – 1 nicht funktioniert und die nicht lesbare Festplatte dem Programm nicht erlaubt, die Boot-Informationen in seinen ersten Sektor neu zu schreiben, sollten Sie diese zweite Methode ausprobieren. Der Grund für das Scheitern von First Method kann die physikalische Beschädigung des ersten Sektors der Diskette sein.
Bei dieser zweiten Methode kopieren wir vorübergehend alle Daten der Oberfläche der nicht lesbaren Diskette in eine einzige Datei und fügen dieses Bild dann direkt auf die Oberfläche der anderen guten Diskette ein.
Das Verfahren umfasst die folgenden zwei wichtigen Schritte:
- Sektor-für-Sektor Kopieren Sie alle Daten der Oberfläche von Diskettenmedien vorübergehend in eine einzige Datei.
- Fügen Sie die zuvor in der Datei gespeicherten Daten auf einer neuen, frischen Diskette so wie sie sind in denselben Sektoren ein.
Kopieren Sie alle Daten der Medienoberfläche in eine einzige Datei
Um alle Daten der Oberfläche von Diskettenmedien zu speichern, muss das Programm die folgenden drei Aufgaben erledigen:
- Initialisieren Sie die Platte ordnungsgemäß mit Hilfe der Funktion 00H von INT 13H.
- Lesen Sie die Sektor-für-Sektor-Informationen der Oberfläche und speichern Sie sie in einer einzigen Datei.
- Überprüfen Sie den erfolgreichen Lesevorgang (am wichtigsten)
Es kommt sehr häufig vor, dass bei einer Diskette ein Initialisierungsproblem auftritt, das zu vielen erfolglosen Lesemeldungen führt. Deshalb muss die Platte vor dem Lese-Schreib-Vorgang mit Hilfe der Programmierung initialisiert werden.
Es ist der wichtigste und notwendige Schritt bei jeder Art von Operationen, die auf Diskette angewendet werden, um zu überprüfen, ob die Operation erfolgreich war oder nicht.
Wenn auch nach der Initialisierung die neu eingelegte Diskette oder die geänderte Diskette einen Lesefehler verursacht, wird Ihnen empfohlen, das Programm erneut auszuführen, höchstwahrscheinlich funktioniert es dieses Mal.
Das folgende Programm soll diese spezifizierten Aufgaben ausführen. Mal sehen, wie es weitergeht:
/* Programm zum Speichern der Daten der physischen Oberfläche der Diskette in einer Datei */
#include <bios.h>
#include <stdio.h>
void main(void)
{
int head,track;
union REGS regs;
int result,i,sector;
char filename[80];
struct diskinfo_t dinfo;
static char dbuf[512];
FILE *tt;
clrscr();
printf("\n Enter The Name of file with Path to store The
Data Temporarily\n");
gets(filename);
if((tt=fopen(filename,"wb"))==NULL)
{
printf("Could Not Create The File,
Press any Key To EXIT");
getch();
exit(0);
}
printf("\n Initializing Floppy Disk System...\n");
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
for(track=0;track<=79;track++)
{
for(head=0;head<=1;head++)
{
for(sector=1;sector<=18;sector++)
{
dinfo.drive = 0; /* drive number for A: */
dinfo.head = head; /* disk head number */
dinfo.track = track; /* track number */
dinfo.sector = sector; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
for(i=0;i<512;i++)
fprintf(tt,"%c",dbuf[i] & 0xff);
}
else
{
printf("Cannot read drive A, status =
0x%02x\t%d\t%d\t%d\n", result,head,track,sector);
}
printf("Reading Track= %d Head= %d Sector= %d\n",
track,head,sector);
}
}
}
}
Bemerkungen zur Programmcodierung:
In der zuvor angegebenen Programmcodierung gehen wir im Wesentlichen Schritt für Schritt vor, um die folgenden Aufgaben auszuführen:
- Das Zeichenarray filename[80] speichert den benutzerdefinierten Pfad und Dateinamen der Datei, in der wir die Daten vorübergehend speichern werden.
- 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.
- Initialisieren Sie das Plattensystem mit dem Interrupt 13H (Funktion 00h), wobei regs.h.ah = 0x00 auf die Funktion 00 H zeigt und regs.h.dl = 0x00 für eine: Diskette verwendet wird. Und int86(0x13, ®s, ®s) ruft den MS-DOS-Interrupt-Service INT 13 H auf.
- Da wir alle Informationen der Festplattenoberfläche lesen werden, lauten die Parameter von _bios_disk wie folgt:
| Parameter |
What it means |
| dinfo.drive = 0x00 |
It indicates the drive 0 that is floppy disk drive (a:) |
| dinfo.head = head |
It points to head number 0 and 1 as floppy has two sides(two heads) |
| dinfo.track = track |
It points to track 0 to 79 as there are 80 tracks on each side of floppy. |
| dinfo.sector = sector |
It points to sector 1 to 18 as there are 18 sectors in each track. |
| dinfo.sector = 1 |
Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- _bios_disk(_DISK_READ, &dinfo) liest die Daten von der physikalischen Oberfläche der Diskette aus dem durch dinfo angegebenen Sektor.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für einen erfolgreichen Vorgang anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Denken Sie immer daran, dass die Größe der Datei, die das Image der Diskettendaten enthält, genau 1.474.560 Byte betragen muss, da die Diskette 80 Spuren (0 bis 79), 2 Seiten oder Köpfe (Kopf 0 und Kopf 1) für jede Spur hat hat 18 Sektoren und jeder Sektor enthält somit die 512 Bytes an Daten
Total bytes = (Number of tracks) * (Number of Heads) *
(Number of Sectors per Track) * 512
= 80*2*18*512
= 1,474,560 Bytes
Wenn also ein Fehler beim Lesen in einem beliebigen Sektor der Diskette auftritt, ändert sich die Größe der Datei von 1.474.560 Bytes, wodurch die gesamten Informationen für die Zieldiskette, auf die wir gehen, ganz oder teilweise unbrauchbar werden um das Disk-Image Sektor für Sektor aus dieser Datei zu schreiben.
Dies liegt daran, dass der Computer die Informationen jeder Datei auf der Oberfläche des Mediums der Diskette innerhalb des Sektorbereichs liest, wie er in seiner Zuordnungseinheit zugeordnet wurde. Wenn nun die Sektoren der Daten der Dateien geändert werden, werden die vollständigen Dateiinformationen geändert.
Nachdenken über die Lösung des Lesefehlers von Sektoren
Es ist möglich, dass die fehlerhafte oder unlesbare Diskette einen so schlechten Bereich auf ihrer Oberfläche hat, dass wir die Informationen von der Oberfläche der Diskette möglicherweise nicht lesen können.
In diesem Zustand werden die Informationen dieses Sektors/dieser Sektoren übersprungen und das Bild der Diskette wird auch für die anderen Sektoren verzerrt, da die Größe der Bilddatei in diesem Fall von 1.474.560 Bytes abweicht.
Um die Größe der Bilddatei beizubehalten und die restlichen Informationen an den genauen Sektorpositionen auf der Zielfestplatte einzufügen, schreiben wir einige andere Informationen anstelle der Originaldaten von 512 Bytes und sind auf diese Weise in der Lage den Rest der Informationen zu speichern, jedoch kann die Wiederherstellung in einem solchen Fall die teilweise Wiederherstellung sein.
Wenn Ihr System auch den ersten Sektor der Quelldiskette nicht lesen kann, sollten Sie nach dem Einfügen des Images auf die Zieldiskette das zuvor beschriebene Programm ausführen, um den DOS Boot Record der Diskette neu zu schreiben.
Lassen Sie uns sehen, wie wir es durch Programmierung tun können:
#include <bios.h>
#include <stdio.h>
void main(void)
{
int head,track;
union REGS regs;
int result,i,sector;
char filename[80];
struct diskinfo_t dinfo;
static char dbuf[512];
/*Informationen von 512 Bytes, um den Platz des fehlerhaften Sektors zu füllen */
/// Ich habe 512 Nullen verwendet, um den Platz von 512 Bytes zu füllen \\\
statisches Zeichen dbuf2[512] =
"00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000" "00000000000000000000000000000000";
FILE *tt;
clrscr();
printf("\n Enter The Name of file with Path to store The
Data Temporarily\n");
gets(filename);
if((tt=fopen(filename,"wb"))==NULL)
{
printf("Could Not Create The File, Press any Key To
EXIT");
getch();
exit(0);
}
printf("\n Initializing Floppy Disk System...\n");
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
for(track=0;track<=79;track++)
{
for(head=0;head<=1;head++)
{
for(sector=1;sector<=18;sector++)
{
dinfo.drive = 0; /* drive number for A: */
dinfo.head = head; /* disk head number */
dinfo.track = track; /* track number */
dinfo.sector = sector; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
for(i=0;i<512;i++)
fprintf(tt,"%c",dbuf[i] & 0xff);
}
else
{
printf("Cannot read drive A, status =
0x%02x\t%d\t%d\t%d\n", result, head, track, sector);
/* Wenn der Sektor nicht lesbar ist, belegen Sie 512 Bytes durch dbuf2 */
fwrite(dbuf2,512,1,tt);
}
printf("Reading Track= %d Head= %d Sector= %d\n",
track, head, sector);
}
}
}
}
Bemerkungen zur Programmcodierung:
Bei der Codierung des Programms ist jeder Schritt derselbe wie im vorherigen Programm, mit Ausnahme des Datenpuffers dbuf2[512], den wir verwenden, um den Fehler zu behandeln, der durch einen fehlerhaften Sektor während des Festplattenlesevorgangs erzeugt wird, und um Behalten Sie die Größe der Bilddatei bei.
Dadurch füllen wir den Platz der Informationen, die wir nicht aus dem schlechten Sektor gelesen haben, und jetzt schreiben wir die Pseudoinformationen von 512 Bytes, so dass wir kann die Genauigkeit des Disk-Images beibehalten.
Fügen Sie die Daten aus der Datei auf die physische Oberfläche einer neuen Diskette ein:
In diesem Schritt fügen wir die vom vorherigen Programm in der Datei gespeicherten Daten Sektor für Sektor auf der physischen Oberfläche der neuen Diskette ein, so wie wir sie in die Datei kopiert haben.
Das Programm läuft mit den folgenden Hauptschritten ab:
- Öffnen Sie die Datei, in der wir die Oberflächendaten der nicht lesbaren Diskette zwischengespeichert haben.
- Initialisieren Sie das Plattensystem ordnungsgemäß durch die Rücksetzfunktion 00H von INT 13H.
- Schreiben Sie die Informationen in die Sektoren der neuen Diskette aus der Datei.
- Zeigen Sie gleichzeitig den Schreibstatus an, um das Auftreten von Fehlern zu finden oder zu vermeiden.
Der Quellcode des Programms wurde unten angegeben. Lassen Sie uns untersuchen, wie es funktioniert:
/* Programm zum Schreiben der Daten auf die Sektoren der Oberfläche einer frischen Diskette aus der Datei, die vom vorherigen Programm erstellt wurde */
#include <bios.h>
#include <stdio.h>
void main(void)
{
int head,track;
union REGS regs;
int result,i,sector;
int count =0;
char filename[80];
struct diskinfo_t dinfo;
static char dbuf[512];
FILE *fp;
clrscr();
printf("\n Enter The Name of file with Path to store The
Data Temporarily\n");
gets(filename);
if((fp=fopen(filename,"rb"))==NULL)
{
printf("Could Not Create The File, Press any Key To
EXIT");
getch();
exit(1);
}
/// Initialisieren Sie das Plattensystem \\\
for(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Reset Disk System */
regs.h.dl = 0x00; /* Floppy Disk a: */
int86(0x13, ®s, ®s);
}
for(track=0;track<=79;track++)
{
for(head=0;head<=1;head++)
{
for(sector=1;sector<=18;sector++)
{
count =0;
while(count<512 )
{
fscanf(fp,"%c",&dbuf[count]);
count++;
}
dinfo.drive = 0x00; /* drive number for A: */
dinfo.head = head; /* disk head number */
dinfo.track = track; /* track number */
dinfo.sector = sector;/* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
result= _bios_disk(_DISK_WRITE, &dinfo);
if ((result & 0xff00) == 0)
printf("Successful write on Track = %d, Head = %d,
Sector = %d.\n", track, head, sector);
else
printf("Cannot read drive A, status = 0x%02x\n",
result);
}
}
}
}
Bemerkungen zur Programmcodierung:
In der zuvor angegebenen Programmcodierung gehen wir im Wesentlichen Schritt für Schritt vor, um die folgenden Aufgaben auszuführen:
- Das Zeichenarray filename[80] enthält den Pfad und den Dateinamen der Datei, in der wir die Daten der Oberfläche einer nicht lesbaren Diskette vorübergehend gespeichert haben.
- 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.
- Initialisieren Sie das Plattensystem mit dem Interrupt 13H (Funktion 00h), wobei regs.h.ah = 0x00 auf die Funktion 00 H zeigt und regs.h.dl = 0x00 für eine: Diskette verwendet wird. Und int86(0x13, ®s, ®s) ruft den MS-DOS-Interrupt-Service INT 13 H auf.
- Da wir die Informationen direkt in Sektoren der Festplattenoberfläche schreiben werden, lauten die Parameter von _bios_disk wie folgt:
| Parameter |
What it means |
| dinfo.drive = 0x00 |
It indicates the drive 0 that is floppy disk drive (a:) |
| dinfo.head = head |
It points to head number 0 and 1 as floppy has two sides(two heads) |
| dinfo.track = track |
It points to track 0 to 79 as there are 80 tracks on each side of floppy. |
| dinfo.sector = sector |
It points to sector 1 to 18 as there are 18 sectors in each track. |
| dinfo.sector = 1 |
Number of sectors to consider for write operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- _bios_disk(_DISK_WRITE, &dinfo) schreibt die Daten auf die durch dinfo spezifizierten Sektoren der physikalischen Oberfläche der Diskette.
- Der zurückgegebene Status wird im Ergebnis gespeichert, das verwendet wird, um die Nachricht für einen erfolgreichen Vorgang anzuzeigen oder um eine Fehlermeldung auf dem Bildschirm anzuzeigen, wenn ein Fehler auftritt.
Wenn nach der Methode – 2 Ihre neue Diskette nicht funktioniert, können Sie die Methode weiter anwenden – 1 auf Ihrer neuen Diskette, die Sie während der Methode – 2.
Nicht nur dies, sondern auch die Anzahl der Treffer und Versuche kann je nach Beschädigung der Festplatte variieren. Aber Sie müssen sich keine Sorgen machen, wenn Sie auch danach keine zufriedenstellenden Ergebnisse erzielen.
Sie können die Wiederherstellung von Datei zu Datei versuchen oder viele weitere Tipps ausprobieren, die Sie im Folgenden lernen werden. Hier werden wir die Idee implementieren, die Dateiinformationen aus Root-Verzeichnissen in unserer Programmierung zu sammeln, um die Daten wiederherzustellen.
Denken an eine logische Wiederherstellung für gelöschte oder verlorene Daten:
Alle vorherigen Fälle, die wir in diesem Kapitel zur Wiederherstellung besprochen haben, dienten der Wiederherstellung der Daten in solchen Fällen, in denen wir erwartet hatten, dass nur der DBR beschädigt ist und die Sektoren in Spur 0 , mit FAT1, FAT2 und Root-Verzeichnissen sind lesbar.
Aber wenn das Problem auf die Beschädigung von FAT zurückzuführen ist oder die Daten von der Festplatte gelöscht wurden oder Sie die Daten direkt wiederherstellen möchten, indem Sie ihre Informationen auslesen das Root-Verzeichnis, wir müssen Informationen wie Dateiname, Startcluster, Größe der Datei, Attribut usw. lesen. aus seinem Stammverzeichniseintrag.
Wie wir bereits in früheren Kapiteln über Root Directory gesprochen haben, gibt es die Information von 32 Bytes für jede Datei oder jedes Verzeichnis. Diese 32 Bytes teilen sich wie folgt auf:
| Number of Bytes |
Information Description |
| 8 Bytes |
Filename |
| 3 Bytes |
Extension |
| 1 Byte |
Attribute |
| 10 Bytes |
Reserved |
| 2 Bytes |
Time, Created or Last Updated |
| 2 Bytes |
Date, Created or Last Updated |
| 2 Bytes |
Starting Cluster |
| 4 Bytes |
File Size |
Wir stellen die Daten wieder her, indem wir die Informationen der Datei(en) aus dem Stammverzeichnis lesen und dann die Datei in den Zielpfad integrieren und die Datei wiederherstellen. Unser nächstes Programm führt die folgenden Schritte aus, um die Daten wiederherzustellen:
- Lesen Sie die Root-Verzeichniseinträge und zeigen Sie sie mit allen Informationen wie Datei-/Verzeichnisname, Erweiterung der Datei, Anfangsclustergröße der Dateien in Bytes auf dem Bildschirm an.
- Lesen Sie die Informationen zu Dateien und Verzeichnissen in den Unterverzeichnissen und zeigen Sie sie bei Bedarf an.
- Bestätigen Sie den wiederherzustellenden Dateinamen und fahren Sie mit der Wiederherstellung fort.
- Berechnen Sie die CHS-Informationen (Zylinder, Kopf und Sektor) für die wiederherzustellende angegebene Datei.
- Integrieren Sie die Daten der Datei aus dem Datenbereich der Festplatte und speichern Sie die wiederhergestellte Datei unter dem angegebenen Zieldateinamen im angegebenen Pfad.
Dieses Programm kümmert sich nicht darum, ob die Startinformationen der Diskette lesbar sind oder nicht. Daher können Sie sogar gelöschte Daten auch von der beschädigten Diskette wiederherstellen. Lassen Sie uns die Codierung des Programms sehen:
/* Programm zum Wiederherstellen der Daten von der Diskette durch Lesen von Dateiinformationen aus dem Stammverzeichnis */
#include<stdio.h>
#include<bios.h>
#include<dos.h>
void main()
{
void Display_Information(unsigned int,unsigned int,
unsigned int);
unsigned int track=0,head=1,sector=2;
Display_Information(track,head,sector);
} /*End of main */
void Display_Information(unsigned int track,
unsigned int head,
unsigned int sector)
{
void recover(unsigned int *,unsigned int);
char buf[512]; // Buffer of 512 Bytes
char ch;
struct diskinfo_t finfo; //Structure, Used by _bios_disk
unsigned int result,i,j, count=0; /* Unsigned Integers
Defined */
unsigned int file_no; /* Unsigned Integer
for File Number */
struct
{
unsigned int name[8],ext[3]; /* File Name for DOS in 8.3
(Eight Dot Three) Format */
unsigned int attribute; // File/Directory Attribute
unsigned int start; // Starting Cluster of the File
long unsigned int size; // Size of the File in Bytes
}root[32]; /* 32 Bytes Information of
File/Directory in Root
Directory */
clrscr();
do
{
file_no=0;
finfo.drive = 0x00; /* drive number for A: */
finfo.head = head; /* disk head number */
finfo.track = track; /* track number */
finfo.sector= sector; /* sector number */
finfo.nsectors=1; /* sector count */
finfo.buffer = buf; /* data buffer */
result = _bios_disk(_DISK_READ, &finfo); /* Read the
Sector */
if( (result & 0xff00) != 0) /* If Read Error, Display
Error Message and Exit*/
{
printf("Read error");
getch();
exit(0); // Go Back to DOS
}
/// Bildschirmformat der Informationsanzeige \\\
clrscr();
gotoxy(9,1);
cprintf("DISPLAY CYLN: %u, HEAD: %u, SECTOR: %u",
track, head, sector);
gotoxy(9,2);
cprintf("FNO NAME EXT ATTRIBUTE START SIZE");
gotoxy(7,3);
cprintf("--------------------------------------------");
/* Ein Sektor nach dem anderen. Jeder File/DIR-Eintrag benötigt 32 Byte */
for(i=0;i<512;i+=32)
{
for(j=0;j<8;j++)
{
/// Find The File/Dir Name \\\
root[file_no].name[j]=buf[j+i];
}
for(j=8;j<11;j++)
{
/// Suchen Sie die Erweiterung \\\
root[file_no].ext[j-8]=buf[i+j];
}
j=11;
root[file_no].attribute=buf[i+j]; /// Attribute
/// Cluster starten \\\
root[file_no].start=(0xff & buf[27+i])*16*16 + (0xff & buf[26+i]);
/// Berechnen Sie die Größe \\\
root[file_no].size =(long unsigned int)(0xff &
buf[31+i])*16*16*16*16*16*16*16*16;
root[file_no].size+=(long unsigned int)(0xff &
buf[30+i])*16*16*16*16;
root[file_no].size+=(long unsigned int)(0xff &
buf[29+i])*16*16;
root[file_no].size+=(long unsigned int)(0xff &
buf[28+i]);
if((root[file_no].start == 0) ||
(root[file_no].attribute == 15))
continue;
else
{
gotoxy(8,i/32+4);
cprintf("%2u",file_no); /* Display File
Number */
for(j=0;j<8;j++)
{
gotoxy(14+j,i/32+4);
cprintf("%c",root[file_no].name[j]); /* Display File
Name */
}
for(j=0;j<3;j++)
{
gotoxy(26+j,i/32+4);
cprintf("%c",root[file_no].ext[j]); /* Display
Extension */
}
gotoxy(30,i/32+4);
cprintf("%u",root[file_no].attribute); /* Display
Attribute */
if(root[file_no].attribute==16)
{
gotoxy(33,i/32+4);
cprintf("<DIR>"); /* Display if Directory Attribute */
}
else
{
gotoxy(33,i/32+4);
cprintf("<FILE>"); /* The Entry is of a file */
}
gotoxy(44,i/32+4);
cprintf("%-5u", root[file_no].start); /* Display
Starting Cluster */
gotoxy(58,i/32+4);
cprintf("%-10lu", root[file_no].size); /* size of the
File */
}
file_no++;
}
gotoxy(10,
cprintf("Press 'M' : To see list of more files &quo
gotoxy(10,
cprintf("Press 'R' :To recover a file from the above
list&quo
ch=getc
Denken Sie daran, dass der Dateiname, der mit s (E5H) beginnt, anzeigt, dass die Datei gelöscht wurde und daher das erste Zeichen des Dateinamens durch s ersetzt wurde (siehe die Beschreibung des Stammverzeichnisses in den früheren Kapiteln).
Und die Ausgabe des Programms wird wie folgt angezeigt:
|
DISPLAY CYLN: 0, HEAD: 1, SECTOR: 2
FNO NAME EXT ATTRIBUTE START SIZE
--------------------------------------------------------------------------
0 WE 32 <FILE> 15 1800
1 s2_INFO C 32 <FILE> 5 4700
2 THELP CFG 32 <FILE> 2 22
3 THELP COM 32 <FILE> 3 11072
4 TIMEIT CPP 32 <FILE> 39 1186
5 TOUCH COM 32 <FILE> 42 5124
6 TRY1 CPP 32 <FILE> 53 1581
7 TURBOC CFG 32 <FILE> 57 30
8 AA CPP 32 <FILE> 58 260
9 ABC CPP 32 <FILE> 59 1036
10 ASSIGN1 CPP 32 <FILE> 62 4257
11 CH24_2 CPP 32 <FILE> 71 834
12 sBSDISK1 C 32 <FILE> 73 911
13 sH24_25 C 32 <FILE> 75 594
14 sBSDISK C 32 <FILE> 77 840
Press 'M' : To see list of more files
Press 'R' :To recover a file from the above list R
|
|
DISPLAY CYLN: 0, HEAD: 1, SECTOR: 2
FNO NAME EXT ATTRIBUTE START SIZE
----------------------------------------------------------------------------
0 WE 32 <FILE> 15 1800
1 s2_INFO C 32 <FILE> 5 4700
2 THELP CFG 32 <FILE> 2 22
3 THELP COM 32 <FILE> 3 11072
4 TIMEIT CPP 32 <FILE> 39 1186
5 TOUCH COM 32 <FILE> 42 5124
6 TRY1 CPP 32 <FILE> 53 1581
7 TURBOC CFG 32 <FILE> 57 30
8 AA CPP 32 <FILE> 58 260
9 ABC CPP 32 <FILE> 59 1036
10 ASSIGN1 CPP 32 <FILE> 62 4257
11 CH24_2 CPP 32 <FILE> 71 834
12 sBSDISK1 C 32 <FILE> 73 911
13 sH24_25 C 32 <FILE> 75 594
14 sBSDISK C 32 <FILE> 77 840
Enter FNO. of the file you want to recover 1
You want to recover _2_INFO .C
Cylinder = 1, Head = 0, Sector = 1 Integrating........
Enter Path and Filename to recover the file: c:\windows\desktop\H2_INFO.C
Recovery Done !!!
|
Anmerkungen zur Codierung:
Die Funktion Display_Information dient zum Lesen der Datei- und Verzeichnisinformationen und aus dem Root-Verzeichnis. In der Struktur lesen wir die 32-Byte-Informationen für jede Datei oder jedes Verzeichnis mit root[32].
Die vorzeichenlosen Integer-Arrays name[8] und ext[3] sind für Datei- oder Verzeichnisnamen für DOS im 8.3-Format (Eight Dot Three). Ähnlich ist ein Byte für das Attribut und zwei Bytes für das Starten des Clusters. lange unsignierte Int-Größe; ist die Größe der Datei von vier Bytes zu speichern.
Die Funktion _bios_disk liest den Sektor, der durch die Struktur finfo angegeben ist, und der Status der Operation wird im Ergebnis gespeichert.
Von allen Informationen von 512 Bytes, die von der _bios_disk-Funktion gelesen werden, bis zum Ende des Stammverzeichnisbereichs, sammeln wir die Informationen der auf der Festplatte gespeicherten Dateien und Verzeichnisse und zeigen sie an auf dem Bildschirm.
Die Ganzzahl file_no speichert die Nummer der Datei oder des Verzeichnisses in der Liste, beginnend bei 0. Im Allgemeinen beträgt die Größe des Stammverzeichnisses 14 Sektoren und das Stammverzeichnis beginnt im Allgemeinen bei Zylinder = 0, Kopf = 0 und Sektor = 2 im Falle von 1,44 MB und 3½ Diskette.
Wenn der Benutzer das Zeichen ‘M’ oder ‘m’ Als Eingabe werden die Informationen des nächsten Sektors angezeigt, wenn die Auswahl durch den Benutzer ‘R’ oder ‘r’ Die Wiederherstellungsfunktionen werden aufgerufen. Die Codierung der Funktion recover() ist unten angegeben:
/* Funktion zum Starten der Wiederherstellung für die angegebene Datei */
void recover(unsigned int *root,unsigned int len)
{
void clear_the_line(unsigned int r); /* Function to Clear a Row on the Screen */
/* Funktion zum Integrieren der angegebenen Datei */
void integrate(long unsigned int,unsigned int,
unsigned int,unsigned int);
unsigned int file_no,i;
char ch;
unsigned int *loc;
unsigned int cylinder,head,sector;
unsigned int start;
long unsigned int size;
clear_the_line(21); /* Clear The Row Number 21 */
clear_the_line(22); /* Clear The Row Number 22 */
clear_the_line(23); /* Clear The Row Number 23 */
clear_the_line(24); /* Clear The Row Number 24 */
gotoxy(10,21);
cprintf("Enter FNO. of the file you want to recover");
scanf("%u",&file_no); /* Get the File No. to be
Recovered */
loc=(root+(len*file_no/2));
/* Bestätigen Sie den wiederherzustellenden Dateinamen */
gotoxy(10,22);
cprintf("You want to recover");
for(i=0;i<8;i++)
{
gotoxy(30+i,22);
cprintf("%c",*(loc+i)); /* File name */
}
gotoxy(38,22);
cprintf(".");
for(i=0;i<3;i++)
{
gotoxy(39+i,22);
cprintf("%c",*(loc+8+i)); /* File Extension */
}
start=*(loc+12);
/// Entschuldigung, Sie haben ein Verzeichnis ausgewählt \\\
if(*(loc+11)==16)
{
gotoxy(5,23);
cprintf("Is A directory. Do you want to see the
contents of this directory Y/N");
ch=getch();
if(ch==27)
main();
if(ch=='y' || ch=='Y')
{
/* Geomatrie berechnen */
calculate(start,&cylinder,&head,§or);
/* Display Directory Contents */
Display_Information (cylinder,head,sector);
}
else
/* Ask for A file again and Continue Recovery */
recover(root,len);
}
else
{
size=*(loc+13);
/* Berechnen Sie für CHS-Informationen */
calculate(start,&cylinder,&head,§or);
/* Integrate The File */
integrate(size,cylinder,head,sector);
}
}
Anmerkungen zur Codierung:
Die Funktion recover() dient dazu, die Benutzereingabe zum Starten der Wiederherstellung zu erhalten. Die vom Benutzer zur Wiederherstellung der Datei eingegebene Dateinummer wird in file_no gespeichert.
Wenn die eingegebene Nummer für den Verzeichniseintrag gilt, zeigt Display_Information() den Inhalt dieses Verzeichnisses an, andernfalls werden der Dateiname und die Erweiterung der Dateinummer file_no auf dem Bildschirm angezeigt, um die wiederherzustellende Datei zu bestätigen.
Um die angegebene Datei wiederherzustellen, werden die Funktionen calculate() und integrate() innerhalb der Funktion aufgerufen. Die Kodierung der Funktion compute() wurde unten angegeben:
/* Funktion Zur Berechnung der CHS-Geomatry For The Recovery */
void calculate(unsigned int start,unsigned int *cylinder,
unsigned int *head,unsigned int *sector)
{
unsigned int temp;
*cylinder=0;
*head=1;
*sector=14;
if(start<5)
*sector=14+start;
else
{
temp= (start-4)/18;
if(temp>0)
{
if(temp%2==0)
*head=0;
else
*head=1;
*cylinder+=1+temp/2;
}
else
{
*head=0;
*cylinder=1;
}
*sector=(start-4)%18;
}
/// Zeigen Sie den CHS der wiederherzustellenden Datei an \\\
gotoxy(10,23);
cprintf("Cylinder = %u, Head = %u, Sector = %u",
*cylinder,*head,*sector);
}
Anmerkungen zur Codierung:
Die Funktion calculate() dient zur Berechnung der Zylinder-, Kopf- und Sektorinformationen für die wiederherzustellende Datei. Nach der Berechnung werden die Zylinder-, Kopf- und Sektornummern auf dem Bildschirm angezeigt.
Die Codierung für die Funktion Integrate () wurde unten angegeben:
/* Integrieren Sie die Datei und speichern Sie die wiederhergestellte Datei unter dem angegebenen Pfad und Dateinamen */
void integrate(long unsigned int size,
unsigned int cylinder,
unsigned int head,
unsigned int sector)
{
void clear_the_line(unsigned int);
/* Funktion zum Überprüfen des Sektors auf Fehler */
int verify_the_sector(unsigned int, unsigned int,
unsigned int);
int status;
char buf[512],*Filename_with_path;
struct diskinfo_t dinfo;
unsigned int result;
FILE *fp;
unsigned int left,i;
unsigned int sec;
/* Geben Sie den Zielpfad und den Dateinamen ein, um die wiederhergestellte Datei zu speichern */
gotoxy(2,24);
cprintf("Enter Path and Filename to recover the file: ");
fflush(stdin);
gets(Filename_with_path);
fp=fopen(Filename_with_path,"wb");
/* Wenn ein Fehler aufgetreten ist, zeigen Sie die Fehlermeldung an und erhalten Sie den Eingabepfad und den Dateinamen erneut */
if(fp==NULL)
{
gotoxy(5,25);
cprintf("Error in opening the file");
getch();
clear_the_line(24);
gotoxy(0,25);
cprintf(" ");
integrate(size,cylinder,head,sector); /* Enter the
Destination Again */
}
/* Wenn alles in Ordnung ist, Integrieren und schreiben */
gotoxy(50,23);
cprintf("Integrating........");
left= size%512;
sec = size/512;
sec++;
while(sec>0)
{
dinfo.drive = 0x00; /* drive number for A: */
dinfo.head = head; /* disk head number */
dinfo.track = cylinder; /* track number */
dinfo.sector= sector; /* sector number */
dinfo.nsectors=1; /* sector count */
dinfo.buffer = buf; /* data buffer */
result = _bios_disk(_DISK_READ, &dinfo);
/* If there is Error While Reading any Sector */
if( (result & 0xff00) != 0)
{
gotoxy(5,25);
cprintf("read error Cylinder %u, Head %u, Sector %u",
cylinder, head, sector);
}
else
{
if(sec==1)
{
for(i=0;i<left;i++)
fputc(buf[i],fp); /* Write The Integrated
Information to the File */
}
else
{
fwrite(buf,512,1,fp);
}
Anmerkungen zur Codierung:
Die Funktion integrate() ist das eigentliche Modul zur Durchführung der Wiederherstellung der vom Benutzer angegebenen Datei in diesem Wiederherstellungsprogramm.
Der Dateiname mit dem Zielpfad zum Speichern der wiederhergestellten Datei wird im Zeichenzeiger *Dateiname_mit_Pfad gespeichert. Wenn beim Öffnen der Zieldatei ein Fehler auftritt, wird eine Fehlermeldung angezeigt und der Benutzer wird erneut aufgefordert, das Ziel einzugeben.
Die Funktion _bios_disk(_DISK_READ, &dinfo); liest die durch die Struktur dinfo spezifizierten und im Datenpuffer buf abgelegten Daten der Datei sektorweise aus dem Datenbereich der Platte. Diese Daten von 512 Bytes werden in die Zieldatei geschrieben. Dies wird solange wiederholt, bis die komplette Datei integriert ist.
Die Funktion status=verify_the_sector (Zylinder,Kopf,Sektor); überprüft den zu lesenden Sektor. Wenn der Status = 10 ist, stellt dies einen fehlerhaften (0xA) Sektor dar. Die Codierung der Funktion ist unten angegeben:
/// Überprüfen Sie den Sektor. (Hier werden keine Daten übertragen) \\\
int verify_the_sector(unsigned int c,unsigned int h,unsigned int s)
{
int status;
char *buf;
union REGS in, out;
struct SREGS sg;
in.h.ah = 0x04; /* Function Number */
in.h.al = 1; /* Number of Sectors to Verify*/
in.h.dl = 0x00; /* Drive Number for A: */
in.h.ch = c; /* Cylinder Number */
in.h.dh = h; /* Head Number */
in.h.cl = s; /* Sector Number */
in.x.bx = FP_OFF(buf);/* Offset */
sg.es = FP_SEG(buf); /* Segment */
int86x(0x13,&in,&out,&sg); /* Call the Function 4H
of INT 13H */
if(out.x.cflag)
{
status=out.h.ah;
}
return(status);
}
Kommentare zur Codierung:
Die Funktion verify_the_sector() verifiziert den von der Funktion _bios_disk() zu lesenden Sektor und gibt den Status der Operation zurück. Die Funktion verwendet INT 13H und Funktion 4H, um den Sektor zu überprüfen.
*buf ist der Datenpuffer, 0x04 ist die durch in.h.ah = 0x04 angegebene Funktionsnummer; und in.h.al = 1; weist an, jeweils nur einen Sektor zu überprüfen. in.h.dl = 0x00; wird für die Laufwerksnummer des Diskettenlaufwerks A: verwendet, c, h und s sind Cylinder-, Head- und Sector-Nummern.
Die Funktion int86x() wird verwendet, um INT 13H (Funktion 4H) mit Segmentregisterwerten aufzurufen. Der Status der Operation wird durch den ganzzahligen Status zurückgegeben.
Die Funktion clear_the_line() löscht die angegebene Zeile auf dem Bildschirm. Die Codierung der Funktion ist wie folgt:
/* Funktion zum Löschen der Zeile auf dem Bildschirm für die angegebene Zeilennummer */
void clear_the_line(unsigned int row)
{
unsigned int column;
/* There are 80 Columns in a Row (Line) */
for(column=1;column<=80;column++)
{
gotoxy(column,row);
cprintf(" "); /* Clear With " " */
}
}
Anmerkungen zur Codierung:
TDie Funktion wird verwendet, um die angegebene Zeile auf dem Bildschirm zu löschen. Die Funktion wird mit der Nummer der Zeile aufgerufen, die vom Bildschirm gelöscht werden soll.
Seite Geändert am: 08/03/2022
Zuhause