Hoofdstuk – 11
Back-upkopieën maken
Waarom heb je back-ups nodig?
"Voorkomen is beter dan genezen." Back-up is ook een belangrijk onderdeel van het voorkomen van gegevensrampen. Het kan ons helpen bij het voorkomen van schijfstoringen of andere vormen van gegevensverlies. In dit hoofdstuk bespreken we hoe u gegevens kunt herstellen, zelfs na ernstige schijffouten, door gebruik te maken van eerder gemaakte back-ups.
Herstel met behulp van eerder opgeslagen back-ups is bijna altijd tot 100 procent mogelijk. In sommige specifieke gevallen kunnen verschillende soorten schijffouten echter tot verschillen in herstelresultaten leiden.
Het herstellen van gegevens met behulp van back-ups is een eenvoudig, snel en betrouwbaar proces dat de beste resultaten kan opleveren. Het herstellen van gegevens zonder back-ups is echter complex, verwarrend en kan veel tijd kosten. Bovendien zijn we in veel gevallen bang dat we niet 100 procent van de gegevens terugkrijgen.
Wanneer en wat reserveren
Er zijn verschillende gebieden op de schijf die één keer of met verschillende tussenpozen gekopieerd moeten worden. De volgende tabel geeft een overzicht van de stappen die nodig zijn voor een volledige back-up. Zo kunt u bepalen wat u wanneer en wanneer moet back-uppen:
| Wat moet er gereserveerd worden |
Wanneer is een back-up noodzakelijk? |
| MBR-back-up |
Na FDISK. MBR wordt gemaakt door de DOS-opdracht FDISK. U kunt een back-up maken van MBR na FDISK, maar zelfs na het FORMATTEREN van partities die door FDISK zijn gemaakt, blijft MBR ongewijzigd. |
| DBR-back-up |
Maak na het formatteren een DBR-back-up voor elke logische schijf. |
| Maak een back-up van FAT-vermeldingen en -mappen. |
FAT- en mapvermeldingen veranderen telkens wanneer u bestanden of mappen aanmaakt of verwijdert. Daarom is het raadzaam om dagelijks een back-up te maken. |
| Back-up van gebruikersgegevens |
Moet regelmatig gedaan worden. Bij dit type back-up wordt er een schijfkopie gemaakt. Dit kost echter veel tijd, maar de meeste bedrijven die zeer gevoelige gegevens op hun schijven hebben staan, besteden graag hun tijd aan het maken van een schijfkopie. Op die manier kunnen ze een back-up maken van alle hierboven beschreven informatie. |
Daarnaast dient u een noodopstartdiskette voor het systeem te maken. Mocht er iets misgaan met de gegevens op uw harde schijf, dan kunt u uw systeem opstarten met behulp van deze floppydisk en de schijf analyseren op fouten.
Back-up maken van MBR (Master Boot Record) en het gebruik ervan
De master boot record (MBR), soms ook wel master partition table (MPT) genoemd, bevat een klein programma voor het laden en uitvoeren van de actieve (of opstartbare) partitie vanaf de harde schijf. Het master boot record bevat informatie over alle vier de primaire partities.
Voor een gedetailleerde bespreking van MBR, zie het hoofdstuk "Een logische benadering van schijven en besturingssystemen", dat eerder in dit boek is besproken.
MBR bevindt zich in absolute sector 0 of we kunnen zeggen in cilinder 0, kop 0 en sector 1. Het wordt op de harde schijf aangemaakt door het uitvoeren van de DOS-opdracht FDISK.EXE.
Waarom een backup maken van MBR:
Met MBR krijgt de opstartsector van de actieve partitie controle wanneer het systeem opstart.
Na de Power-On Self-Test (POST) laadt het BIOS de MBR (Master Boot Record) van de harde schijf in het geheugen en voert deze vervolgens uit. Eerst controleert de MBR de harde schijf op een actieve partitie, laadt vervolgens de DOS-opstartrecord (DBR) in het geheugen en draagt de besturing over aan de opstartcode van het besturingssysteem. Vervolgens laadt de opstartrecordcode van het besturingssysteem de rest van het besturingssysteem in het geheugen.
We kunnen dus zeggen dat als de MBR van de schijf beschadigd is, de harde schijf praktisch dood is en het systeem helemaal niet meer kan opstarten of het besturingssysteem kan uitvoeren. In deze toestand zijn alle gegevens op de harde schijf niet meer toegankelijk. Foutmeldingen worden doorgaans als volgt weergegeven:
"Ongeldige partitietabel" "Fout bij het laden van het besturingssysteem" "Besturingssysteem ontbreekt"
Wat kan er hersteld worden met een MBR-back-up?
Door een back-up van MBR te maken, kunt u de bovenstaande foutmeldingen verhelpen. Met een back-up kunt u de volgende problemen oplossen:
- Fout bij het laden van het besturingssysteem vanwege een beschadigde IPL (initial program loader)
- Verloren primaire partitie(s)
- Corrupte partitie-informatie
- Verkeerd magisch getal
Een programma schrijven om een MBR-back-up te maken:
/* Programma voor het maken van een MBR-back-up */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo; /* Structuur voor opslag
schijfparameterinformatie */
resultaat int;
aantal gehele getallen=0;
char bestandsnaam[80]; /* Slaat de opgegeven bestandsnaam op
Gebruiker */
static char dbuf[512]; /* Gegevensbuffer van 512 bytes */
BESTAND *fp;
dinfo.drive = 0x80; /* schijfnummer voor eerste harde schijf
Schijf */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
printf("\n Voer de bestandsnaam en het pad in om de
Back-up van MBR \n ");
krijgt(bestandsnaam);
// Open het bestand om de MBR-back-up op te slaan \\
als((fp=fopen(bestandsnaam,"wb"))==NULL)
{
printf("Kan bestand niet aanmaken, druk op een toets om
Uitgang...");
halen();
uitgang(0);
}
printf("Proberen te lezen van harde schijf :\n");
//// Lees de opgegeven schijfsector \\\\
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
printf("Schijf gelezen van harde schijf:
succesvol.\n");
/// Schrijf 512 bytes van MBR naar het bestand \\\\
terwijl(aantal<512)
{
fprintf(fp,"%c",dbuf[aantal] & 0xff );
tellen++;
}
fsluiten(fp);
}
anders
printf("Kan harde schijf niet lezen, status = 0x%02x\n", resultaat);
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 = 0x80 |
Hiermee wordt de fysieke schijf 80H aangegeven , de eerste harde schijf. |
| 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 een leesbewerking = 1 |
| dinfo.buffer = dbuf |
Gegevensbuffer voor de bewerking |
- Open een bestandsstroom met door de gebruiker opgegeven bestandsnaam en pad om de back-up van MBR van exact 512 bytes op te slaan. De bestandsnaam en het pad worden opgeslagen in de tekenreeks bestandsnaam.
- _bios_disk(_DISK_READ, &dinfo) leest de eerste sector van de harde schijf (80H), 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.
Programma om de MBR te herstellen vanuit een back-up:
Als de MBR op welke manier dan ook beschadigd is, helpt het volgende programma om de MBR te herstellen.
Houd er altijd rekening mee dat illegaal gebruik of gebruik in gebrek aan kennis van dit programma uw gegevens op de harde schijf kan vernietigen en de volledige gegevens ontoegankelijk kan maken. U moet zeker weten wat u gaat doen. Anders kunt u het probleem nog ingewikkelder maken.
Programma om de MBR te herstellen vanuit een back-up:
De codering van het programma is als volgt:
/* Programma om de back-up van MBR te herstellen vanuit het back-upbestand */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
int resultaat;
int aantal=0;
char bestandsnaam[80]; /* Slaat de opgegeven bestandsnaam op
door Gebruiker */
static char dbuf[512]; /* Gegevensbuffer van 512 bytes
*/
BESTAND *fp;
/* Haal de gebruikersinvoer op voor het pad naar het MBR-back-upbestand */
printf("\n Voer de bestandsnaam en het pad van het back-upbestand in
MBR \n ");
krijgt(bestandsnaam);
als((fp=fopen(bestandsnaam,"rb"))==NULL)
{
printf("Kan back-upbestand niet openen, druk op een toets
om af te sluiten...");
halen();
uitgang(1);
}
/* MBR-gegevens moeten exact 512 bytes lang zijn */
terwijl(aantal<512)
{
fscanf(fp,"%c",&dbuf[aantal]);
tellen++;
}
fsluiten(fp);
printf("Proberen te schrijven naar harde schijf :\n");
dinfo.drive = 0x80; /* schijfnummer voor Eerste
Harde schijf */
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)
{
printf("De back-up van MBR terugzetten naar de schijf
Sector: succesvol.\n");
}
anders
printf("Kan niet schrijven op harde schijf, status =
0x%02x\n", resultaat);
retourneer 0;
}
Opmerkingen over programmacodering:
In de hierboven 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 op de eerste sector van de schijf willen schrijven, zal de locatie van de sector als volgt zijn:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x80 |
Hiermee wordt de fysieke schijf 80H aangegeven , de eerste harde schijf. |
| 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 |
- De bestandsnaam en het pad van de Backup van MBR, opgegeven door de gebruiker, worden opgeslagen in de karakterarray bestandsnaam. Houd er rekening mee dat de MBR-informatie exact 512 bytes moet zijn.
- _bios_disk(_DISK_WRITE, &dinfo) schrijft de gegevens naar de eerste sector van de harde schijf (80H), 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.
Back-up van DBR (DOS Boot Record) en het gebruik ervan
Na de partitietabel is de DOS Boot Record (DBR), soms ook wel DOS Boot Sector genoemd, de tweede belangrijkste informatie op uw harde schijf.
Voor een gedetailleerde studie over DBR, zie het hoofdstuk, “ Logische benadering van schijven en besturingssystemen ”, eerder in dit boek besproken.
De eerste logische sector van elke DOS-partitie bevat een DOS Boot Record (DBR) of DOS Boot Sector. De taak van de DBR is om het besturingssysteem van de harde schijf in het hoofdgeheugen van de computer te laden en de controle van het systeem aan het geladen programma te geven.
De DOS Boot Record (DBR) voor de eerste partitie op een harde schijf bevindt zich meestal op Absolute Sector 63 (de 64e sector op de schijfeenheid) of in CHS-vorm kunnen we zeggen C–H–S = 0–1–1 voor de meeste schijven.
Deze locatie kan echter variëren afhankelijk van de SPT (Sectors per Track) van de Drive. Bijvoorbeeld, op een oude 245MB drive met slechts 31 SPT, bevond de Boot Record zich op de 32e sector (Absolute Sector 31).
De DBR wordt gemaakt door de FORMAT-opdracht van DOS, nadat de partitionering is uitgevoerd met de FDISK-opdracht. De sector waarop DBR zich bevindt, wordt logische sector 1 van die specifieke partitie voor DOS. Het sectornummer dat door DOS wordt gebruikt, begint bij de fysieke sector waarop DBR zich bevindt.
De DBR bevat een klein programma dat wordt uitgevoerd door het Master Boot Record (MBR) Executable-programma. Alle DOS-partities bevatten de programmacode om de machine op te starten, d.w.z. het besturingssysteem te laden, maar alleen die partitie krijgt controle van de Master Boot Record die is opgegeven als actieve partitie, in de partitietabelinvoer.
Waarom DBR back-uppen:
De DBR bevat belangrijke informatie over de schijfgeometrie. Deze informatie bevindt zich in de eerste sector van elke partitie, zoals:
- Jumpcode + NOP
- OEM-naam en versie
- Bytes per sector
- Sectoren per cluster
- Gereserveerde sectoren
- Aantal kopieën van FAT
- Maximale rootdirectory-ingangen (maar niet beschikbaar voor FAT32)
- Aantal sectoren in partitie kleiner dan 32 MB (daarom niet beschikbaar voor FAT32)
- Media Descriptor (F8H voor harde schijven)
- Sectoren per FAT (in oudere FAT-systemen en niet beschikbaar voor FAT32)
- Sectoren per spoor
- Aantal hoofden
- Aantal verborgen sectoren in partitie
- Aantal sectoren in partitie
- Aantal sectoren per FAT
- FAT-informatiedescriptorvlaggen
- Versie van FAT32-station
- Clusternummer van het begin van de rootdirectory
- Sectornummer van de bestandssysteeminformatiesector
- Sectornummer van de back-upbootsector
- Gereserveerd
- Logisch schijfnummer van partitie
- Uitgebreide handtekening (29H)
- Serienummer van partitie
- Volumenaam van partitie
- FAT-naam
- Uitvoerbare code
- Uitvoerbare marker of magisch getal (AAH 55H)
Over het algemeen worden de volgende foutmeldingen op het scherm weergegeven:
“Schijf opstarten mislukt”
“Geen systeemschijf of schijffout”
“Ongeldige systeemschijf of schijf-I/O-fout”
“Plaats de schijf terug en druk op een willekeurige toets…”
Wat kan er hersteld worden met een DBR-back-up?
De back-up van DBR kan u helpen om van de bovenstaande foutmeldingen af te komen. Deze foutmeldingen op het scherm wachten tot de gebruiker een opstartbare diskette met de hierboven genoemde programma's in de floppy drive plaatst en op een toets drukt.
De drive zou toegankelijk moeten zijn als u het systeem opstart vanaf de opstartbare floppy of CD. Hoewel de harde schijf niet opstartbaar is, zou dat over het algemeen geen invloed moeten hebben op de toegang tot de gegevens op de diskdrive. Nadat u het systeem hebt opgestart met de opstartbare disk, kunt u de gegevens benaderen.
Door de back-up van DBR te herstellen, kunt u de hierboven genoemde problemen oplossen.
Programma's voor het maken en herstellen van DBR-back-ups:
De programma's voor het maken van back-ups van DBR's en het terugzetten ervan zijn vrijwel gelijk aan de programma's voor MBR-back-up en -herstel.
Als u bijvoorbeeld programma's gaat schrijven voor het maken van een back-up van de DBR van het eerste logische station van de schijf en deze wilt terugzetten, worden de parameters die zijn opgegeven door de dinfo-structuur als volgt gewijzigd:
| Parameter |
Wat het betekent |
| dinfo.drive = 0x80 |
Het geeft de fysieke schijf 80H aan , dat is de eerste harde schijf> |
| dinfo.hoofd = 1 |
Het wijst naar hoofdnummer 1 |
| 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 |
Hier zien we dat alleen de locatie van de sector om te lezen/schrijven is gewijzigd. Hier wordt de CHS gegeven als 0-1-1 aangezien de DBR van de eerste logische schijf hier is opgeslagen.
Volledige schijfkopie
Dit type back-up wordt tegenwoordig steeds populairder en is het meest geliefd bij organisaties die zeer gevoelige gegevens in hun systemen hebben. Deze mensen kunnen geen enkel risico lopen op ook maar één procent dataverlies.
Dergelijke organisaties maken regelmatig back-ups als volledige schijfkopie. Hoewel het wat tijd kost, geeft het u de zekerheid dat u niets mist. Vanwege de toenemende populariteit hebben programmeurs hun best gedaan om de software voor het maken van schijfkopieën steeds sneller te maken om de tijd die het maken van de kopie in beslag neemt, te minimaliseren.
Disk imaging is een goed idee omdat je door er maar een paar tientallen minuten aan te besteden de geruststelling hebt dat je een backup hebt van alles in je zak. Alle factoren zoals MBR, BDR, FAT's, root directories worden gekopieerd naar de bestemmingsschijf zoals ze zijn.
Wat we nodig hebben voor disk imaging is een Identieke (of bijna Identieke) bestemmingsharde schijf, aan onze bronharde schijf waarop we onze waardevolle data hebben. Eén ding is altijd in gedachten te houden: de bestemmingsschijf mag niet kleiner zijn dan de bronschijf.
Nadat u de volledige image hebt gemaakt, kunt u het systeem opstarten vanaf de doelschijf waarop u de schijfimage hebt gemaakt. Normaal gesproken krijgt u dan alle gegevens zoals ze zijn.
Het schrijven van het programma voor volledige schijfkopie
Het programma voor disk imaging is hierna gegeven. Het programma gebruikt de INT 13H extensies en kan daarom ook grote schijven ondersteunen.
Het programma maakt een image van de eerste fysieke harde schijf (0x80) naar de tweede fysieke harde schijf (0x81). Voordat u de back-upimage maakt, moet u er dus rekening mee houden dat alle gegevens op de doelschijf (0x81) worden overschreven door de gegevens op de bronschijf (0x80) in een sector-voor-sectorpatroon.
De codering van het programma is als volgt:
/* Programma om een image te maken van de eerste harde schijf (0x80) naar de tweede harde schijf (0x81) */
#include<stdio.h>
#include<dos.h>
#include<conio.h>
/* Structuur die gebruikt moet worden door de getdrivegeometry-functie met behulp van de INT 13H-extensie, functienummer 0x48. */
structuur geometrie
{
unsigned int size ; /* (call) grootte van Buffer */
niet-ondertekende int-vlaggen; /* Informatievlaggen */
ongetekende lange cyl; /* Aantal fysieke
Cilinders op aandrijving */
ongetekende lange hoofden ;/* Aantal fysieke
Hoofden op Drive */
unsigned long spt ; /* Aantal fysieke
Sectoren per spoor */
ongetekende lange sectoren[2] ; /* Totaal aantal
Sectoren op Drive */
ongetekende int bps ; /* Bytes per sector */
} ;
/* Structuur van het schijfadrespakketformaat, te gebruiken door de functies readabsolutesectors en writeabsolutesectors */
struct diskadderpakket
{
char packetsize ; /* Grootte van het pakket, over het algemeen 10H */
char gereserveerd ; /* Gereserveerd (0) */
int blockcount ; /* Aantal blokken om over te dragen */
char far *bufferadres ; /* adres om over te dragen
Buffertje */
ongetekend lang bloknummer[2] ; /* Beginnend Absoluut
Bloknummer */
} ;
///// Functie om schijfparameters op te halen \\\\\
ongetekende lange getdrivegeometry (int drive)
{
vakbond REGS i, o;
structuur SREGS s;
structuurgeometrie g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
ihah = 0x48 ; /* Functienummer 0x48 van INT 13H
Extensies Zie de opmerkingen
Onderstaand */
ihdl = drive; /* Schijfnummer */
ixsi = FP_OFF ( (void ver*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Roep het opgegeven functie nummer van de INT 13H extensie aan met Segment Register Waarden */
int86x ( 0x13, &i, &o, &s );
printf("\n Hoofd = %lu, Sectoren per spoor = %lu, Cilinder =
%lu\n", g.heads, g.spt, g.cyl);
/* Als de Get Drive Geometry-functie mislukt, wordt een foutmelding weergegeven en wordt het programma afgesloten */
als(g.spt==0)
{
printf("\n Get Drive Geometry-functie mislukt....");
printf("\n Extensies worden niet ondersteund, druk op een willekeurige toets om
Uitgang...");
halen();
uitgang(1);
}
return *g.sectors; /* Retourneert het aantal sectoren
op Drive */
}
////// Begin van hoofd \\\\\\
leeg hoofd()
{
ongetekende lange lus=0, Sectoren_in_HDD1=0, Sectoren_in_HDD2=0;
unsigned char buffer[61440]; /* Gegevensbuffer van 61440
Bytes om 120 sectoren van 512 bytes tegelijk te lezen/schrijven om tijd te besparen. */
keuze van karakter;
clrscr();
/* Als het totale aantal aangesloten harde schijven minder dan twee bedraagt, wordt een foutmelding weergegeven en wordt het programma afgesloten. */
als(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n U moet minimaal twee harde schijven hebben
Aangesloten op uw computer om dit uit te voeren");
printf("\n Programma. Druk op een toets om af te sluiten... ");
halen();
uitgang(1);
}
/// Haal parameters op van de eerste harde schijf (0x80) \\\
Sectoren_in_HDD1 = getdrivegeometry (0x80);
printf("Totaal aantal sectoren op de eerste harde schijf = %lu\n\n",
Sectoren_in_HDD1);
/// Parameters van tweede Hsrd-schijf ophalen (0x81) \\\
Sectoren_in_HDD2 = getdrivegeometry (0x81);
printf("Totaal aantal sectoren op tweede harde schijf = %lu\n\n",
Sectoren_in_HDD2);
/// Eerst bevestigen, dan verdergaan \\\
printf("\n Alle gegevens op de tweede harde schijf worden
kwijt !!!");
printf("\n Druk op \'Y\' om door te gaan, anders een willekeurige toets om
Uitgang... ");
keuze = getche();
schakelaar(keuze)
{
geval 'y':
geval 'Y':
pauze;
standaard:
uitgang(0);
}
/* Bestemming mag niet kleiner zijn dan de Bron */
als(Sectoren_in_HDD2<Sectoren_in_HDD1)
{
printf("\n\n De doelschijf mag niet kleiner zijn
dan Bronschijf");
printf("\n Druk op een toets om af te sluiten...");
halen();
uitgang(0);
}
/* Als alles in orde is, kopieer dan alle sectoren van de bronschijf naar de doelschijf */
gotoxy(10,15);printf("Absolute sector kopiëren: ");
for(loop=0;loop< =Sectoren_in_HDD1;loop=loop+120)
{
readabsolutesectors (0x80, lus, 120, buffer);
writeabsolutesectors ( 0x81, lus, 120, buffer );
gotoxy(36,15); printf("%ld",loop);
als(kbhit())
{
uitgang(0);
}
}
//// Toon het bericht van voltooiing \\\
printf("\n\n Schijfkopie maken is nu voltooid, druk op een willekeurige toets
Om af te sluiten...");
halen();
}
//// Einde van hoofdpagina
Reacties op codering:
Bij het coderen van het eerder gegeven programma, voor schijfimaging, gaan we verder met het uitvoeren van de volgende taken:
- De structuur, geometrie wordt gebruikt door de functie getdrivegeometry met behulp van INT 13H-extensie, functienummer 0x48. Voor een gedetailleerde beschrijving van INT 13H-extensies, zie het hoofdstuk "Grote harde schijven verwerken", eerder in dit boek besproken.
De gegevenstypen die verschillende parameters van de schijf vertegenwoordigen, hebben de volgende betekenissen:
| Gegevenstype |
Grootte in bytes |
Beschrijving |
| ongetekende int- grootte |
2 bytes |
Grootte van de buffer |
| ongetekende int- vlaggen |
2 bytes |
Informatievlaggen |
| ongetekende lange cilinder |
4 bytes |
Aantal fysieke cilinders op de aandrijving |
| ongetekende lange hoofden |
4 bytes |
Aantal fysieke koppen op schijf |
| ongetekende lange spt |
4 bytes |
Aantal fysieke sectoren per spoor |
| ongetekende lange sectoren[2] |
8 Bytes |
Totaal aantal sectoren op schijf |
| ongetekende int bps |
2 bytes |
Bytes per sector |
- De structuur diskaddrpacket wordt gebruikt door de functies readabsolutesectors en writeabsolutesectors. De indeling van het disk address packet is gegeven in de volgende tabel:
| Gegevenstype |
Grootte in bytes |
Beschrijving |
| char pakketgrootte |
1 byte |
Grootte van het pakket, over het algemeen 10H |
| char gereserveerd |
1 byte |
Gereserveerd (0) |
| int blokaantal |
2 bytes |
Aantal blokken om over te dragen |
| char ver *bufferadres |
4 bytes |
adres naar Transfer Buffer |
| ongetekend lang bloknummer[2] |
4 bytes |
Begin absoluut bloknummer |
- De functie getdrivegeometry wordt gebruikt om de parameters van de opgegeven Drive op te halen. De functie getdrivegeometry gebruikt functienummer 0x48 van INT 13H Extensions.
De betekenis van de parameters wordt in de onderstaande tabel beschreven:
| Parameter |
Wat het betekent |
| ja = 0x48 |
Functienummer 0x48 van INT 13H-extensies |
| ihdl = rijden |
Schijfnummer |
| ixsi = FP_OFF ( (void ver*)&g ) |
ds:si adres naar buffer voor schijfparameters zoals eerder besproken |
| s.ds = FP_SEG ( (void ver*)&g ) |
ds:si adres naar buffer voor schijfparameters zoals eerder besproken |
De functie int86x(0x13, &i, &o, &s) roept de interrupt 13H aan met segmentregisterwaarden. De functie getdrivegeometry retourneert het totale aantal op de schijf.
- In de functie main() retourneert (char)peekb(0x0040, 0x0075); (de functie peekb is gedefinieerd in DOS.H) het aantal harde schijven dat aan het systeem is gekoppeld.
Het aantal harde schijven dat op het systeem is aangesloten, wordt weergegeven door de byte die is opgeslagen op geheugenlocatie 0040H:0075H (Segment 0040H: Offset 0075H). Als het aantal harde schijven dat op het systeem is aangesloten minder dan twee is, geeft het programma een foutmelding en wordt het afgesloten.
Sectors_in_HDD1 = getdrivegeometry (0x80); haalt de parameters van de eerste harde schijf (0x80) op en retourneert het totale aantal sectoren op de eerste harde schijf.
Op dezelfde manier haalt Sectors_in_HDD2 = getdrivegeometry (0x81) de parameters van de tweede harde schijf (0x81) op en retourneert het totale aantal sectoren op de tweede harde schijf.
Na bevestiging door de gebruiker om door te gaan met het maken van afbeeldingen, controleer eerst de voorwaarde dat de grootte van de bron-harde schijf niet groter mag zijn dan de grootte van de doel-harde schijf. Als de bestemming kleiner is, geef dan de foutmelding weer en sluit af.
Als alles goed gaat, kopieer dan de sectoren van de bronschijf naar de doelschijf. Hier lezen en schrijven we 61440 bytes (120 sectoren met elk 512 bytes) tegelijk om het imagingproces sneller te maken.
Als u meer sectoren tegelijk wilt gebruiken, zelfs voorbij de limiet van 64K, kunt u dit doen door "huge Pointer" te gebruiken in een groot geheugenmodel. Het voorbeeld van de specificatie is als volgt:
char enorme array[100000L];
- De functie readabsolutesectors (0x80, loop, 120, buffer); leest de 120 sectoren van de eerste harde schijf (0x80), beginnend bij het sectornummer dat is opgegeven door de unsigned long integer loop en slaat de gegevens op in de gegevensbuffer.
- De functie writeabsolutesectors (0x81, loop, 120, buffer); schrijft de gegevens van de gegevensbuffer naar 120 sectoren van de tweede harde schijf (0x81), beginnend bij het sectornummer dat is opgegeven door de unsigned long integer loop.
De codering van de functies readabsolutesectors ( ) en writeabsolutesectors ( ) is als volgt gegeven:
//// Functie om absolute sector(en) te lezen \\\\
int readabsolutesectors ( int drive,
ongetekend lang sectornummer,
int aantal sectoren,
leeg *buffer)
{
vakbond REGS i, o;
structuur SREGS s;
structuur diskaddrpacket pp;
pp.packetsize = 16 ; /* pakketgrootte = 10H */
pp.reserved = 0 ; /* Gereserveerd = 0 */
pp.blockcount = numofsectors ; /* Aantal sectoren
lezen */
/* voor gegevensbuffer */
pp.bufferadres = (char far*) MK_FP ( FP_SEG((void
ver*)buffer), FP_OFF((void ver*)buffer));
pp.blocknumber[0] = sectornummer ; /* Sectornummer
lezen */
pp.blocknumber[1] = 0 ; /* Bloknummer */
ihah = 0x42 ; /* Functie Nummer*/
ihdl = drive ; /* Fysiek schijfnummer */
ixsi = FP_OFF ( (void far*)&pp ); /* ds:si voor
bufferparameters */
s.ds = FP_SEG ( (void ver*)&pp ) ; /* ds:zeg voor
bufferparameters */
/* Roep de opgegeven functie van INT 13H aan met segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s );
als (oxcflag==1)
retourneer 0 ; /*mislukt */
anders
retour 1 ; /* succes */
}
//// Functie om absolute sector(en) te schrijven \\\\
int writeabsolutesectors ( int drive,
ongetekend lang sectornummer,
int aantal sectoren,
leeg *buffer)
{
vakbond REGS i, o ;
structuur SREGS s;
structuur diskaddrpacket pp;
pp.pakketgrootte = 16 ; /* Pakketgrootte = 10H */
pp.gereserveerd = 0 ; /* Gereserveerd = 0 */
pp.blockcount = aantal sectoren; /* Aantal sectoren
zal geschreven worden */
/* voor gegevensbuffer */
pp.bufferadres = (char far*) MK_FP ( FP_SEG((void
ver*)buffer), FP_OFF((void ver*)buffer));
pp.blocknumber[0] = sectornummer ;/* Sectornummer
zal geschreven worden */
pp.bloknummer[1] = 0 ; /* Bloknummer = 0 */
ik heb = 0x43 ; /* Functie nummer */
ihal = 0x00 ; /* Vlaggenvermelding, zie
opmerkingen */
ihdl = rijden; /* Fysiek schijfnummer*/
/* ds:si voor bufferparameters */
ixsi = FP_OFF ((void ver*)&pp);
/* ds:si voor bufferparameters */
s.ds = FP_SEG ( (void ver*)&pp ) ;
/* Roep de opgegeven INT 13H-functie aan met de segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s );
als (oxcflag == 1)
retourneer 0 ; /* mislukking */
meer
retour 1 ; /* succes */
}
Opmerkingen bij codering:
De parameters die door beide functies worden gebruikt, hebben de volgende betekenissen:
| Parameter |
Grootte in bytes |
Beschrijving |
| pp.pakketgrootte = 16 ; |
1 byte |
Pakketgrootte = 10H |
| pp.gereserveerd = 0 ; |
1 byte |
Gereserveerd = 0 |
| pp.blockcount = aantal sectoren; |
2 bytes |
Aantal te lezen sectoren |
| pp.bufferadres = (char ver*) MK_FP ( FP_SEG((void ver*)buffer), FP_OFF((void ver*)buffer)); |
----- |
voor databuffer of verzendbuffer |
| pp.blocknumber[0] = sector_nummer; |
4 bytes |
Sectornummer om te lezen/schrijven (meestal hebben we alleen deze nodig). Alleen apart. Ondersteunt maximaal 2,1 terabyte. |
| pp.block_number[1] = 0 ; |
4 bytes |
Bloknummer. Gebruik dit als u toegang wilt tot een schijf die groter is dan 2,1 terabyte. |
| ik heb gelijk = 0x42; of ihah = 0x43; |
2 bytes |
Functie Aantal extensies INT 13H |
| ihal = 0x00; |
1 byte |
Schrijfvlaggen worden alleen gebruikt bij schrijffuncties. 00H en 01H worden gebruikt voor schrijven zonder verificatie en 02H wordt gebruikt voor schrijven met verificatie. |
| ihdl = rijden; |
2 bytes |
Fysiek schijfnummer |
| ixsi = FP_OFF ((void ver*)&pp); |
------ |
ds:si voor bufferparameters |
| s.ds = FP_SEG ( (void ver*)&pp ) ; |
------ |
ds:si voor bufferparameters |
| int86x ( 0x13, &i, &o, &s ); |
------ |
Roep de opgegeven INT 13H-functie aan met de segmentregisterwaarden |
