Hoofdstuk – 13
MBR LEZEN EN WIJZIGEN MET PROGRAMMERING
DOS Boot Record (DBR) / DOS Boot Sector
Na de partitietabel is het DOS-opstartrecord (DBR), soms ook wel de DOS-opstartsector genoemd, het tweede belangrijkste stukje informatie op de harde schijf.
Voor een gedetailleerde bespreking van DBR, zie het hoofdstuk "Een logische benadering van schijven en besturingssystemen", dat eerder in dit boek is besproken.
De eerste logische sector van elke DOS-partitie bevat de DOS Boot Record (DBR) of DOS Boot Sector. De taak van DBR is om het besturingssysteem van de harde schijf in het hoofdgeheugen van de computer te laden en de controle over het systeem over te dragen aan het geladen programma.
De DOS Boot Record (DBR) voor de eerste partitie op een harde schijf bevindt zich meestal in absolute sector 63 (de 64e sector op de schijf) of in CHS-vorm, dat wil zeggen dat we voor de meeste schijven kunnen zeggen C–H–S = 0–1–1.
Deze indeling kan echter variëren, afhankelijk van de SPT (Sectors per Track) van de aandrijving. Op een oude 245MB-schijf met slechts 31 SPT's bevond de opstartrecord zich bijvoorbeeld in sector 32 (absolute sector 31).
Omdat de floppydisk geen partities heeft, bevat deze geen MBR of Master Partition Table in de eerste sector. In plaats daarvan bevat deze een DBR in de allereerste sector.
De DBR wordt gemaakt met de DOS-opdracht FORMAT na partitionering met de opdracht FDISK. De sector waar de DBR zich bevindt, wordt logische sector 1 van die specifieke partitie voor DOS. Het sectornummer dat DOS gebruikt, begint bij de fysieke sector waar de 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 voor het opstarten van de machine, d.w.z. het besturingssysteem opstarten, maar alleen deze partitie krijgt de besturing van de Master Boot Record, die is opgegeven als de actieve partitie in de partitietabelvermelding.
Als de DBR op enigerlei wijze beschadigd is, zou de schijf toegankelijk moeten zijn als u het systeem opstart vanaf een opstartdiskette of -cd. Ook al is de harde schijf niet opstartbaar (als de DBR van de actieve partitie beschadigd is), zou dit over het algemeen geen invloed moeten hebben op de toegang tot gegevens op de schijf. Nadat u het systeem vanaf de opstartschijf hebt opgestart, hebt u toegang tot de gegevens.
/* Geef de opstartparameters van de floppydisk weer */
# voeg <dos.h> toe
# voeg <stdio.h> toe
basis( )
{
laadstructuur
{
ongetekende tekencode[3] ; /* Overgangscode */
unsigned char system_id[8] ;/* OEM-naam en versie*/
int bytes_per_sec ; /* Bytes per sector */
symbool sec_per_clus ; /* Sectoren per cluster */
int res_sec ; /* Gereserveerde sectoren */
char fat_kopieën ; /* Aantal FAT */
int root_dir_entry ; /* Wortelnummer
Directory-items */
ongetekend int no_sects; /* Aantal sectoren in
Logisch volume */
ongetekende char format_id; /* Media-descriptorbyte
*/
int sec_per_vet ; /* Sectoren op FAT */
int sec_per_trk ; /* Sectoren per spoor */
int geen_zijden ; /* Aantal koppen */
int geen_sp_res_sect ; /* Aantal verborgen
Sectoren */
ongetekende char rest_code[482] ; /* Rest van de code */
} ;
laadstructuur b;
symbool temp[4] ;
int val, aandrijving;
val = absread(0, 1, 0, &b) ; /* Gebruik voor floppy disk*/
als (waarde == -1)
{
printf ( "Fout bij het lezen van schijf...slechte sector\n" ) ;
uitvoer (1);
}
clrscr ( );
printf("Systeem-ID = %s\n",
b.systeem_identifier ) ;
printf ("Bytes per sector = %d\n",
b.bytes_in_sec );
printf ("Sectoren per cluster = %d\n",
b.sec_per_klasse);
printf ("Gereserveerde sectoren = %d\n",
b.res_sec ) ;
printf ( "FAT kopieën = %d\n",
b.fat_kopieën ) ;
printf ( "Hoofdmap-items = %d\n",
b.root_dir_entry ) ;
printf ("Aantal sectoren op schijf = %u\n",
b.geen_secten ) ;
printf ( "Media-descriptorbyte = %X\n",
b.format_id ) ;
printf ("Sectoren per FAT = %d\n",
b.sec_per_vet );
printf ( "Sectoren per spoor = %d\n",
b.sec_per_trk ) ;
printf ("Aantal zijden = %d\n",
b.geen_zijden ) ;
printf ("Aantal gereserveerde sectoren = %d\n",
b.geen_sp_res_sect ) ;
retourneer 0;
}
Als u dit programma uitvoert om de DBR van een 1,44 M, 3½ inch floppydisk met 70 sporen, twee zijden, 18 sectoren per spoor en 512 bytes in een sector te testen, wordt de uitvoer van het programma als volgt weergegeven:
Systeem-ID = +1<*uIHC
Bytes per sector = 512
Sectoren per cluster = 1
Gereserveerde sectoren = 1
FAT-kopieën = 2
Hoofdmapvermeldingen = 224
Aantal sectoren op schijf = 2880
Media-descriptorbyte = F0
Sectoren per FAT = 9
Sectoren per spoor = 18
Aantal zijden = 2
Aantal gereserveerde sectoren = 0
Het lezen van de DBR van grote volumes
Partitievolumes die groter zijn dan 32 MB hebben een andere DBR-indeling dan de DBR voor volumes die kleiner zijn dan of gelijk zijn aan 32 MB.
Dit is om ondersteuning te bieden aan grote volumes van de schijf (voor een gedetailleerde beschrijving hiervan, zie het hoofdstuk “Logische benadering van schijven en besturingssystemen”, eerder in dit boek besproken).
De indeling van de DOS Boot Record van een FAT32-volume is weergegeven in de volgende tabel:
Het volgende programma leest de DBR van grote volumes, die groter zijn dan 32 MB:
/* Programma om opstartparameters van groot schijfvolume weer te geven */
# "dos.h" opnemen
# "stdio.h" opnemen
leeg hoofd()
{
structuur boot
{
ongetekende char-code[3] ; /* Jump-code */
ongetekende char system_id[8] ; /* OEM-naam en versie */
int bytes_per_sec ; /* Bytes per sector */
teken sec_per_clus ; /* Sectoren per cluster*/
unsigned int res_sec ; /* Aantal gereserveerde
Sectoren */
char fat_copies ; /* Aantal FAT's */
unsigned int root_dir_entry ;/* Nummer van Root
Directory-item */
unsigned int no_sects ; /* Aantal sectoren in
Logisch volume (indien
Volume <= 32MB) */
ongetekende char Media_id ; /* Media Descriptor Byte
*/
unsigned int sec_per_fat ; /* Sector per FAT */
unsigned int sec_per_trk ; /* Sectoren per spoor */
unsigned int no_sides ; /* Aantal hoofden */
unsigned long no_sp_res_sect ; /* Aantal verborgen
Sectoren */
unsigned long long_sec_num ; /* Totaal aantal sectoren in
Logisch volume
(Grootte >32MB) */
unsigned long num_sec_per_FAT; /* Sectoren per FAT */
unsigned int binaire_vlaggen; /* Binaire vlaggen */
unsigned char versie_van_FAT1; /* Eerste byte van FAT
Versie */
unsigned char version_of_FAT2; /* Tweede byte van FAT
Versie */
ongetekend lang root_dir_start_cluster;
/* Hoofdmap
Startcluster
Nummer */
ongetekende int sec_num_of_file_sys;
/* Sectornummer van
Bestandssysteem
Informatie Sector
*/
ongetekende int sec_num_of_backup_boot_sec;
/* Sectornummer van
Back-up opstartsector
*/
ongetekende char gereserveerd[12]; /* Gereserveerd */
ongetekende char logisch_schijfnummer;
/* Fysieke schijf
Aantal logische
Deel */
unsigned char unused_byte; /* Ongebruikte byte */
ongetekende char hex_extd_boot_signature;
/* Uitgebreide opstart
Handtekening(29H) */
unsigned long binary_volume_ID;/* Binaire volume-ID */
ongetekende char volume_label[11];/* Volumelabel */
ongetekende char FAT_name[8]; /* FAT-naam */
ongetekende char rest_code[420] ; /* Rest 420 bytes van
De DBR */
ongetekende char magic_number[2]; /* Magisch getal */
} ;
structuur boot b ;
teken temp[4] ;
int val, aandrijving,i;
val = biosdisk( 2, 0x80, 1,0,1,1, &b ) ;
/* Voor eerste harde schijf */
als ( val == -1 )
{
printf ( "Schijfleesfout...slechte sector\n" ) ;
uitgang ( 1 );
}
clrscr ( );
printf ( " Sprong Instructie Code = ");
voor(i=0;i<=2;i++)
{
printf("%X",b.code[i]);
}
afdrukkenf("(H)\n ");
printf ( "OEM-naam en versie = %s\n ",
b.systeem_id ) ;
printf ("Bytes per sector = %u\n",
b.bytes_per_sec );
printf ("Sectoren per cluster = %u\n",
b.sec_per_clus );
printf ("Gereserveerde sectoren = %u\n ",
b.res_sec ) ;
printf ( "FAT kopieën = %d\n ",
b.fat_kopieën ) ;
printf ( "Root directory-items = %u\n ",
b.root_dir_entry ) ;
printf ("Aantal sectoren op schijf = %u\n ",
b.geen_secten ) ;
printf ( "Media-descriptorbyte = %X(H)\n",
b.Media_id ) ;
printf ("Sectoren per FAT = %u\n",
b.sec_per_vet );
printf ( "Sectoren per spoor = %u\n ",
b.sec_per_trk ) ;
printf ("Aantal zijden = %u\n",
b.geen_zijden ) ;
printf ("Aantal gereserveerde (verborgen) sectoren= %lu\n ",
b.geen_sp_res_sect ) ;
printf ( "========== Voor grote (>32 MB) schijven ========\n");
printf ( "Aantal sectoren,(als volume >32MB is) = %lu\n ",
b.lange_sec_num) ;
printf ( “Aantal sectoren per FAT = %lu\n “,
b.aantal_sec_per_FAT );
printf ( "Hoofdmap Startcluster = %lu\n ",
b.root_dir_start_cluster);
printf ( "Bestandssysteem Informatie Sector = %u\n ",
b.sec_num_van_bestandssys);
printf ( "Sectornummer van back-upbootsector = %u\n ",
b.sec_aantal_backup_opstartsec);
printf ("Fysiek schijfnummer = %X(H)\n",
b.logisch_schijfnummer);
printf ( "Uitgebreide opstarthandtekening = %X(H)\n",
b.hex_extd_boot_signature);
printf ( "32-bits binaire volume-ID = ");
Decimaal_naar_binair (b.binary_volume_ID,32);
afdrukken ( " (B)\n ");
printf ( "Volumelabel = ");
voor(i=0;i<=10;i++)
{
printf ( "%c",b.volume_label[i]);
}
printf ( "\n FAT-naam = ");
voor(i=0;i<=7;i++)
{
printf ( "%c",b.FAT_naam[i]);
}
afdrukkenf ( "\n ");
printf ( "Magisch getal = %X%X(H)",
b.magic_number[0],b.magic_number[1]);
halen();
}
//////// Decimaal naar binair conversiefunctie \\\\\\\\
Decimal_to_Binary (ongetekende lange invoer)
{
ongetekende lange i;
int aantal = 0;
int binair [32]; /* 32 Bit MAX alleen 32
elementen totaal */
Doen
{
i = input%2; /* MOD 2 om 1 of een 0*/ te krijgen
binair[aantal] = i; /* Elementen laden in de
Binaire array */
input = input/2; /* Deel input door 2 om
decrement via binair */
count++; /* Tel hoeveel elementen
zijn nodig */
}terwijl (invoer > 0);
/* Binaire cijfers omkeren en uitgeven */
Doen
{
printf ("%d", binair[aantal - 1]);
graaf--;
} terwijl (aantal > 0);
retourneer 0;
}
Wanneer het programma wordt uitgevoerd om de DBR van een groot volume te lezen, wordt de uitvoer van het programma als volgt weergegeven:
Jump Instruction Code = EB5890 (H)
OEM-naam en -versie = MSWIN4.1
Bytes per sector = 512
Sectoren per cluster = 8
Gereserveerde sectoren = 32
FAT-kopieën = 2
Hoofddirectory-items = 0
Aantal sectoren op schijf = 0
Media Descriptor Byte = F8 (H)
Sectoren per FAT = 0
Sectoren per track = 63
Aantal zijden = 255
Aantal gereserveerde (verborgen) sectoren = 63
=========== Voor grote (>32 MB) schijven ============ Aantal sectoren (als het volume >32 MB is) = 11277567 Aantal sectoren per FAT = 11003 Hoofddirectory Starting Cluster = 2 Bestandssysteeminformatie Sector = 1 Sectornummer van back-up Boot Sector = 6 Fysiek schijfnummer = 80 (H) Uitgebreide opstarthandtekening = 29 (H) 32-bits binair Volume-ID = 110101010001100001110111100101 (B) Volumelabel = SAAYA FAT-naam = FAT32 Magisch getal = 55AA (H)
In de uitvoer van het programma zien we dat de volgende parameters nul zijn:
- Hoofdmap-invoer
- Aantal sectoren op schijf
- Aantal sectoren per FAT
Deze parameters zijn zo omdat deze waarden op nul worden gezet als het partitievolume groter is dan 32 MB en de werkelijke informatie te vinden is in het Extended Volume Information Block van de DBR.
In het begingedeelte van de DBR-informatie is het aantal sectoren per FAT bijvoorbeeld 0 en in het Extended Volume Information Block van DBR is het aantal sectoren per FAT 11003, wat de werkelijke waarde is voor dit grote volume.
De DBR van het volume bevat belangrijke informatie over de schijfparameters, die kan worden gebruikt om alle gegevensinformatie te koppelen voor programmeerdoeleinden. Als u bijvoorbeeld toegang wilt tot de DBR's van andere partitievolumes op de schijf, kunt u deze berekenen op basis van het aantal sectoren, geschreven in DBR en andere gerelateerde informatie.
Als u de Schijf met cluster-aanpak wilt gebruiken, kunt u berekeningen uitvoeren met behulp van Sectoren per cluster, sectoren per FAT en andere informatie.
Als u een harde schijf groter dan 8,4 GB gebruikt (zie het hoofdstuk 'Logische benadering van schijven en besturingssystemen', eerder in dit boek besproken), gebruikt u extensies om toegang te krijgen tot alle DBR's van de schijf die groter zijn dan 8,4 GB. Raadpleeg de uitgebreide lees-schrijffuncties in de vorige hoofdstukken
Hoe DBR te herstellen met programmeren
U kunt de DBR van het schijfvolume tot 100 procent herstellen door een lastige aanpak en logische berekeningen te gebruiken. Zoals we eerder in dit boek in het hoofdstuk "Logische aanpak van schijven en besturingssystemen" hebben besproken over logische benaderingen van bestandssystemen, wordt alle informatie in DBR binnen een bepaalde limiet of regel geschreven.
Elke parameter die in de DBR is geschreven, heeft een specifieke betekenis en is geschreven volgens een specifieke regel en reden. Daarom kan de informatie van DBR, als deze verloren gaat, handmatig opnieuw worden gekoppeld of herschreven als u deze regel volgt en de lastige geest gebruikt om erachter te komen wat en hoe u moet genezen.
Bijvoorbeeld, de volgende tabel beschrijft het aantal sectoren per cluster voor verschillende bestandssystemen, waarmee u het aantal sectoren per cluster voor uw schijf kunt vinden. Laten we aannemen dat u een volume van ongeveer 10 GB op uw schijf had en dat het besturingssysteem dat u gebruikte Windows 98 was.
Nu, als er een manier is waarop de "Sectors per cluster" informatie van de DBR van het volume beschadigd is. Laten we proberen uit te vinden welk bestandssysteem en hoeveel sectoren per clusters u had in het volume van uw schijf.
Omdat het besturingssysteem op uw schijf Windows 98 was, dat alleen het FAT-bestandssysteem ondersteunt, was het bestandssysteem van uw volume FAT. Laten we nu eens nadenken over de grootte van het volume, dat ongeveer 10 GB was.
We weten dat de 10GB-partitie niet wordt ondersteund door FAT16 (zie de onderstaande tabel). Daarom moet het bestandssysteem van het volume FAT32 zijn.
Laten we nu proberen het aantal sectoren per cluster voor het volume te berekenen. Zoals we in de tabel zien, heeft de partitie binnen het bereik van 8 GB tot 16 GB één cluster van 8 sectoren.
Daarom kunnen we nu concluderen dat in het volume, het bestandssysteem FAT32 was met 8 sectoren per cluster. Op dezelfde manier kunnen we de andere informatie van de DBR samenstellen met behulp van andere logische benaderingen die in de vorige hoofdstukken van dit boek zijn beschreven.
Het volgende programma is geschreven om de informatie van schijfparameters te herschrijven naar een DBR van 1,44 Mb, 3½ inch floppy disk, met 80 sporen, 2 koppen (zijden) en 18 sectoren per spoor.
/* Programma om de parameters van een 1,44 MB, 3½ inch floppy disk te herschrijven naar zijn DBR */
# "dos.h" opnemen
# "stdio.h" opnemen
structuur boot
{
ongetekende char-code[3] ; /* Jump-code */
ongetekende char system_id[8] ; /* OEM-ID en versie*/
int bytes_per_sec ; /* Bytes per sector */
char sec_per_clus ; /* Aantal sectoren
Per cluster */
int res_sec ; /* Gereserveerde sectoren */
char fat_copies ; /* Aantal FAT's */
int root_dir_entry ; /* Nummer van Root
Directory-items */
unsigned int no_sects ; /* Aantal Totaal
Sectoren */
ongetekende char format_id ; /* Media Descriptor
Byte */
int sec_per_fat ; /* Sectoren per FAT */
int sec_per_trk ; /* Sectoren per FAT */
int no_sides ; /* Aantal
Zijden (hoofden) */
int no_sp_res_sect ; /* Aantal verborgen
Sectoren */
ongetekende char rest_code[482] ;/* Rest 482 Bytes code
van DBR */
} ;
structuur boot b ;
voornaamst( )
{
met een hint;
val = absread(0, 1, 0, &b); /* Gebruik voor floppy disk */
als ( val == -1 )
{
printf ( "\n Schijfleesfout...slechte sector\n" ) ;
uitgang ( 1 );
}
clrscr ( );
weergave_info();
halen();
printf("\n Nu BDR van floppy herstellen.....\n");
Herstellen_met_waarden();
printf ( "\n Schijf succesvol hersteld." ) ;
weergave_info();
retourneer 0;
}
/* Functie om de parameters van DBR te wijzigen */
Herstellen_met_waarden()
{
int-waarde = 0;
/* Jumpcode van 3 bytes voor floppy */
b.code[0] = 0xEB;
b.code[1]= 0x3E;
b.code[2]= 0x90 ;
/* Systeem-ID van 8 bytes */
strcpy(b.systeem_id, "+05PSIHC");
/* Bytes per sector = 512 */
b.bytes_per_sec = 512;
/* Sector per cluster voor 1,44M 3,5" floppy = 1 */
b.sec_per_clus = 1;
/* Aantal gereserveerde sectoren = 1 */
b.res_sec =1;
/* Aantal FAT-kopieën = 2 */
b.fat_kopieën =2;
/* Aantal vermeldingen in de rootdirectory = 224 */
b.root_dir_entry =224;
/* Aantal sectoren op schijf = 2880 */
b.geen_secten =2880;
/* Media-descriptorbyte voor floppy = F0 (H) */
b.formaat_id = 0xF0;
/* Sectoren per FAT = 9 */
b.sec_per_vet =9;
/* Sectoren per spoor = 18 */
b.sec_per_trk =18;
/* Aantal zijden = 2 */
b.geen_zijden =2;
/* Aantal speciale gereserveerde sectoren (of verborgen
Sectoren) = 0 */
b.no_sp_res_sect =0;
/* Gebruik voor floppy disk*/
val = abswrite ( 0, 1, 0, &b );
als ( val == -1 )
{
printf ( "\n Schijfschrijffout...slechte sector\n" ) ;
printf ( "Schijf is niet hersteld." ) ;
uitgang ( 1 );
}
retourneer 0;
}
weergave_info()
{
printf ( "\n Sprongcode (Hex) = %X%X%X (H)\n",
b.code[0], b.code[1], b.code[2]);
printf ( " Systeem-ID = %s\n",
b.systeem_id ) ;
printf ( "Bytes per sector = %d\n",
b.bytes_per_sec );
printf (" Sectoren per cluster = %d\n",
b.sec_per_clus );
printf ("Gereserveerde sectoren = %d\n",
b.res_sec ) ;
printf ( " FAT kopieën = %d\n",
b.fat_kopieën ) ;
printf ( " Hoofdmap vermeldingen = %d\n",
b.root_dir_entry ) ;
printf ("Aantal sectoren op schijf = %u\n",
b.geen_secten ) ;
printf("Media-descriptorbyte = %X\n",
b.format_id ) ;
printf("Sectoren op FAT = %d\n",
b.sec_per_vet );
printf("Sectoren per spoor = %d\n",
b.sec_per_trk ) ;
printf("Aantal zijden = %d\n",
b.geen_zijden) ;
printf("Aantal gereserveerde sectoren = %d\n",
(geen_sp_res_sect );
retourneer 0;
}
Opmerkingen bij codering:
De opstartstructuur wordt gebruikt om toegang te krijgen tot de DBR en om schijfparameters te lezen en schrijven. De functie display_info() geeft verschillende schijfparameters weer door deze uit de DBR te lezen. De functie Recover_with_values() wordt gebruikt om DBR Floppy-parameters te wijzigen en te herstellen.
De waarden die door de functie Recover_with_values() worden gebruikt, zijn voor een 1,44 MB, 3 ½ inch DBR-floppydisk. Een beschrijving van deze waarden vindt u in onderstaande tabel:
