Hoofdstuk – 11
Back-ups maken
Waarom back-ups maken?
“Voorkomen is altijd beter dan genezen”. Het maken van back-ups is ook een belangrijk onderdeel van het voorkomen van gegevensrampen, wat ons kan helpen de schijfcrash of elk ander type gegevensverlies te overwinnen. In dit hoofdstuk zullen we bespreken hoe we de gegevens kunnen herstellen, zelfs na een aantal ernstige schijfcrashes, alleen met behulp van eerder gemaakte back-ups.
Het herstel dat wordt gedaan door de eerder opgeslagen back-ups is bijna altijd tot 100 procent, maar de verschillende typen schijfcrashes kunnen in bepaalde gevallen de variatie in de herstelresultaten veroorzaken.
Het herstellen van gegevens met behulp van back-ups is vrij eenvoudig, snel en betrouwbaar en kan de beste resultaten opleveren, terwijl het herstellen van gegevens zonder back-ups een moeilijk, gecompliceerd proces kan zijn dat veel tijd in beslag neemt en zelfs dan zijn we bang voor in verschillende gevallen niet de 100 procent gegevens krijgen.
Wanneer en wat een back-up maken
Er zijn verschillende gebieden op de schijf waarvan eenmalig of met verschillende tijdsintervallen een back-up moet worden gemaakt. De volgende tabel geeft het idee van volledige back-upmaatregelen en helpt om erachter te komen wanneer en wat een back-up moet worden gemaakt:
| What to Backup |
When to be Backed up |
| Backup of MBR |
Once after FDISK. The MBR is Created By the FDISK command of DOS. You can take backup of MBR After FDISK, however even after the FORMAT of partitions created by FDISK, The MBR remains Unchanged. |
| Backup of DBR |
Back up the DBRs for each logical drive once, after FORMAT. |
| Backup of FAT and Directory entries. |
FAT and Directory Entries are changed every time when you create of delete files or directories. Therefore it is recommended that you should take backup daily. |
| Backup of User Data |
Should be taken regularly. This type of backup causes the disk imaging to take place. However it is time taking yet most of the companies which have very sensitive data in their disks like to spend their time on disk imaging because by doing this they can backup all of the information described above. |
Daarnaast moet u een Emergency Boot Floppy voor het systeem maken. Als er een ramp is met de gegevens op uw harde schijf, kunt u uw systeem opstarten met behulp van deze diskette en de schijf analyseren op fouten.
Back-up van MBR (Master Boot Record) en het gebruik ervan
De Master Boot Record (MBR) of soms de Master Partition Table (MPT) genoemd, bevat een klein programma om de actieve (of opstartbare) partitie te laden en te starten vanaf de harde schijf. De Master boot Record bevat informatie over alle vier de primaire partities.
Raadpleeg voor een gedetailleerde studie over MBR het hoofdstuk "Logische benadering van schijven en besturingssysteem", eerder in dit boek besproken.
De MBR bevindt zich op Absolute Sector 0 of we kunnen zeggen op cilinder 0, kop 0 en sector1. Het wordt gemaakt op de harde schijf door de opdracht FDISK.EXE van DOS uit te voeren.
Waarom een back-up maken van MBR:
MBR zorgt ervoor dat de opstartsector van de actieve partitie de besturing ontvangt wanneer het systeem wordt gestart.
Na de Power-On Self Test (POST) laadt het BIOS de MBR (Master Boot Record) van de harde schijf in het geheugen en voert het vervolgens uit. Eerst controleert de MBR de harde schijf op een actieve partitie, laadt vervolgens de DOS Boot Record (DBR) in het geheugen en geeft de controle over aan de opstartcode van het besturingssysteem en vervolgens laadt de opstartcode van het besturingssysteem de rest van het besturingssysteem in Geheugen.
Daarom kunnen we zeggen dat als de MBR van de schijf beschadigd is, de harde schijf bijna leeg is en het systeem helemaal niet in staat is om het besturingssysteem op te starten of uit te voeren. In een dergelijke toestand worden alle gegevens die op de harde schijf zijn opgeslagen, ontoegankelijk. Over het algemeen worden de foutmeldingen als volgt weergegeven:
“Ongeldige partitietabel” “Fout bij laden van besturingssysteem” "Ontbrekend besturingssysteem"
Wat kan worden hersteld met de back-up van MBR?
De back-up van MBR kan u helpen om de bovenstaande foutmeldingen te verwijderen. Met de back-up kunnen de volgende problemen worden verholpen:
- Fout bij laden van besturingssysteem, vanwege beschadigde IPL (Initial Program Loader)
- Verloren primaire partitie(s)
- Beschadigde partitie-informatie
- Ongeldig magisch nummer
Het programma schrijven om een back-up van MBR te maken:
/* Programma om een back-up te maken van MBR */
#include <bios.h>
#include <stdio.h>
int main(void)
{
struct diskinfo_t dinfo; /* Structure to Hold the
information of disk Parameters */
int result;
int count=0;
char filename[80]; /* Stores the File name given by
User */
static char dbuf[512]; /* Data Buffer of 512 Bytes */
FILE *fp;
dinfo.drive = 0x80; /* drive number for First Hard
Disk */
dinfo.head = 0; /* disk head number */
dinfo.track = 0; /* track number */
dinfo.sector = 1; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
printf("\n Enter The Filename and path to store the
Backup of MBR \n ");
gets(filename);
// Open het bestand om de MBR-back-up op te slaan \\
if((fp=fopen(filename,"wb"))==NULL)
{
printf("Could not Create File, Press any key to
Exit...");
getch();
exit(0);
}
printf("Attempting to read from Hard disk drive :\n");
//// Lees de gespecificeerde schijfsector \\\\
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Disk read from hard disk drive :
successful.\n");
/// Schrijf 512 bytes MBR naar het bestand \\\\
while(count<512)
{
fprintf(fp,"%c",dbuf[count] & 0xff );
count++;
}
fclose(fp);
}
else
printf("Cannot read Hard Disk drive, status = 0x%02x\n", result);
return 0;
}
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 van 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, is de locatie van de sector als volgt:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive. |
| dinfo.head = 0 |
It points to head number 0 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
>Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- Open een bestandsstroom van 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 het resultaat dat wordt gebruikt om het bericht voor een succesvolle bewerking weer te geven of om een foutmelding op het scherm weer te geven als er een fout optreedt.
Programma om de MBR te herstellen van een back-up:
Als de MBR op de een of andere manier beschadigd is, helpt het volgende programma om de MBR Back te herstellen.
Houd er altijd rekening mee dat het illegale gebruik of gebruik bij gebrek aan kennis van dit programma uw gegevens op de harde schijf kan vernietigen en de volledige gegevens ontoegankelijk kan maken. Je moet zeker weten wat je gaat doen. Anders kunt u het probleem nog ingewikkelder maken.
Programma om de MBR te herstellen van 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 main(void)
{
struct diskinfo_t dinfo;
int result;
int count=0;
char filename[80]; /* Stores the File name given
by User */
static char dbuf[512]; /* Data Buffer of 512 Bytes
*/
FILE *fp;
/* Verkrijg de gebruikersinvoer voor MBR-back-upbestandspad */
printf("\n Enter The Filename and path of Backup File of
MBR \n ");
gets(filename);
if((fp=fopen(filename,"rb"))==NULL)
{
printf("Could not open Backup File, Press any key
to Exit...");
getch();
exit(1);
}
/* MBR-gegevens moeten van Exact 512 Bytes zijn */
while(count<512)
{
fscanf(fp,"%c",&dbuf[count]);
count++;
}
fclose(fp);
printf("Attempting to Write to Hard disk drive :\n");
dinfo.drive = 0x80; /* drive number for First
Hard Disk */
dinfo.head = 0; /* disk head number */
dinfo.track = 0; /* track number */
dinfo.sector = 1; /* sector number */
dinfo.nsectors = 1; /* sector count */
dinfo.buffer = dbuf; /* data buffer */
result = _bios_disk(_DISK_WRITE, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Restoring the Backup of MBR to The Disk
Sector: successful.\n");
}
else
printf("Cannot Write on Hard Disk drive, status =
0x%02x\n", result);
return 0;
}
Opmerkingen over programmacodering:
In de hierboven gegeven programmacodering gaan we in principe stap voor stap verder met het uitvoeren van de volgende taken:
- dinfo verwijst naar de diskinfo_t-structuur die de informatie bevat van 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, is de locatie van de sector als volgt:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive. |
| dinfo.head = 0 |
It points to head number 0 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
- De bestandsnaam en het pad van Back-up van MBR, gegeven door de gebruiker, wordt opgeslagen in de tekenarray bestandsnaam. Houd er rekening mee dat de MBR-informatie exact 512 bytes moet zijn.
- _bios_disk(_DISK_WRITE, &dinfo) schrijft de gegevens op de eerste sector van de harde schijf (80H), gespecificeerd door dinfo.
- De geretourneerde status wordt opgeslagen in het resultaat dat wordt gebruikt om het bericht voor een succesvolle bewerking weer te geven 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) of soms DOS Boot Sector genoemd, de op één na belangrijkste informatie op uw harde schijf.
Raadpleeg voor een gedetailleerde studie over DBR 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 is meestal te vinden op Absolute Sector 63 (de 64e sector op de schijf) of in CHS-vorm kunnen we zeggen C–H–S = 0–1&ndash ;1 voor de meeste schijven.
Deze locatie kan echter variëren, afhankelijk van de SPT (Sectors Per Track) van de Drive. Op een oude schijf van 245 MB met slechts 31 SPT, bevond het opstartrecord zich bijvoorbeeld in de 32e sector (Absolute Sector 31).
De DBR wordt gemaakt met het FORMAT-commando van DOS, nadat het partitioneren is gedaan met het FDISK-commando. De sector waarop DBR zich bevindt, wordt logische sector 1 van die bepaalde partitie voor de DOS. Het door DOS gebruikte sectornummer gaat uit van de fysieke sector waarop DBR zich bevindt.
De DBR bevat een klein programma dat wordt uitgevoerd door het uitvoerbare programma Master Boot Record (MBR). Alle DOS-partities bevatten de programmacode om de machine op te starten, d.w.z. het besturingssysteem te laden, maar alleen die partitie wordt bestuurd door de Master Boot Record, die gespecificeerd is als actieve partitie, in de partitietabel.
Waarom een back-up maken van DBR:
De DBR bevat enkele belangrijke informatie over de schijfgeometrie. Deze informatie bevindt zich in de eerste sector van elke partitie, zoals:
- Sprongcode + NOP
- OEM-naam en versie
- Bytes per sector
- Sectoren per cluster
- Gereserveerde sectoren
- Aantal exemplaren van FAT
- Maximale invoer in rootdirectory (maar niet beschikbaar voor FAT32)
- Aantal sectoren in partitie kleiner dan 32 MB (dus niet beschikbaar voor FAT32)
- Mediadescriptor (F8H voor harde schijven)
- Sectoren per FAT (in oudere FAT-systemen en niet beschikbaar voor FAT32)
- Sectoren per spoor
- Aantal koppen
- Aantal verborgen sectoren in partitie
- Aantal sectoren in partitie
- Aantal sectoren per FAT
- FAT-informatiedescriptorvlaggen
- Versie van FAT32-schijf
- Clusternummer van het begin van de hoofdmap
- Sectornummer van de bestandssysteeminformatiesector
- Sectornummer van de back-upopstartsector
- Gereserveerd
- Logisch schijfnummer van partities
- Uitgebreide handtekening (29H)
- Serienummer van partitie
- Volumenaam van partitie
- FAT-naam
- Uitvoerbare code
- Uitvoerbare markering of magisch getal (AAH 55H)
Over het algemeen worden de volgende foutmeldingen op het scherm weergegeven:
“Schijfopstartfout”
“Niet-systeemschijf of schijffout”
“Ongeldige systeemschijf of schijf-I/O-fout”
“Vervang de schijf en druk vervolgens op een willekeurige toets…”
Wat kan worden hersteld met de back-up van DBR?
De back-up van DBR kan u helpen om de bovenstaande foutmeldingen te verwijderen. Deze foutmeldingen Wacht op het scherm totdat de gebruiker een opstartbare schijf met de bovengenoemde programma's in het diskettestation plaatst en op een toets drukt.
De drive zou toegankelijk moeten zijn als u het systeem opstart vanaf de opstartbare diskette of cd. Hoewel de harde schijf niet opstartbaar is, zou dat over het algemeen geen invloed moeten hebben op de toegang tot de gegevens van de schijf. Na het opstarten van het systeem met de opstartbare schijf heb je toegang tot de gegevens.
Door de back-up van DBR te herstellen, kunt u de gegenereerde problemen, zoals hierboven vermeld, oplossen.
Programma's voor het maken en herstellen van back-ups van DBR:
De programma's voor het maken van back-ups van DBR's en het herstellen ervan zijn bijna gelijk aan de programma's van MBR back-up en om te herstellen.
Als u bijvoorbeeld de programma's gaat schrijven voor het maken van een back-up van de DBR van de eerste logische schijfeenheid van de schijf en om deze terug te zetten, worden de parameters gespecificeerd door de dinfo-structuur als volgt gewijzigd:
| Parameter |
What it means |
| dinfo.drive = 0x80 |
It indicates the Physical drive 80H that is the first Hard disk drive> |
| dinfo.head = 1 |
It points to head number 1 |
| dinfo.track = 0 |
It points to track 0 |
| dinfo.sector = 1 |
First sector of the floppy that is sector 1 |
| dinfo.sector = 1 |
Number of sectors to consider for read operation = 1 |
| dinfo.buffer = dbuf |
Data buffer for the operation |
Hier zien we dat alleen de locatie van de te lezen/schrijven sector wordt gewijzigd. Hier wordt de C-H-S als 0-1-1 gegeven, aangezien de DBR van de eerste logische schijfeenheid hier wordt opgeslagen.
Volledige schijfbeeldbewerking
Dit type back-up wordt tegenwoordig steeds populairder en heeft de meeste voorkeur van dergelijke organisaties die zeer gevoelige gegevens in hun systemen hebben. Die mensen kunnen geen enkel risico nemen op zelfs maar één procent van het gegevensverlies.
Dergelijke organisaties nemen hun back-ups regelmatig als volledige schijfkopie. Het kost wel wat tijd maar geeft je de zekerheid dat je niets zal missen. Vanwege de toenemende populariteit hebben programmeurs hun best gedaan om de disk imaging-software steeds sneller te maken om de tijdsduur van het imaging-proces te minimaliseren.
Schijfbeeldbewerking is een goed idee, want door enkele tientallen minuten te besteden, kunt u het gemoedsrust krijgen dat u een back-up van alles in uw zak hebt. Alle factoren zoals MBR, BDR, FAT's, rootdirectories worden gekopieerd naar de doelschijf zoals deze is.
Wat we nodig hebben voor schijfafbeeldingen is een identieke (of bijna identieke) doelharde schijf, als onze bronschijf waarin we onze waardevolle gegevens hebben. Eén ding wordt altijd in gedachten gehouden dat de doelschijf niet kleiner mag zijn dan de bronschijf.
Nadat u de volledige image hebt gemaakt en u het systeem opstart met de doelschijf waarop u de schijfimage hebt gemaakt, krijgt u over het algemeen alle gegevens zoals ze zijn.
Het programma schrijven voor volledige schijfbeeldbewerking
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 de image van de eerste fysieke harde schijf (0x80) naar de tweede fysieke harde schijf (0x81), dus voordat u de backup-image maakt, moet u er rekening mee houden dat alle gegevens op de doelschijf (0x81) worden overschreven door de gegevens van de bronschijf (0x80) in sector voor sectorpatroon.
De codering van het programma is als volgt gegeven:
/* Programma om de afbeelding van de eerste harde schijf (0x80) naar de tweede harde schijf (0x81) te maken */
#include<stdio.h>
#include<dos.h>
#include<conio.h>
/* Structuur die moet worden gebruikt door de getdrivegeometry-functie met behulp van INT 13H-extensie, functienummer 0x48. */
struct geometry
{
unsigned int size ; /* (call) size of Buffer */
unsigned int flags ; /* Information Flags */
unsigned long cyl ; /* Number of Physical
Cylinders on Drive */
unsigned long heads ;/* Number of Physical
Heads on Drive */
unsigned long spt ; /* Number of Physical
Sectors Per Track */
unsigned long sectors[2] ; /* Total Number of
Sectors on Drive */
unsigned int bps ; /* Bytes Per Sector */
} ;
/* Structuur van schijfadrespakketformaat, te gebruiken door de functies, leesabsolutesectoren en schrijfabsolutesectoren */
struct diskaddrpacket
{
char packetsize ; /* Size of Packet, generally 10H */
char reserved ; /* Reserved (0) */
int blockcount ; /* Number of Blocks to Transfer */
char far *bufferaddress ; /* address to Transfer
Buffer */
unsigned long blocknumber[2] ; /* Starting Absolute
Block Number */
} ;
///// Functie om aandrijfparameters te krijgen: \\\\\
unsigned long getdrivegeometry (int drive)
{
union REGS i, o ;
struct SREGS s ;
struct geometry g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
i.h.ah = 0x48 ; /* Function Number 0x48 of INT 13H
Extensions See the Comments
Below */
i.h.dl = drive; /* Drive Number */
i.x.si = FP_OFF ( (void far*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Roep het gespecificeerde functienummer van de INT 13H-extensie op met Segment Register Values */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n", g.heads, g.spt, g.cyl);
/* Als de functie Drive Geometry mislukt, geeft u het foutbericht weer en sluit u af */
if(g.spt==0)
{
printf("\n Get Drive Geometry Function Fails....");
printf("\n Extensions Not Supported, Press any Key to
Exit...");
getch();
exit(1);
}
return *g.sectors; /* Return The Number of Sectors
on Drive */
}
////// Begin van het hoofdgerecht \\\\\\
void main()
{
unsigned long loop=0, Sectors_in_HDD1=0, Sectors_in_HDD2=0;
unsigned char buffer[61440]; /* Data buffer of 61440
Bytes to Read/Write 120 Sectors of 512 Bytes at a time to save time. */
char choice;
clrscr();
/* Als totaal nr. van de aangesloten harde schijven is minder dan twee Display Error Message en Exit. */
if(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n You Must Have At least Two Hard Disks
Attached to your Computer To Run This");
printf("\n Program. Press any Key to Exit... ");
getch();
exit(1);
}
/// Krijg parameters van de eerste harde schijf (0x80) \\\
Sectors_in_HDD1 = getdrivegeometry (0x80);
printf(" Total Sectors in First Hard Disk = %lu\n\n",
Sectors_in_HDD1);
/// Parameters van tweede Hsrd-schijf ophalen (0x81) \\\
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk = %lu\n\n",
Sectors_in_HDD2);
/// Eerst bevestigen, dan doorgaan \\\
printf("\n All The Data in Second Hard Disk will be
lost !!!");
printf("\n Press \'Y\' to Continue, Else any key to
Exit... ");
choice = getche();
switch(choice)
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
/* Bestemming mag niet kleiner zijn dan de Bron */
if(Sectors_in_HDD2<Sectors_in_HDD1)
{
printf("\n\n Destination Disk should not be Smaller
than Source Disk");
printf("\n Press any Key to Exit...");
getch();
exit(0);
}
/* Als alles in orde is, kopieer dan alle sectoren van de bronschijf naar de harde schijf van bestemming */
gotoxy(10,15);printf("Copying Absolute Sector: ");
for(loop=0;loop< =Sectors_in_HDD1;loop=loop+120)
{
readabsolutesectors ( 0x80, loop, 120, buffer );
writeabsolutesectors ( 0x81, loop, 120, buffer );
gotoxy(36,15); printf("%ld",loop);
if(kbhit())
{
exit(0);
}
}
//// Toon het bericht van voltooiing \\\
printf("\n\n Disk Imaging is Now Completed, Press any Key
To Exit...");
getch();
}
//// Einde hoofdgerecht
Opmerkingen over codering:
In de codering van het eerder gegeven programma, voor schijfimaging gaan we verder door de volgende taken uit te voeren:
- 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 raadpleegt u het hoofdstuk "Omgaan met grote harde schijven", dat eerder in dit boek is besproken.
De gegevenstypen die verschillende parameters van de schijf vertegenwoordigen, hebben de volgende betekenis:
| Data Type |
Size in Bytes |
Description |
| unsigned int size |
2 Bytes |
Size of Buffer |
| unsigned int flags |
2 Bytes |
Information Flags |
| unsigned long cyl |
4 Bytes |
Number of Physical Cylinders on Drive |
| unsigned long heads |
4 Bytes |
Number of Physical Heads on Drive |
| unsigned long spt |
4 Bytes |
Number of Physical Sectors Per Track |
| unsigned long sectors[2] |
8 Bytes |
Total Number of Sectors on Drive |
| unsigned int bps |
2 Bytes |
Bytes Per Sector |
- De structuur diskaddrpacket wordt gebruikt door de functies readabsolutesectors en writeabsolutesectors. Het formaat van het schijfadrespakket is gegeven in de volgende tabel:
| Data Type |
Size in Bytes |
Description |
| char packetsize |
1 Byte |
Size of Packet, generally 10H |
| char reserved |
1 Byte |
Reserved (0) |
| int blockcount |
2 Bytes |
Number of Blocks to Transfer |
| char far *bufferaddress |
4 Bytes |
address to Transfer Buffer |
| unsigned long blocknumber[2] |
4 Bytes |
Starting Absolute Block Number |
- 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 parameters is beschreven in de onderstaande tabel:
| Parameter |
What it means |
| i.h.ah = 0x48 |
Function Number 0x48 of INT 13H Extensions |
| i.h.dl = drive |
Drive Number |
| i.x.si = FP_OFF ( (void far*)&g ) |
ds:si address to buffer for drive parameters as discussed earlier |
| s.ds = FP_SEG ( (void far*)&g ) |
ds:si address to buffer for drive parameters as discussed earlier |
De functie int86x(0x13, &i, &o, &s) roept de interrupt 13H op met segmentregisterwaarden. De functie getdrivegeometry retourneert het totale aantal op drive.
- In de main() functie, (char)peekb(0x0040, 0x0075); (de functie peekb is gedefinieerd in DOS.H) retourneert het aantal harde schijven dat op het systeem is aangesloten.
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 is dan twee, geeft het programma de foutmelding weer en wordt 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.
Evenzo Sectoren_in_HDD2 = getdrivegeometry (0x81); haalt 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 imaging, controleer eerst de voorwaarde dat de grootte van de harde schijf van de bron niet groter mag zijn dan de grootte van de harde schijf van de bestemming. Als de bestemming kleiner is, geeft u de foutmelding weer en sluit u 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 beeldverwerkingsproces sneller te maken.
Als u meer sectoren tegelijk wilt gebruiken, zelfs boven de limiet van 64K, kunt u dit doen met “enorme Pointer” in groot geheugenmodel. Het voorbeeld van specificatie is als volgt:
char huge array[100000L];
- De functie, readabsolutesectors (0x80, loop, 120, buffer); leest de 120 sectoren van de eerste harde schijf (0x80), beginnend bij het sectornummer gespecificeerd door een 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 wordt gespecificeerd door een niet-ondertekende lange integerlus.
De codering van de functies readabsolutesectors ( ) en writeabsolutesectors ( ) zijn hierna gegeven:
//// Functie om absolute sector(en) te lezen \\\\
int readabsolutesectors ( int drive,
unsigned long sectornumber,
int numofsectors,
void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* packet size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ; /* Number of sectors
to read */
/* voor gegevensbuffer */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void
far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Sector number
to read */
pp.blocknumber[1] = 0 ; /* Block number */
i.h.ah = 0x42 ; /* Function Number*/
i.h.dl = drive ; /* Physical Drive Number */
i.x.si = FP_OFF ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
/* Roep de gespecificeerde functie van INT 13H op met segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /*failure */
else
return 1 ; /* success */
}
//// Functie om absolute sector(en) te schrijven \\\\
int writeabsolutesectors ( int drive,
unsigned long sectornumber,
int numofsectors,
void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* Packet Size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ; /* Number of Sectors
to be written */
/* voor gegevensbuffer */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void
far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ;/* Sector number
to be written */
pp.blocknumber[1] = 0 ; /* Block number = 0 */
i.h.ah = 0x43 ; /* Function Number */
i.h.al = 0x00 ; /* Write Flags, see
comments */
i.h.dl = drive ; /* Physical Drive number*/
/* ds:si for buffer Parameters */
i.x.si = FP_OFF ( (void far*)&pp ) ;
/* ds:si for buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ;
/* Roep de gespecificeerde functie van INT 13H op met segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /* failure */
else
return 1 ; /* success */
}
Opmerkingen over codering:
De parameters die door beide functies worden gebruikt, hebben de volgende betekenis:
| Parameter |
Size in Bytes |
Description |
| pp.packetsize = 16 ; |
1 Byte |
Size of packet = 10H |
| pp.reserved = 0 ; |
1 Byte |
Reserved = 0 |
| pp.blockcount = numofsectors ; |
2 Bytes |
Number of sectors to read |
| pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer)); |
----- |
for Data buffer or Transfer Buffer |
| pp.blocknumber[0] = sectornumber ; |
4 Bytes |
Sector number to read/write (generally, we need only this). Only alone This can support up to 2.1 Terabytes. |
| pp.blocknumber[1] = 0 ; |
4 Bytes |
Block number. Use this, If accessing the disk of greater then 2.1 Terabytes in size. |
| i.h.ah = 0x42 ; or i.h.ah = 0x43 ; |
2 Bytes |
Function Number of INT 13H Extensions |
| i.h.al = 0x00 ; |
1 Byte |
Write Flags used in write function only,00H, 01H are used for Write Without Verify and 02H is used for write with verify |
| i.h.dl = drive ; |
2 Bytes |
Physical Drive Number |
| i.x.si = FP_OFF ( (void far*)&pp ) ; |
------ |
ds:si for buffer Parameters |
| s.ds = FP_SEG ( (void far*)&pp ) ; |
------ |
ds:si for buffer Parameters |
| int86x ( 0x13, &i, &o, &s ) ; |
------ |
Invoke the specified Function of INT 13H with segment register values |
Pagina aangepast op: 15/01/2022
Home