Hoofdstuk – 10
GEGEVENS HERSTELLEN VAN EEN BESCHADIGDE SCHIJF
Gegevens herstellen van een beschadigde floppydisk
Een floppy disk is een van de meest onbetrouwbare bronnen voor gegevensopslag. Als u naar een organisatie gaat die computersystemen gebruikt en u vraagt hun werknemers naar problemen die worden veroorzaakt door floppy disks, dan zult u heel vaak horen dat het probleem is dat een werknemer van de organisatie belangrijke gegevens op zijn floppy disk had staan. Nu kan de computer de floppy disk niet meer lezen en verschijnt er een bericht op het scherm dat er ongeveer zo uitziet:
"Kan schijf niet lezen"
"Slechte track 0"
"Ongeldige schijf of capaciteit"
"Schijf niet geformatteerd. Wilt u het nu formatteren?
Dit is een dagelijks probleem voor organisaties die gebruikmaken van computersystemen en floppy disks. Het probleem wordt ernstig wanneer u erachter komt dat er geen back-up is gemaakt of dat er geen back-up beschikbaar is voor de gegevens die verloren lijken te zijn gegaan op de beschadigde floppydisk.
Het grootste probleem ontstaat wanneer u belangrijke informatie op een floppydisk wilt back-uppen, antivirusprogramma's wilt herstellen om een virusaanval te voorkomen, of opstartrecords of andere back-ups (er zijn mogelijk meerdere opties) op een floppydisk wilt maken en er een leesfout optreedt wanneer u de back-up van de floppydisk opnieuw wilt gebruiken.
In een dergelijk geval loopt u het risico belangrijke informatie en gegevens te verliezen. In sommige gevallen, wanneer u merkt dat er te weinig back-ups en herstelprogramma's zijn voor de opstartinformatie van uw computer, of dat er geen programma's zijn die virussen kunnen redden , enz., kunt u een groot gegevensverlies lijden in de vorm van een OS-storing vanwege het gebrek aan informatie die op de floppydisk is opgeslagen en die op dat moment niet door de computer kan worden gelezen.
In dergelijke gevallen is het belangrijkste dat u gegevens kunt herstellen van een floppydisk die uw computersysteem als defect heeft herkend.
Waarom is de floppydisk niet leesbaar?
Het meest voorkomende probleem waardoor een floppydisk foutmeldingen als deze geeft, is een beschadiging van de DOS Boot Record (DBR) van de floppydisk. Deze DBR helpt de computer de logische identiteit van de floppydisk te achterhalen.
De DBR is een klein programma dat is opgeslagen op spoor 0, kop 0 en sector 1 en dat belangrijke informatie over de floppydisk bevat, zoals:
- Aantal bytes per sector
- Sector per cluster
- Aantal FAT
- Maximaal aantal hoofdmappen, enz.
Omdat de floppydisk geen logisch partitiesysteem heeft, staat er geen MBR op de floppydisk. Het eerste deel van de floppydisk bevat de DBR. Dit is ook het grootste verschil als je de logische structuur van een harde schijf vergelijkt met die van een floppy disk.
Wanneer we de bootsectorinformatie van de floppydisk uitlezen met behulp van een programma voor het bewerken van diskettes, wordt informatie weergegeven zoals in de onderstaande afbeelding.
De volgende afbeelding toont 512 bytes aan DBR-informatie op een 1,44 MB, 3½-inch floppydisk.
Als deze informatie op de een of andere manier beschadigd raakt of onleesbaar wordt, zal de floppydisk deze foutmeldingen weergeven. Dit kan komen door fysieke of logische schade aan de eerste sector van de schijf.
Van logische corruptie is sprake als de informatie in de eerste sector van de diskette is gewijzigd, als er een logisch beschadigde sector is of als de DBR van de diskette om een andere reden is beschadigd.
Er wordt aangenomen dat er fysieke schade optreedt als de eerste sector van de floppydisk fysieke slechte sectoren heeft (d.w.z. sector 1 is fysiek beschadigd). Het probleem wordt ernstiger als u ontdekt dat de floppydisk meer dan één slechte sector op spoor 0 heeft.
Hoe te herstellen
Nu we beide oorzaken van de schade kennen, hoop ik dat u het probleem begrijpt. Het is niet zo moeilijk om gegevens te herstellen van logische corruptie, maar het herstellen van fysieke corruptie vereist wat meer moeite.
Methode – 1
Maak een opstartbaar image van elke nieuwe floppydisk.
Als het probleem logisch is, begrijpen we nu hoe we de gegevens kunnen herstellen . Wat we moeten doen is gewoon de juiste Boot record van een andere floppy van dezelfde grootte en capaciteit halen en deze plakken in de eerste sector van de onleesbare floppy. Hoewel het probleem is ontstaan door de slechte boot record , zou het nu moeten werken.
Deze procedure bestaat uit twee stappen. We gaan nu onze gegevens herstellen van een onleesbare floppy:
- Het maken van een image van DOS Boot Record van een goede floppy
- Het opstartimage plakken op de eerste sector van de onleesbare floppy
Het maken van een image van DOS Boot Record van een goede floppy
Om een image van de opstartrecord van een nieuwe floppy op te slaan, moet het programma de volgende drie taken uitvoeren:
- Lees precies de eerste 512 bytes van de goede floppy
- Controleer of de leesbewerking succesvol is verlopen (belangrijkste)
- Sla deze 512 bytes op in de opgegeven bestandsnaam en het opgegeven bestemmingspad
De sector van de floppy is 512 bytes en het is noodzakelijk om de exacte afbeelding van de sector te kopiëren. Het is de belangrijkste en noodzakelijke stap in het geval van elk type bewerkingen toegepast op de floppy om te controleren of de bewerking succesvol was of niet.
Er kan een initialisatieprobleem zijn, zelfs met de goede en verse floppy disk. Daarom wordt in de meeste gevallen, wanneer de bewerking op floppy disks wordt uitgevoerd, eerst de initialisatie van floppy disks uitgevoerd in de programmering met de reset disk-bewerking (functie 00 H van INT 13H).
Als de onlangs geplaatste of verwisselde floppy disk ook na initialisatie nog steeds een leesfout veroorzaakt , raden wij u aan het programma opnieuw uit te voeren. De kans is groot dat het deze keer wel werkt.
Het volgende programma is om deze specifieke taken uit te voeren. Laten we eens kijken hoe het verder gaat:
/* Sla het opstartimage op in een bestand vanaf een nieuwe floppydisk */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
vakbond REGS-regels;
int resultaat;
int aantal=0, i;
char voornaam[80];
statische char dbuf[512];
BESTAND *fp;
dinfo.drive = 0x00; /* schijfnummer voor A: */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
clrscr();
gotoxy(10,3);cprintf("Voer de bestandsnaam en het pad naar
Boot-image opslaan");
gotoxy(5,5);
krijgt(fnaam);
fp=fopen(voornaam,"wb");
als((fp=fopen(fnaam,"wb"))==NULL)
{
hoogvideo();
gotoxy(10,10);cprintf("Bestand kon niet worden gemaakt");
halen();
uitgang(0);
}
gotoxy(10,9);
cprintf("Proberen te lezen van floppydiskstation :\n");
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
terwijl(aantal<512)
{
fprintf(fp,"%c",dbuf[aantal] & 0xff );
tellen++;
}
fsluiten(fp);
gotoxy(10,14);cprintf("Schijf gelezen van floppydiskstation
: succesvol.\n");
}
anders
{
gotoxy(10,14);
cprintf("Kan station A niet lezen, status = 0x%02x\n", resultaat);
schakelaar(resultaat)
{
geval 0x00:
cprintf("\n\n STATUS: Geen fout!! ");
pauze;
geval 0x01:
cprintf("\n\n STATUS: Ongeldige opdracht ");
pauze;
geval 0x02:
cprintf("\n\n STATUS: Adresmarkering niet gevonden ");
pauze;
geval 0x03:
cprintf("\n\n STATUS: Poging om te schrijven naar schrijfbeveiligde schijf ");
pauze;
geval 0x04:
cprintf("\n\n STATUS: Sector niet gevonden ");
pauze;
geval 0x06:
cprintf("\n\n STATUS: Schijf gewijzigd sinds laatste bewerking ");
pauze;
geval 0x08:
cprintf("\n\n STATUS: Directe geheugentoegang (DMA) overschreden ");
pauze;
geval 0x09:
cprintf("\n\n STATUS: Poging om DMA uit te voeren over de 64K-grens ");
pauze;
geval 0x0C:
cprintf("\n\n STATUS: Mediatype niet gevonden ");
pauze;
geval 0x10:
cprintf("\n\n STATUS: Slechte CRC/ECC bij het lezen van de schijf ");
pauze;
geval 0x20:
cprintf("\n\n STATUS: Controller is mislukt ");
pauze;
geval 0x31:
cprintf("\n\n STATUS: Geen media in station (IBM/MS INT 13H-extensies) ");
pauze;
geval 0x32:
cprintf("\n\n STATUS: Onjuist schijftype opgeslagen in CMOS (Compaq) ");
pauze;
geval 0x40:
cprintf("\n\n STATUS: Zoekbewerking mislukt ");
pauze;
geval 0x80:
cprintf("\n\n STATUS: Bijlage kon niet reageren (schijftime-out) ");
pauze;
geval 0xB0:
cprintf("\n\n STATUS: Volume niet vergrendeld in station (INT 13H extensies) ");
pauze;
geval 0xB1:
cprintf("\n\n STATUS: Volume vergrendeld in station (INT 13H-extensies) ");
pauze;
geval 0xB2:
cprintf("\n\n STATUS: Volume niet verwijderbaar (INT 13H extensies) ");
pauze;
geval 0xB3:
cprintf("\n\n STATUS: Volume in gebruik (INT 13H extensies) ");
pauze;
geval 0xB4:
cprintf("\n\n STATUS: Lock count overschreden (INT 13H extensies) ");
pauze;
geval 0xB5:
cprintf("\n\n STATUS: Geldige uitwerpaanvraag mislukt (INT 13H-extensies) ");
pauze;
standaard: cprintf("\n\n STATUS: ONBEKENDE Statuscode voor floppyfouten ");
}
}
retourneer 0;
}
Opmerkingen over programmacodering:
In de eerder gegeven programmacodering voeren we in principe de volgende taken stap voor stap uit:
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat over de parameters die nodig zijn voor de bewerking die wordt uitgevoerd door de functie _bios_disk.
- Omdat we de eerste sector van de schijf willen lezen, zal de locatie van de sector als volgt zijn:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x00 |
Het geeft station 0 aan , dat is het floppy disk station ( a :) |
| dinfo.hoofd = 0 |
Het wijst naar hoofdnummer 0 |
| dinfo.track = 0 |
Het wijst naar spoor 0 |
| dinfo.sector = 1 |
Eerste sector van de floppy, dat is sector 1 |
| dinfo.sector = 1 |
Aantal sectoren dat in aanmerking moet worden genomen voor de leesbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
- Open een bestandsstroom met door de gebruiker opgegeven bestandsnaam en pad om de bootimage-informatie van exact 512 bytes op te slaan. De bestandsnaam en het pad worden opgeslagen in de tekenreeks fname.
- Initialiseer het disksysteem met behulp van de interrupt 13H (functie 00h) waarbij regs.h.ah = 0x00 naar de functie 00 H verwijst en regs.h.dl = 0x00 wordt gebruikt voor a: floppy. En int86(0x13, ®s, ®s) roept MS-DOS interrupt service INT 13 H aan.
- _bios_disk(_DISK_READ, &dinfo) leest de opgegeven sector van de floppy disk.
- De geretourneerde status wordt opgeslagen in result dat wordt gebruikt om een bericht weer te geven bij een succesvolle bewerking of om een foutmelding op het scherm weer te geven als er een fout optreedt.
Het opstartimage plakken op de eerste sector van de onleesbare floppy
Om het opstartimage van het bestand naar de eerste sector van de onleesbare floppy te plakken, moeten we de volgende drie hoofdtaken in ons programma uitvoeren:
- Lees de exacte 512 bytes aan informatie van de opstartrecord van de nieuwe floppy uit het eerder opgeslagen bestand.
- Schrijf deze informatie naar het eerste deel van de floppy dat op dat moment onleesbaar is.
- Controleer of de schrijfbewerking succesvol is voltooid (belangrijkste).
Omdat de sector van de floppy 512 bytes is en het nodig is om de exacte boot image in de sector te plakken, is het de belangrijkste en noodzakelijke stap in het geval van welke soort bewerking dan ook die op de floppy wordt toegepast om te controleren of de bewerking succesvol was of niet.
Er kunnen tijdens de bewerking initialisatieproblemen met de floppydisk optreden. Daarom moet u de diskette initialiseren door het diskettesysteem te resetten (met behulp van functie 00H van INT 13H).
Als de onlangs geplaatste of verwisselde floppy disk ook na initialisatie nog steeds een leesfout veroorzaakt , raden wij u aan het programma opnieuw uit te voeren. De kans is groot dat het deze keer wel werkt.
Het volgende programma is om deze specifieke taken uit te voeren. Laten we eens kijken hoe het verder gaat:
/* Laad opstartimage naar de onleesbare floppy */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
vakbond REGS-regels;
int resultaat;
int aantal=0, i;
char voornaam[80];
teken dbuf[512];
BESTAND *fp;
clrscr();
gotoxy(5,3);cprintf("Voer de bestandsnaam en het pad in waarin het opstartimage van de floppy is opgeslagen");
gotoxy(5,5);
krijgt(fnaam);
fp=fopen(fnaam,"rb");
als((fp=fopen(fnaam,"rb"))==NULL)
{
hoogvideo();
gotoxy(10,10);cprintf("Bestand kon niet worden geopend");
halen();
uitgang(0);
}
gotoxy(10,9);
cprintf("Poging om floppydiskstation te herstellen :\n");
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
terwijl(aantal<512)
{
fscanf(fp,"%c",&dbuf[aantal]);
tellen++;
}
dinfo.drive = 0x00; /* schijfnummer voor A: */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
als ((resultaat & 0xff00) == 0)
{
fsluiten(fp);
gotoxy(10,14);cprintf("Succesvol!!! Ik hoop dat Floppy May
Werk nu.\n");
}
anders
{
gotoxy(10,14);
cprintf("Kan station A niet lezen, status = 0x%02x\n",result);
gotoxy(10,16);
schakelaar(resultaat)
{
geval 0x00:
cprintf("\n\n STATUS: Geen fout!! ");
pauze;
geval 0x01:
cprintf("\n\n STATUS: Ongeldige opdracht ");
pauze;
geval 0x02:
cprintf("\n\n STATUS: Adresmarkering niet gevonden ");
pauze;
geval 0x03:
cprintf("\n\n STATUS: Poging om te schrijven naar schrijfbeveiligde schijf ");
pauze;
geval 0x04:
cprintf("\n\n STATUS: Sector niet gevonden ");
pauze;
geval 0x06:
cprintf("\n\n STATUS: Schijf gewijzigd sinds laatste bewerking ");
pauze;
geval 0x08:
cprintf("\n\n STATUS: Directe geheugentoegang (DMA) overschreden ");
pauze;
geval 0x09:
cprintf("\n\n STATUS: Poging om DMA uit te voeren over de 64K-grens ");
pauze;
geval 0x0C:
cprintf("\n\n STATUS: Mediatype niet gevonden ");
pauze;
geval 0x10:
cprintf("\n\n STATUS: Slechte CRC/ECC bij het lezen van de schijf ");
pauze;
geval 0x20:
cprintf("\n\n STATUS: Controller is mislukt ");
pauze;
geval 0x31:
cprintf("\n\n STATUS: Geen media in station (IBM/MS INT 13H-extensies) ");
pauze;
geval 0x32:
cprintf("\n\n STATUS: Onjuist schijftype opgeslagen in CMOS (Compaq) ");
pauze;
geval 0x40:
cprintf("\n\n STATUS: Zoekbewerking mislukt ");
pauze;
geval 0x80:
cprintf("\n\n STATUS: Bijlage kon niet reageren (schijftime-out) ");
pauze;
geval 0xB0:
cprintf("\n\n STATUS: Volume niet vergrendeld in station (INT 13H extensies) ");
pauze;
geval 0xB1:
cprintf("\n\n STATUS: Volume vergrendeld in station (INT 13H-extensies) ");
pauze;
geval 0xB2:
cprintf("\n\n STATUS: Volume niet verwijderbaar (INT 13H extensies) ");
pauze;
geval 0xB3:
cprintf("\n\n STATUS: Volume in gebruik (INT 13H extensies) ");
pauze;
geval 0xB4:
cprintf("\n\n STATUS: Lock count overschreden (INT 13H extensies) ");
pauze;
geval 0xB5:
cprintf("\n\n STATUS: Geldige uitwerpaanvraag mislukt (INT 13H-extensies) ");
pauze;
standaard: cprintf("\n\n STATUS: ONBEKENDE Statuscode voor floppyfouten ");
}
}
retourneer 0;
}
Opmerkingen over programmacodering:
In de eerder gegeven programmacodering voeren we in principe de volgende taken stap voor stap uit:
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat over de parameters die nodig zijn voor de bewerking die wordt uitgevoerd door de functie _bios_disk.
- Omdat we de informatie op de eerste sector van de schijf gaan schrijven, zal de locatie van de sector als volgt zijn:
- Open het bestand waarin de boot image informatie van 512 bytes van een nieuwe floppy is opgeslagen door het vorige programma. De bestandsnaam en het pad zijn opgeslagen in de tekenreeks fname.
- Initialiseer het disksysteem met behulp van de interrupt 13H (functie 00h) waarbij regs.h.ah = 0x00 naar de functie 00 H verwijst en regs.h.dl = 0x00 wordt gebruikt voor a: floppy. En int86(0x13, ®s, ®s) roept MS-DOS interrupt service INT 13 H aan.
- _bios_disk(_DISK_WRITE, &dinfo) schrijft de opstartinformatie van het opgegeven bestand naar de eerste (opgegeven) sector van de floppydisk.
- De geretourneerde status wordt opgeslagen in result dat wordt gebruikt om een bericht weer te geven bij een succesvolle bewerking of om een foutmelding op het scherm weer te geven als er een fout optreedt.
| Parameter |
Wat het betekent |
| dinfo.drive = 0x00 |
Het geeft station 0 aan , dat is het floppy disk station ( a :) |
| dinfo.hoofd = 0 |
Het wijst naar hoofdnummer 0 |
| dinfo.track = 0 |
Het wijst naar spoor 0 |
| dinfo.sector = 1 |
Eerste sector van de floppy, dat is sector 1 |
| dinfo.sector = 1 |
Aantal sectoren dat in aanmerking moet worden genomen voor schrijfbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
Laten we het met één programma doen
Ik hoop dat u nu het concept achter dit type data recovery van de floppy disk begrijpt . Laten we ons hierna een enkel programma voorstellen dat dezelfde resultaten geeft als die we kregen met behulp van de eerder besproken twee programma's.
Met de onlangs besproken programma's voerden we de volgende taken uit:
- Sla de opstartinformatie van een goede floppydisk op in een bestand
- Plak deze informatie in de eerste sector van de momenteel onleesbare floppy. Het bestand dat we gebruikten om de bootimage op te slaan, werkte als tussenliggende brug om de bewerkingen van beide programma's te verbinden. Maar als we deze bootinformatie definiëren in onze programmacodering zelf, hoeven we geen bestand te maken en hoeven we de bootinformatie van de floppy niet uit het bestand te lezen.
In ons volgende programma vertellen we ons programma wat het naar de eerste sector van de onleesbare floppy disk moet schrijven. Zo voorkomen we dat twee verschillende programma's dezelfde taak uitvoeren en kunnen we onze gegevens op dezelfde manier als voorheen uit het nieuwe ene programma herstellen.
Het programma wordt zo simpel met minder codering en we kunnen de kans op het optreden van fouten bij het lezen, schrijven of aanmaken van bestanden verkleinen . We voeren de volgende vier belangrijke taken uit in dit programma:
Denk niet dat het programma moeilijk te schrijven en te begrijpen is als je de 512 bytes hexadecimale informatie van dbuf[512] ziet. Later bespreken we de eenvoudige manier om deze informatie voor je programmacodering te schrijven.
- Definieer de DOS-opstartrecordinformatie in het hexadecimale stelsel die moet worden geschreven in de eerste sector van een op dat moment onleesbare floppy.
- Reset het diskettesysteem om de floppy disk te initialiseren (INT 13H, Functie 00H).
- Schrijf de DOS Boot Record naar de eerste sector van de floppy
- Controleer of de bewerking succesvol is voltooid en of er fouten zijn opgetreden.
Laten we het programma eens bekijken:
/* Enkel programma om standaard opstartimage te laden naar onleesbare floppydisk */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
vakbond REGS-voorschriften:
int resultaat, i;
/* Boot Image moet worden geladen in het floppy diskstation */
statisch 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,0x72,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; /* schijfnummer voor A: */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
gotoxy(10,9);
cprintf("Proberen te lezen van floppydiskstation :\n");
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
als ((resultaat & 0xff00) == 0)
{
gotoxy(10,14);
cprintf("Schijfschrijfstatus: succesvol.\n");
}
anders
{
gotoxy(10,14);
cprintf("Kan station A niet lezen, status = 0x%02x\n",
resultaat);
gotoxy(10,16);
schakelaar(resultaat)
{
geval 0x00:
cprintf("\n\n STATUS: Geen fout!! ");
pauze;
geval 0x01:
cprintf("\n\n STATUS: Ongeldige opdracht ");
pauze;
geval 0x02:
cprintf("\n\n STATUS: Adresmarkering niet gevonden ");
pauze;
geval 0x03:
cprintf("\n\n STATUS: Poging om te schrijven naar schrijven-
beveiligde schijf ");
pauze;
geval 0x04:
cprintf("\n\n STATUS: Sector niet gevonden ");
pauze;
geval 0x06:
cprintf("\n\n STATUS: Schijf gewijzigd sinds laatste bewerking ");
pauze;
geval 0x08:
cprintf("\n\n STATUS: Directe geheugentoegang (DMA) overschreden ");
pauze;
geval 0x09:
cprintf("\n\n STATUS: Poging om DMA uit te voeren over de 64K-grens ");
pauze;
geval 0x0C:
cprintf("\n\n STATUS: Mediatype niet gevonden ");
pauze;
geval 0x10:
cprintf("\n\n STATUS: Slechte CRC/ECC bij het lezen van de schijf ");
pauze;
geval 0x20:
cprintf("\n\n STATUS: Controller is mislukt ");
pauze;
geval 0x31:
cprintf("\n\n STATUS: Geen media in station (IBM/MS INT 13H-extensies) ");
pauze;
geval 0x32:
cprintf("\n\n STATUS: Onjuist schijftype opgeslagen in CMOS (Compaq) ");
pauze;
geval 0x40:
cprintf("\n\n STATUS: Zoekbewerking mislukt ");
pauze;
geval 0x80:
cprintf("\n\n STATUS: Bijlage kon niet reageren (schijftime-out) ");
pauze;
geval 0xB0:
cprintf("\n\n STATUS: Volume niet vergrendeld in station (INT 13H extensies) ");
pauze;
geval 0xB1:
cprintf("\n\n STATUS: Volume vergrendeld in station (INT 13H-extensies) ");
pauze;
geval 0xB2:
cprintf("\n\n STATUS: Volume niet verwijderbaar (INT 13H extensies) ");
pauze;
geval 0xB3:
cprintf("\n\n STATUS: Volume in gebruik (INT 13 extensies) ");
pauze;
geval 0xB4:
cprintf("\n\n STATUS: Lock count overschreden (INT 13H extensies) ");
pauze;
geval 0xB5:
cprintf("\n\n STATUS: Geldige uitwerpaanvraag mislukt (INT 13H-extensies) ");
pauze;
standaard: cprintf("\n\n STATUS: ONBEKENDE Statuscode voor floppyfouten ");
}
}
retourneer 0;
}
In dit programma gaan we in principe de volgende taken stap voor stap uitvoeren:
- Statische karaktergegevensbuffer dbuf[512] wordt voorzien van de informatie van 512 bytes in het hexadecimale systeem, die moet worden geschreven in de eerste sector van de onleesbare floppy. dbuf[512] vertelt de computer tijdens de bewerking welke informatie moet worden geschreven in de eerste sector van de floppy. (Zie het volgende programma)
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat over de parameters die nodig zijn voor de bewerking die wordt uitgevoerd door de functie _bios_disk.
- Omdat we de informatie op de eerste sector van de schijf gaan schrijven, zal de locatie van de sector als volgt zijn:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x00 |
Het geeft station 0 aan , dat is het floppy disk station ( a :) |
| dinfo.hoofd = 0 |
Het wijst naar hoofdnummer 0 |
| dinfo.track = 0 |
Het wijst naar spoor 0 |
| dinfo.sector = 1 |
Eerste sector van de floppy, dat is sector 1 |
| dinfo.sector = 1 |
Aantal sectoren dat in aanmerking moet worden genomen voor schrijfbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
- Initialiseer het disksysteem met behulp van de interrupt 13H (functie 00h) waarbij regs.h.ah = 0x00 naar de functie 00 H verwijst en regs.h.dl = 0x00 wordt gebruikt voor a: floppy. En int86(0x13, ®s, ®s) roept MS-DOS interrupt service INT 13 H aan.
- _bios_disk(_DISK_WRITE, &dinfo) schrijft de opstartinformatie van het opgegeven bestand naar de eerste (opgegeven) sector van de floppydisk.
De geretourneerde status wordt opgeslagen in result dat wordt gebruikt om een bericht weer te geven bij een succesvolle bewerking of om een foutmelding op het scherm weer te geven als er een fout optreedt.
Het opslaan van de boot-image in HEXADECIMALE tekens voor gebruik in ons vorige programma
Het zal een heel moeilijke klus zijn om alle 512 tekens van de DOS Boot Record van de floppy handmatig in het hexadecimale systeem te schrijven zonder fouten in het programma dat we onlangs bespraken. Als we het zelfs maar nauwkeurig kunnen schrijven, dan zal het een moeilijke en tijdrovende taak zijn om dit te doen. Laten we een slimme geest gebruiken om de gegevens voor databuffer dbuf[512] in een bestand op te slaan.
We weten dat in C-programmering de hexadecimale tekens worden weergegeven met 0x, zodat als het hexadecimale teken A9 H is, we dit in ons C-programma zullen schrijven als 0xA9. Ons volgende programma doet hetzelfde. Het zal de gegevens opslaan die we in ons vorige programma moeten schrijven, als de gegevens van gegevensbuffer dbuf[512].
Wat u moet doen is gewoon een nieuwe floppy nemen om een image van zijn DBR te maken en de output van dit programma te kopiëren van het opgegeven doelbestand en deze data in uw programma te plakken. Voer indien nodig wat opmaak uit. Laten we eens kijken hoe het werkt:
/* Programma om de opstartimage van de floppydisk in HEX-tekens te maken */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
vakbond REGS-regels;
int resultaat,i;
int aantal=0;
char voornaam[80];
statische char dbuf[512];
BESTAND *fp;
dinfo.drive = 0x00; /* schijfnummer voor A: */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
clrscr();
gotoxy(10,3);cprintf("Voer de bestandsnaam en het pad naar
Sla de opstartimage op in het HEX-systeem");
gotoxy(5,5);
krijgt(fnaam);
fp=fopen(voornaam,"wb");
als((fp=fopen(fnaam,"wb"))==NULL)
{
hoogvideo();
gotoxy(10,10);cprintf("Bestand kon niet worden gemaakt");
halen();
uitgang(0);
}
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
gotoxy(10,9); cprintf("Proberen te lezen van Floppy
schijfstation :\n");
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
gotoxy(10,14);
cprintf("Schijf gelezen van floppydiskstation:
succesvol.\n");
terwijl(aantal<512)
{
fprintf(fp,"0x%X, ",dbuf[aantal] & 0xff );
tellen++;
}
fsluiten(fp);
}
anders
{
gotoxy(10,14);
cprintf("Kan station A niet lezen, status = 0x%02x\n",
resultaat);
}
retourneer 0;
}
Opmerkingen over de codering van het programma:
Zo worden de gegevens opgeslagen in het opgegeven bestand. Kopieer de gegevens gewoon naar uw programma en voer de vereiste opmaak uit. U mag de volgende tips nooit vergeten tijdens de procedure:
- Controleer of de uitvoering van het programma succesvol is verlopen en of de gegevens die in het doelbestand zijn opgeslagen, correct zijn.
- Controleer de gehele bewerking op de verwachte fouten.
- U moet de Floppy disk initialiseren in, met het programma voordat u de boot sector leest. U kunt hiervoor functie 00H van INT 13H gebruiken.
Methode – 2
Wat moet u doen als Methode 1 niet werkt?
Als Methode – 1 niet werkt en de onleesbare disk het programma niet toestaat de bootinformatie op de eerste sector te herschrijven, moet u deze tweede methode proberen. De reden achter het falen van de eerste methode kan de fysieke corruptie van de eerste sector van de floppy disk zijn.
Bij deze tweede methode kopiëren we alle gegevens van het oppervlak van de onleesbare floppy tijdelijk naar één enkel bestand. Vervolgens plakken we dit bestand rechtstreeks op het oppervlak van een andere goede diskette.
De procedure omvat de volgende twee belangrijke stappen:
- Sector-voor-sector Kopieer tijdelijk alle gegevens van het oppervlak van de floppy naar één enkel bestand.
- Plak de eerder in het bestand opgeslagen gegevens op een nieuwe, lege floppy, op dezelfde sectoren.
Kopieer alle gegevens van het mediaoppervlak naar één enkel bestand
Om alle gegevens op het oppervlak van het floppy-medium op te slaan, moet het programma de volgende drie taken uitvoeren:
- Initialiseer de schijf correct met behulp van functie 00H van INT 13H.
- Lees de sector-voor-sectorinformatie van het oppervlak en sla deze op in één bestand.
- Controleer of de leesbewerking succesvol is verlopen (belangrijkste)
Het is heel gebruikelijk om een initialisatieprobleem te hebben met een floppy disk, wat leidt tot veel mislukte leesberichten. Daarom moet de disk worden geïnitialiseerd vóór de lees-schrijfbewerking met behulp van programmering.
Het is de belangrijkste en noodzakelijke stap bij elke bewerking die op een floppy wordt uitgevoerd, om te controleren of de bewerking succesvol is geweest of niet.
Als de onlangs geplaatste of verwisselde floppy disk ook na initialisatie nog steeds een leesfout veroorzaakt, raden wij u aan het programma opnieuw uit te voeren. De kans is groot dat het deze keer wel werkt.
Het volgende programma is om deze specifieke taken uit te voeren. Laten we eens kijken hoe het verder gaat:
/* Programma om de gegevens van het fysieke oppervlak van de floppydisk op te slaan in een bestand */
#include <bios.h>
#include <stdio.h>
leeg hoofd(leeg)
{
int hoofd,track;
vakbond REGS-regels;
int resultaat,i,sector;
char bestandsnaam[80];
structuur diskinfo_t dinfo;
statische char dbuf[512];
BESTAND *tt;
clrscr();
printf("\n Voer de naam van het bestand in met het pad om het op te slaan
Gegevens tijdelijk\n");
krijgt(bestandsnaam);
als((tt=fopen(bestandsnaam,"wb"))==NULL)
{
printf("Kan het bestand niet aanmaken,
Druk op een toets om af te sluiten");
halen();
uitgang(0);
}
printf("\n Initialiseren van floppy disk systeem...\n");
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
voor(track=0;track<=79;track++)
{
voor(hoofd=0;hoofd<=1;hoofd++)
{
voor(sector=1;sector<=18;sector++)
{
dinfo.drive = 0; /* schijfnummer voor A: */
dinfo.head = head; /* schijfkopnummer */
dinfo.track = track; /* tracknummer */
dinfo.sector = sector; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
voor(i=0;i<512;i++)
fprintf(tt,"%c",dbuf[i] & 0xff);
}
anders
{
printf("Kan station A niet lezen, status =
0x%02x\t%d\t%d\t%d\n", resultaat,kop,spoor,sector);
}
printf("Leesspoor= %d Hoofd= %d Sector= %d\n",
spoor,hoofd,sector);
}
}
}
}
Opmerkingen over programmacodering:
In de eerder gegeven programmacodering voeren we in principe de volgende taken stap voor stap uit:
- Karakterarray bestandsnaam[80] slaat het door de gebruiker gedefinieerde pad en de bestandsnaam op van het bestand waarin we de gegevens tijdelijk gaan opslaan.
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat over de parameters die nodig zijn voor de bewerking die wordt uitgevoerd door de functie _bios_disk.
- Initialiseer het disksysteem met behulp van de interrupt 13H (functie 00h) waarbij regs.h.ah = 0x00 naar de functie 00 H verwijst en regs.h.dl = 0x00 wordt gebruikt voor a: floppy. En int86(0x13, ®s, ®s) roept MS-DOS interrupt service INT 13 H aan.
- Omdat we alle informatie van het schijfoppervlak gaan lezen, zullen de parameters van _bios_disk als volgt zijn:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x00 |
Het geeft station 0 aan , dat is het floppy disk station ( a :) |
| dinfo.head = hoofd |
Het wijst naar kopnummer 0 en 1 omdat de floppy twee kanten heeft (twee koppen) |
| dinfo.track = spoor |
Het verwijst naar de sporen 0 tot en met 79, aangezien er 80 sporen op elke kant van de floppy staan. |
| dinfo.sector = sector |
Het verwijst naar sector 1 tot en met 18, aangezien elk spoor uit 18 sectoren bestaat . |
| dinfo.sector = 1 |
Aantal sectoren dat in aanmerking moet worden genomen voor de leesbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
- _bios_disk(_DISK_READ, &dinfo) leest de gegevens van het fysieke oppervlak van de floppy disk uit de sector die door dinfo is opgegeven.
- De geretourneerde status wordt opgeslagen in result dat wordt gebruikt om een bericht weer te geven bij een succesvolle bewerking of om een foutmelding op het scherm weer te geven als er een fout optreedt.
Onthoud altijd dat de grootte van het bestand dat de afbeelding van de gegevens van de floppydisk bevat, exact 1.474.560 bytes moet zijn, omdat de floppy 80 sporen (0 tot 79) heeft, 2 zijden of koppen (kop 0 en kop 1), elk spoor 18 sectoren heeft en elke sector 512 bytes aan gegevens bevat, dus
Totaal aantal bytes = (Aantal tracks) * (Aantal koppen) *
(Aantal sectoren per spoor) * 512
= 80*2*18*512
= 1.474.560 bytes
Als er dus een fout optreedt bij het lezen van een sector van de floppydisk, verandert de bestandsgrootte van 1.474.560 bytes. Hierdoor is de gehele informatie geheel of gedeeltelijk onbruikbaar voor de doeldiskette waarnaar we de schijfkopie sector voor sector gaan schrijven.
Dit komt doordat de computer de informatie van elk bestand op het oppervlak van de media van de floppy disk binnen het sectorbereik leest zoals het is toegewezen in zijn toewijzingseenheid. Als nu de sectoren van de gegevens van de bestanden worden gewijzigd, wordt de volledige bestandsinformatie gewijzigd.
Denken over de oplossing van de leesfout van de sector(en)
Het is mogelijk dat de slechte of onleesbare floppy zo'n slecht oppervlak heeft dat we de informatie op het oppervlak van de schijf niet kunnen lezen.
In deze situatie wordt de informatie van deze sector(en) overgeslagen en wordt de afbeelding van de floppy vervormd, zelfs voor de andere sectoren, omdat de grootte van het afbeeldingsbestand in dit geval afwijkt van 1.474.560 bytes.
Om de grootte van het imagebestand te behouden en de overige informatie op de exacte sectorlocaties op de doelschijf te plakken, schrijven we wat andere informatie namens de originele gegevens van 512 bytes. Op deze manier kunnen we de rest van de informatie opslaan, maar het herstel kan in dat geval gedeeltelijk zijn.
Als uw systeem er ook niet in slaagt de eerste sector van de brondiskette te lezen, nadat u de image naar de doeldiskette hebt geplakt, moet u het eerder beschreven programma uitvoeren om de DOS Boot Record van de diskette te herschrijven.
Laten we eens kijken hoe we dit kunnen doen door te programmeren:
#include <bios.h>
#include <stdio.h>
leeg hoofd(leeg)
{
int hoofd,track;
vakbond REGS-regels;
int resultaat,i,sector;
char bestandsnaam[80];
structuur diskinfo_t dinfo;
statische char dbuf[512];
/* Informatie van 512 bytes om de ruimte van de slechte sector te vullen */
/// Ik heb 512 nullen gebruikt om de ruimte van 512 bytes te vullen \\\
statisch char dbuf2[512] =
"00000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "00000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "00000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "00000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000" "0000000000000000000000000000000";
BESTAND *tt;
clrscr();
printf("\n Voer de naam van het bestand in met het pad om het op te slaan
Gegevens tijdelijk\n");
krijgt(bestandsnaam);
als((tt=fopen(bestandsnaam,"wb"))==NULL)
{
printf("Kan het bestand niet aanmaken, druk op een toets om
UITGANG");
halen();
uitgang(0);
}
printf("\n Initialiseren van floppy disk systeem...\n");
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
voor(track=0;track<=79;track++)
{
voor(hoofd=0;hoofd<=1;hoofd++)
{
voor(sector=1;sector<=18;sector++)
{
dinfo.drive = 0; /* schijfnummer voor A: */
dinfo.head = head; /* schijfkopnummer */
dinfo.track = track; /* tracknummer */
dinfo.sector = sector; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
voor(i=0;i<512;i++)
fprintf(tt,"%c",dbuf[i] & 0xff);
}
anders
{
printf("Kan station A niet lezen, status =
0x%02x\t%d\t%d\t%d\n", resultaat, hoofd, spoor, sector);
/* Als Sector niet leesbaar is, worden 512 bytes ingenomen door dbuf2 */
fwrite(dbuf2,512,1,tt);
}
printf("Leesspoor= %d Hoofd= %d Sector= %d\n",
spoor, hoofd, sector);
}
}
}
}
Opmerkingen over programmacodering:
Bij het coderen van het programma is elke stap hetzelfde als in het vorige programma, behalve de gegevensbuffer dbuf2[512], die we gebruiken om de fout te verwerken die wordt gegenereerd door een slechte sector tijdens het lezen van de schijf en om de grootte van het afbeeldingsbestand te behouden.
Door dit te doen, vullen we de ruimte met informatie die we niet konden lezen van de slechte sector en schrijven we nu de pseudo-informatie van 512 bytes, zodat we de nauwkeurigheid van de schijfkopie kunnen behouden.
Plak de gegevens uit het bestand op het fysieke oppervlak van een nieuwe floppy:
In deze stap plakken we de gegevens die door het vorige programma in het bestand zijn opgeslagen, sector voor sector op het fysieke oppervlak van de nieuwe floppy, op dezelfde manier als waarop we ze naar het bestand hebben gekopieerd.
Het programma verloopt in de volgende hoofdstappen:
- Open het bestand waarin we tijdelijk de oppervlaktegegevens van de onleesbare floppy hebben opgeslagen.
- Initialiseer het schijfsysteem op de juiste manier door de resetfunctie 00H van INT 13H.
- Schrijf de informatie over de sectoren van de nieuwe floppy uit het bestand.
- Geef tegelijkertijd de schrijfstatus weer om fouten te vinden of te voorkomen.
De broncode van het programma is hieronder gegeven. Laten we eens kijken hoe het werkt:
/* Programma om de gegevens naar de sectoren van het oppervlak van de nieuwe floppy te schrijven vanuit het bestand dat door het vorige programma is gemaakt */
#include <bios.h>
#include <stdio.h>
leeg hoofd(leeg)
{
int hoofd,track;
vakbond REGS-regels;
int resultaat,i,sector;
int aantal = 0;
char bestandsnaam[80];
structuur diskinfo_t dinfo;
statische char dbuf[512];
BESTAND *fp;
clrscr();
printf("\n Voer de naam van het bestand in met het pad om het op te slaan
Gegevens tijdelijk\n");
krijgt(bestandsnaam);
als((fp=fopen(bestandsnaam,"rb"))==NULL)
{
printf("Kan het bestand niet aanmaken, druk op een toets om
UITGANG");
halen();
uitgang(1);
}
/// Initialiseer het schijfsysteem \\\
voor(i=0; i<3; i++)
{
regs.h.ah = 0x00; /* Schijfsysteem resetten */
regs.h.dl = 0x00; /* Floppydisk a: */
int86(0x13, ®s, ®s);
}
voor(track=0;track<=79;track++)
{
voor(hoofd=0;hoofd<=1;hoofd++)
{
voor(sector=1;sector<=18;sector++)
{
aantal =0;
terwijl(aantal<512 )
{
fscanf(fp,"%c",&dbuf[aantal]);
tellen++;
}
dinfo.drive = 0x00; /* schijfnummer voor A: */
dinfo.head = head; /* schijfkopnummer */
dinfo.track = track; /* tracknummer */
dinfo.sector = sector;/* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
resultaat= _bios_disk(_DISK_WRITE, &dinfo);
als ((resultaat & 0xff00) == 0)
printf("Succesvol schrijven op Track = %d, Head = %d,
Sector = %d.\n", spoor, hoofd, sector);
anders
printf("Kan station A niet lezen, status = 0x%02x\n",
resultaat);
}
}
}
}
Opmerkingen over programmacodering:
In de eerder gegeven programmacodering voeren we in principe de volgende taken stap voor stap uit:
- Karakterarray bestandsnaam[80] bevat het pad en de bestandsnaam van het bestand waarin we tijdelijk de gegevens van het oppervlak van de onleesbare floppy hebben opgeslagen.
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat over de parameters die nodig zijn voor de bewerking die wordt uitgevoerd door de functie _bios_disk.
- Initialiseer het disksysteem met behulp van de interrupt 13H (functie 00h) waarbij regs.h.ah = 0x00 naar de functie 00 H verwijst en regs.h.dl = 0x00 wordt gebruikt voor a: floppy. En int86(0x13, ®s, ®s) roept MS-DOS interrupt service INT 13 H aan.
- Omdat we de informatie rechtstreeks naar sectoren van het schijfoppervlak gaan schrijven , zullen de parameters van _bios_disk als volgt zijn:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x00 |
Het geeft station 0 aan , dat is het floppy disk station ( a :) |
| dinfo.head = hoofd |
Het wijst naar kopnummer 0 en 1 omdat de floppy twee kanten heeft (twee koppen) |
| dinfo.track = spoor |
Het verwijst naar de sporen 0 tot en met 79, aangezien er 80 sporen op elke kant van de floppy staan. |
| dinfo.sector = sector |
Het verwijst naar sector 1 tot en met 18, aangezien elk spoor uit 18 sectoren bestaat . |
| dinfo.sector = 1 |
Aantal sectoren dat in aanmerking moet worden genomen voor schrijfbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
- _bios_disk(_DISK_WRITE, &dinfo) schrijft de gegevens naar de sectoren van het fysieke oppervlak van de floppy disk, gespecificeerd door dinfo.
- De geretourneerde status wordt opgeslagen in result dat wordt gebruikt om een bericht weer te geven bij een succesvolle bewerking of om een foutmelding op het scherm weer te geven als er een fout optreedt.
Als uw nieuwe floppy na Methode 2 niet werkt, kunt u Methode 1 toepassen op uw nieuwe floppy, die u als doeldiskette gebruikte tijdens Methode 2.
Niet alleen dit, maar ook het aantal hits en trials kan variëren afhankelijk van de corruptie van de schijf. Maar u hoeft zich geen zorgen te maken als u zelfs daarna nog steeds niet de gewenste resultaten krijgt.
U kunt bestand voor bestand herstel proberen of u kunt nog veel meer tips proberen die u in het volgende zult leren. Hier zullen we het idee van het verzamelen van de bestandsinformatie van Root Directories implementeren in onze programmering om de gegevens te herstellen.
Denken over logisch herstel van verwijderde of verloren gegevens:
Alle voorgaande gevallen voor herstel die we in dit hoofdstuk hebben besproken, waren bedoeld om gegevens te herstellen in gevallen waarin we verwachtten dat alleen de DBR beschadigd was en de sectoren in spoor 0, met FAT1, FAT2 en de root-directory's, leesbaar waren .
Maar als het probleem wordt veroorzaakt door een beschadiging van FAT of als de gegevens van de schijf zijn verwijderd, of als u de gegevens rechtstreeks wilt herstellen door de informatie ervan uit de hoofdmap te lezen , moeten we de informatie zoals bestandsnaam , startcluster , bestandsgrootte , kenmerk , enz. uit de hoofdmap lezen .
Zoals we al eerder hebben besproken over Root Directory in eerdere hoofdstukken, is er informatie van 32 Bytes voor elk bestand of directory. Deze 32 Bytes zijn als volgt verdeeld:
| Aantal bytes |
Informatie Beschrijving |
| 8 Bytes |
Bestandsnaam |
| 3 bytes |
Verlenging |
| 1 byte |
Attribuut |
| 10 Bytes |
Gereserveerd |
| 2 bytes |
Tijd, gemaakt of laatst bijgewerkt |
| 2 bytes |
Datum, gemaakt of laatst bijgewerkt |
| 2 bytes |
Startcluster |
| 4 bytes |
Bestandsgrootte |
We herstellen de gegevens door de informatie van het bestand(en) uit de rootdirectory te lezen en integreren het bestand vervolgens in het bestemmingspad en herstellen het bestand. Ons volgende programma voert de volgende stappen uit om de gegevens te herstellen:
- Lees de vermeldingen in de hoofdmap en geef deze op het scherm weer, inclusief alle informatie, zoals de naam van het bestand/de map, de extensie van het bestand en de beginclustergrootte van de bestanden in bytes.
- Lees de informatie over bestanden en mappen in de submappen en geef deze indien nodig weer.
- Bevestig de bestandsnaam die u wilt herstellen en ga verder met het herstel.
- Bereken de CHS-gegevens (cilinder, kop en sector) voor het opgegeven bestand dat moet worden hersteld.
- Integreer de gegevens van het bestand uit het gegevensgebied van de schijf en sla het herstelde bestand op in de opgegeven doelbestandsnaam in het opgegeven pad.
Dit programma maakt het niet uit of de bootinformatie van de floppy leesbaar is of niet. Daarom kunt u zelfs verwijderde gegevens van de corrupte floppydisk herstellen . Laten we de codering van het programma bekijken:
/* Programma om de gegevens van de floppydisk te herstellen door bestandsinformatie uit de hoofdmap te lezen */
#include<stdio.h>
#include<bios.h>
#include<dos.h>
leeg hoofd()
{
void Display_Information(unsigned int,unsigned int,
ongetekende int);
ongetekend int spoor=0,hoofd=1,sector=2;
Display_Information(spoor,kop,sector);
} /*Einde van hoofdpagina */
void Display_Information(unsigned int track,
ongetekende int hoofd,
ongetekende int sector)
{
void herstellen(unsigned int *,unsigned int);
char buf[512]; // Buffer van 512 bytes
teken ch;
struct diskinfo_t finfo; //Structuur, Gebruikt door _bios_disk
ongetekende int resultaat,i,j, count=0; /* Ongetekende gehele getallen
Gedefinieerd */
ongetekend int file_no; /* Ongetekend geheel getal
voor Bestandsnummer */
structuur
{
unsigned int name[8],ext[3]; /* Bestandsnaam voor DOS in 8.3
(Acht Punt Drie) Formaat */
unsigned int-kenmerk; // Bestands-/mapkenmerk
unsigned int start; // Startcluster van het bestand
long unsigned int size; // Grootte van het bestand in bytes
}root[32]; /* 32 Bytes Informatie van
Bestand/map in root
Gids */
clrscr();
Doen
{
bestand_nr=0;
finfo.drive = 0x00; /* schijfnummer voor A: */
finfo.head = head; /* schijfkopnummer */
finfo.track = track; /* tracknummer */
finfo.sector= sector; /* sectornummer */
finfo.nsectors=1; /* sectoraantal */
finfo.buffer = buf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_READ, &finfo); /* Lees de
Sectoren */
if( (resultaat & 0xff00) != 0) /* Als leesfout, weergeven
Foutmelding en afsluiten*/
{
printf("Leesfout");
halen();
exit(0); // Ga terug naar DOS
}
/// Informatieweergaveschermformaat \\\
clrscr();
gotoxy(9,1);
cprintf("WEERGAVECYLN: %u, HOOFD: %u, SECTOR: %u",
spoor, hoofd, sector);
gotoxy(9,2);
cprintf("FNO NAAM EXT ATTRIBUUT STARTGROOTTE");
gotoxy(7,3);
cprintf("-------------------------------------");
/* Eén sector per keer. Elke File/DIR-invoer neemt 32 bytes in beslag */
voor(i=0;i<512;i+=32)
{
voor(j=0;j<8;j++)
{
/// Zoek de bestands-/mapnaam \\\
root[bestandsnummer].naam[j]=buf[j+i];
}
voor(j=8;j<11;j++)
{
/// Zoek de extensie \\\
root[bestandsnummer].ext[j-8]=buf[i+j];
}
j=11;
root[file_no].attribute=buf[i+j]; /// Attribuut
/// Cluster starten \\\
root[bestandsnummer].start=(0xff & buf[27+i])*16*16 + (0xff & buf[26+i]);
/// Bereken de grootte \\\
root[bestandsnummer].size =(long unsigned int)(0xff &
buf[31+i])*16*16*16*16*16*16*16*16;
root[bestandsnummer].size+=(lange unsigned int)(0xff &
buf[30+i])*16*16*16*16;
root[bestandsnummer].size+=(lange unsigned int)(0xff &
buf[29+i])*16*16;
root[bestandsnummer].size+=(lange unsigned int)(0xff &
buf[28+i]);
als((root[bestandsnr].start == 0) ||
(root[bestandsnummer].attribute == 15))
doorgaan;
anders
{
gotoxy(8,i/32+4);
cprintf("%2u",file_no); /* Bestand weergeven
Nummer */
voor(j=0;j<8;j++)
{
gotoxy(14+j,i/32+4);
cprintf("%c",root[file_no].name[j]); /* Bestand weergeven
Naam */
}
voor(j=0;j<3;j++)
{
gotoxy(26+j,i/32+4);
cprintf("%c",root[bestandsnummer].ext[j]); /* Weergeven
Verlenging */
}
gotoxy(30,i/32+4);
cprintf("%u",root[bestandsnummer].attribute); /* Weergeven
Kenmerk */
als(root[bestandsnr].attribute==16)
{
gotoxy(33,i/32+4);
cprintf("<DIR>"); /* Weergeven of directorykenmerk */
}
anders
{
gotoxy(33,i/32+4);
cprintf("<BESTAND>"); /* De invoer is van een bestand */
}
gotoxy(44,i/32+4);
cprintf("%-5u", root[bestandsnummer].start); /* Weergeven
Startcluster */
gotoxy(58,i/32+4);
cprintf("%-10lu", root[file_no].size); /* grootte van de
Bestand */
}
bestand_nr++;
}
gotoxy(10,
cprintf("Druk op 'M': Om een lijst met meer bestanden te zien &quo
gotoxy(10,
cprintf("Druk op 'R': om een bestand van bovenaf te herstellen
lijst&quo
ch=krijgc
Houd er rekening mee dat een bestandsnaam die begint met een s (E5H) aangeeft dat het bestand is verwijderd en dat daarom het eerste teken van de bestandsnaam is vervangen door een s (zie de beschrijving van de hoofdmap in de eerdere hoofdstukken).
En de uitvoer van het programma ziet er als volgt uit:
|
WEERGAVECYLN: 0, HOOFD: 1, SECTOR: 2
FNO NAAM EXT ATTRIBUUT STARTGROOTTE
--------------------------------------------------------------------------
0 WE 32 <BESTAND> 15 1800
1 s2_INFO C 32 <BESTAND> 5 4700
2 THELP CFG 32 <BESTAND> 2 22
3 THELP COM 32 <BESTAND> 3 11072
4 TIMEIT CPP 32 <BESTAND> 39 1186
5 TOUCH COM 32 <BESTAND> 42 5124
6 TRY1 CPP 32 <BESTAND> 53 1581
7 TURBOC CFG 32 <BESTAND> 57 30
8 AA CPP 32 <BESTAND> 58 260
9 ABC CPP 32 <BESTAND> 59 1036
10 ASSIGN1 CPP 32 <BESTAND> 62 4257
11 CH24_2 CPP 32 <BESTAND> 71 834
12 sBSDISK1 C 32 <BESTAND> 73 911
13 sH24_25 C 32 <BESTAND> 75 594
14 sBSDISK C 32 <BESTAND> 77 840
Druk op 'M': Om een lijst met meer bestanden te zien
Druk op 'R': Om een bestand uit de bovenstaande lijst te herstellen R
|
|
WEERGAVECYLN: 0, HOOFD: 1, SECTOR: 2
FNO NAAM EXT ATTRIBUUT STARTGROOTTE
----------------------------------------------------------------------------
0 WE 32 <BESTAND> 15 1800
1 s2_INFO C 32 <BESTAND> 5 4700
2 THELP CFG 32 <BESTAND> 2 22
3 THELP COM 32 <BESTAND> 3 11072
4 TIMEIT CPP 32 <BESTAND> 39 1186
5 TOUCH COM 32 <BESTAND> 42 5124
6 TRY1 CPP 32 <BESTAND> 53 1581
7 TURBOC CFG 32 <BESTAND> 57 30
8 AA CPP 32 <BESTAND> 58 260
9 ABC CPP 32 <BESTAND> 59 1036
10 ASSIGN1 CPP 32 <BESTAND> 62 4257
11 CH24_2 CPP 32 <BESTAND> 71 834
12 sBSDISK1 C 32 <BESTAND> 73 911
13 sH24_25 C 32 <BESTAND> 75 594
14 sBSDISK C 32 <BESTAND> 77 840
Voer FNO in van het bestand dat u wilt herstellen 1
U wilt herstellen _2_INFO .C
Cylinder = 1, Head = 0, Sector = 1 Integreren........
Voer het pad en de bestandsnaam in om het bestand te herstellen: c:\windows\desktop\H2_INFO.C
Herstel voltooid!!!
|
Opmerkingen over codering:
De functie Display_Information is om de bestands- en directory-informatie te lezen en uit de root directory. In de structuur lezen we de 32 bytes informatie voor elk bestand of elke directory met root[32].
De unsigned integer arrays name[8] en ext[3] zijn voor bestands- of directorynamen voor DOS in 8.3 (Eight Dot Three) formaat. Op dezelfde manier is één byte voor kenmerk en twee bytes voor het starten van cluster. long unsigned int size; is om de bestandsgrootte van vier bytes op te slaan.
De functie _bios_disk leest de sector die is opgegeven door de structuur finfo en de status van de bewerking wordt opgeslagen in result.
Van alle 512 bytes aan informatie die door de functie _bios_disk worden gelezen tot aan het einde van de hoofddirectory , verzamelen we de informatie over de bestanden en directories die op de schijf zijn opgeslagen en geven deze weer op het scherm.
Het gehele getal file_no slaat het nummer van het bestand of de directory in de lijst op, beginnend bij 0. Over het algemeen is de grootte van de root directory 14 sectoren en begint de root directory over het algemeen bij Cylinder = 0, Head = 0 en Sector = 2 in het geval van 1,44 MB en 3½ floppy disk.
Als de gebruiker het teken 'M' of 'm' als invoer geeft, wordt de informatie van de volgende sector weergegeven. Als de keuze van de gebruiker 'R' of 'r' is, worden de herstelfuncties aangeroepen. De codering van de functie recover() is hieronder gegeven:
/* Functie om herstel voor het opgegeven bestand te starten */
void herstellen(unsigned int *root,unsigned int len)
{
void clear_the_line(unsigned int r); /* Functie om een rij op het scherm te wissen */
/* Functie om het opgegeven bestand te integreren */
void integreer(long unsigned int,unsigned int,
ongetekende int,ongetekende int);
ongetekend int file_no,i;
teken ch;
ongetekende int *loc;
ongetekend int cilinder,kop,sector;
ongetekende int start;
lange unsigned int grootte;
clear_the_line(21); /* Wis rijnummer 21 */
clear_the_line(22); /* Wis rijnummer 22 */
clear_the_line(23); /* Wis rijnummer 23 */
clear_the_line(24); /* Wis rijnummer 24 */
gotoxy(10,21);
cprintf("Voer het FNO in van het bestand dat u wilt herstellen");
scanf("%u",&file_no); /* Haal het bestandsnummer op dat moet worden
Hersteld */
loc=(root+(len*bestandsnummer/2));
/* Bevestig de bestandsnaam die hersteld moet worden */
gotoxy(10,22);
cprintf("U wilt herstellen");
voor(i=0;i<8;i++)
{
gotoxy(30+i,22);
cprintf("%c",*(loc+i)); /* Bestandsnaam */
}
gotoxy(38,22);
cprintf(".");
voor(i=0;i<3;i++)
{
gotoxy(39+i,22);
cprintf("%c",*(loc+8+i)); /* Bestandsextensie */
}
begin=*(loc+12);
/// Sorry, u hebt een map geselecteerd \\\
als(*(loc+11)==16)
{
gotoxy(5,23);
cprintf("Is een directory. Wilt u de
inhoud van deze map Y/N");
ch=halen();
als(ch==27)
voornaamst();
als(ch=='y' || ch=='Y')
{
/* Bereken Geomatrie */
bereken(start,&cilinder,&hoofd,§or);
/* Mapinhoud weergeven */
Display_Information (cilinder,kop,sector);
}
anders
/* Vraag opnieuw om een bestand en ga door met herstellen */
herstellen(root,len);
}
anders
{
grootte=*(loc+13);
/* Berekenen voor CHS-info */
bereken(start,&cilinder,&hoofd,§or);
/* Integreer het bestand */
integreer(grootte,cilinder,kop,sector);
}
}
Opmerkingen over codering:
De functie recover() is om de invoer van de gebruiker te krijgen om het herstel te starten. Het bestandsnummer dat als invoer door de gebruiker is gegeven om het bestand te herstellen, wordt opgeslagen in file_no.
Als het ingevoerde nummer betrekking heeft op de vermelding Directory, toont Display_Information() de inhoud van die directory. Anders worden de bestandsnaam en de extensie van bestandsnummer file_no op het scherm weergegeven om te bevestigen dat het bestand moet worden hersteld.
Om het opgegeven bestand te herstellen , worden de functies calculate() en integrate() binnen de functie aangeroepen. De codering van de functie calculate() is hieronder gegeven:
/* Functie om de CHS-geometrie voor het herstel te berekenen */
void berekenen(unsigned int start,unsigned int *cilinder,
ongetekende int *hoofd, ongetekende int *sector)
{
ongetekende int temp;
*cilinder=0;
*hoofd=1;
*sector=14;
als(start<5)
*sector=14+start;
anders
{
temperatuur = (begin-4)/18;
als(temp>0)
{
als(temp%2==0)
*hoofd=0;
anders
*hoofd=1;
*cilinder+=1+temp/2;
}
anders
{
*hoofd=0;
*cilinder=1;
}
*sector=(begin-4)%18;
}
/// Toon de CHS van het te herstellen bestand \\\
gotoxy(10,23);
cprintf("Cilinder = %u, Hoofd = %u, Sector = %u",
*cilinder,*kop,*sector);
}
Opmerkingen over codering:
De functie calculate() berekent de Cylinder-, Head- en Sector-informatie voor het te herstellen bestand. Na de berekening worden de Cylinder-, Head- en Sector-nummers op het scherm weergegeven.
De codering voor de functie integrate() is hieronder weergegeven:
/* Integreer bestand en sla het herstelde bestand op in het opgegeven pad en de opgegeven bestandsnaam */
void integreer(long unsigned int grootte,
ongetekende int cilinder,
ongetekende int hoofd,
ongetekende int sector)
{
void clear_the_line(unsigned int);
/* Functie om de sector op fouten te controleren */
int verify_the_sector(ongetekende int, ongetekende int,
ongetekende int);
int-status;
char buf[512],*Bestandsnaam_met_pad;
structuur diskinfo_t dinfo;
ongetekend int resultaat;
BESTAND *fp;
ongetekend int links,i;
ongetekende int sec;
/* Voer het doelpad en de bestandsnaam in om het herstelde bestand op te slaan */
gotoxy(2,24);
cprintf("Voer het pad en de bestandsnaam in om het bestand te herstellen: ");
fflush(stdin);
krijgt(Bestandsnaam_met_pad);
fp=fopen(Bestandsnaam_met_pad,"wb");
/* Als er een fout is opgetreden, wordt de foutmelding weergegeven en worden het invoerpad en de bestandsnaam opnieuw opgehaald */
als(fp==NULL)
{
gotoxy(5,25);
cprintf("Fout bij het openen van het bestand");
halen();
maak_de_lijn_vrij(24);
gotoxy(0,25);
cprintf(" ");
integreer(grootte,cilinder,kop,sector); /* Voer de
Bestemming opnieuw */
}
/* Als alles in orde is, integreer en schrijf */
gotoxy(50,23);
cprintf("Integreren........");
links= grootte%512;
sec = grootte/512;
sec++;
terwijl(sec>0)
{
dinfo.drive = 0x00; /* schijfnummer voor A: */
dinfo.head = head; /* schijfkopnummer */
dinfo.track = cilinder; /* spoornummer */
dinfo.sector= sector; /* sectornummer */
dinfo.nsectors=1; /* sectoraantal */
dinfo.buffer = buf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_READ, &dinfo);
/* Als er een fout optreedt tijdens het lezen van een sector */
als((resultaat & 0xff00) != 0)
{
gotoxy(5,25);
cprintf("leesfout Cilinder %u, Hoofd %u, Sector %u",
cilinder, kop, sector);
}
anders
{
als(sec==1)
{
voor(i=0;i<links;i++)
fputc(buf[i],fp); /* Schrijf de geïntegreerde
Informatie over het bestand */
}
anders
{
fwrite(buf,512,1,fp);
}
Opmerkingen over codering:
De functie integrate() is de daadwerkelijke module voor het uitvoeren van het herstel van het door de gebruiker opgegeven bestand in dit herstelprogramma .
De bestandsnaam met het bestemmingspad om het herstelde bestand op te slaan, wordt opgeslagen in de tekenaanwijzer *Bestandsnaam_met_pad. Als er een fout optreedt bij het openen van het bestemmingsbestand, wordt een foutmelding weergegeven en wordt de gebruiker opnieuw gevraagd om de bestemming in te voeren.
De functie _bios_disk(_DISK_READ, &dinfo); leest de gegevens van het bestand uit het gegevensgebied van de schijf sector voor sector, gespecificeerd door de structuur dinfo en opgeslagen in de gegevensbuffer buf. Deze gegevens van 512 bytes worden naar het doelbestand geschreven. Dit wordt herhaald totdat het volledige bestand is geïntegreerd.
De functie status=verify_the_sector (cylinder,head,sector); verifieert de sector die gelezen moet worden. Als de status = 10, vertegenwoordigt dit een slechte (0xA) sector. De codering van de functie is hieronder gegeven:
/// Controleer de sector. (Hier worden geen gegevens overgedragen) \\\
int verify_the_sector(ongetekende int c,ongetekende int h,ongetekende int s)
{
int-status;
char *buf;
vakbond REGS in, uit;
structuur SREGS sg;
in.h.ah = 0x04; /* Functie Nummer */
in.h.al = 1; /* Aantal te verifiëren sectoren*/
in.h.dl = 0x00; /* Schijfnummer voor A: */
in.h.ch = c; /* Cilindernummer */
in.h.dh = h; /* Hoofdnummer */
in.h.cl = s; /* Sectornummer */
in.x.bx = FP_OFF(buf);/* Verschuiving */
sg.es = FP_SEG(buf); /* Segmenteren */
int86x(0x13,&in,&uit,&sg); /* Functie 4H aanroepen
vanaf INT 13H */
als(uit.x.cvlag)
{
status=uit.h.ah;
}
terugkeer(status);
}
Opmerkingen bij codering:
De functie verify_the_sector() controleert de sector die door de functie _bios_disk() wordt gelezen en retourneert de status van de bewerking. De functie gebruikt INT 13H en functie 4H om de sector te controleren.
*buf — gegevensbuffer, 0x04 — functienummer gespecificeerd door in.h.ah = 0x04; en in.h.al = 1; geeft aan dat er telkens één sector gecontroleerd moet worden. in.h.dl = 0x00; gebruikt voor floppy disk drive nummer A:, c,h en s zijn cilinder-, kop- en sectornummers .
De functie int86x() wordt gebruikt om INT 13H (functie 4H) aan te roepen met segmentregisterwaarden . De status van de bewerking wordt geretourneerd als een geheel getal.
De functie clear_the_line() wist de opgegeven regel op het scherm. De functiecodering is als volgt:
/* Functie om een regel op het scherm te wissen voor het opgegeven regelnummer */
void clear_the_line(ongetekende gehele tekenreeks)
{
kolom met ongetekende gehele getallen;
/* Er staan 80 kolommen op een rij */
voor(kolom=1;kolom<=80;kolom++)
{
gotoxy(kolom,rij);
cprintf(" "); /* Wissen met " " */
}
}
Opmerkingen bij codering:
Deze functie wordt gebruikt om de opgegeven regel op het scherm te wissen . De functie wordt aangeroepen met het regelnummer dat van het scherm moet worden verwijderd.
