Hoofdstuk – 13
Lezen en wijzigen van DBR met programmeren
DOS-opstartrecord (DBR) / DOS-opstartsector
DOS-opstartrecord (DBR) / DOS-opstartsector
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 besturingssysteem", 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 –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).
Omdat de diskette geen partities heeft, heeft hij dus ook geen MBR of Master Partition Table op zijn eerste sector, maar bevat hij de DBR op zijn allereerste sector.
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 is gespecificeerd als actieve partitie, in de partitietabel.
Als de DBR op een of andere manier beschadigd is, zou de drive toegankelijk moeten zijn als u het systeem opstart vanaf de opstartbare diskette of cd. Hoewel de harde schijf niet opstartbaar is (als de DBR van de actieve partitie beschadigd is), zou dat over het algemeen de toegang tot de gegevens van de schijf niet moeten beïnvloeden. Na het opstarten van het systeem met de opstartbare schijf heeft u toegang tot de gegevens.
/* Toon opstartparameters van diskette */
# include <dos.h>
# include <stdio.h>
main( )
{
struct boot
{
unsigned char code[3] ; /* Jump Code */
unsigned char system_id[8] ;/* OEM Name and Version*/
int bytes_per_sec ; /* Bytes Per Sector */
char sec_per_clus ; /* Sectors Per Cluster */
int res_sec ; /* Reserved Sectors */
char fat_copies ; /* Number of FATs */
int root_dir_entry ; /* Number of Root
Directory Entries */
unsigned int no_sects ; /* Number of Sectors in
Logical Volume */
unsigned char format_id ; /* Media Descriptor Byte
*/
int sec_per_fat ; /* Sectors Per FAT */
int sec_per_trk ; /* Sectors Per Track */
int no_sides ; /* Number of Heads */
int no_sp_res_sect ; /* Number of Hidden
Sectors */
unsigned char rest_code[482] ; /* Rest of the code */
} ;
struct boot b ;
char temp[4] ;
int val, drive ;
val = absread(0, 1, 0, &b) ; /* Use For Floppy Disk*/
if ( val == -1 )
{
printf ( "Disk read Error...bad sector\n" ) ;
exit ( 1 ) ;
}
clrscr ( ) ;
printf ( "System ID = %s\n",
b.system_id ) ;
printf ( "Bytes per sector = %d\n",
b.bytes_per_sec ) ;
printf ( "Sectors per cluster = %d\n",
b.sec_per_clus ) ;
printf ( "Reserved sectors = %d\n",
b.res_sec ) ;
printf ( "FAT copies = %d\n",
b.fat_copies ) ;
printf ( "Root directory entries = %d\n",
b.root_dir_entry ) ;
printf ( "No. of sectors on disk = %u\n",
b.no_sects ) ;
printf ( "Media Descriptor Byte = %X\n",
b.format_id ) ;
printf ( "Sectors per FAT = %d\n",
b.sec_per_fat ) ;
printf ( "Sectors per track = %d\n",
b.sec_per_trk ) ;
printf ( "No. of sides = %d\n",
b.no_sides ) ;
printf ( "No. of reserved sectors = %d\n",
b.no_sp_res_sect ) ;
return 0;
}
Als u dit programma uitvoert om de DBR van 1,44M, 3½ inch floppydisk met 70 tracks, twee zijden, 18 sectoren per track en 512 bytes in een sector te testen, wordt de uitvoer van het programma als volgt weergegeven:
System ID = +1<*uIHC
Bytes per sector = 512
Sectors per cluster = 1
Reserved sectors = 1
FAT copies = 2
Root directory entries = 224
No. of sectors on disk = 2880
Media Descriptor Byte = F0
Sectors per FAT = 9
Sectors per track = 18
No. of sides = 2
No. of reserved sectors = 0
De DBR van grote volumes lezen
De partitievolumes die groter zijn dan 32 MB hebben een ander formaat van DBR dan de DBR voor minder dan of gelijk aan 32 MB volumes.
Het is zo om ondersteuning te bieden aan grote volumes van de schijf (raadpleeg voor een gedetailleerde beschrijving ervan het hoofdstuk "Logische benadering van schijven en besturingssysteem", eerder in dit boek besproken).
Het formaat van het DOS-opstartrecord van een FAT32-volume is weergegeven in de volgende tabel:
Het volgende programma is om de DBR van grote volumes te lezen, die groter zijn dan 32 MB:
/* Programma om opstartparameters van groot schijfvolume weer te geven */
# include "dos.h"
# include "stdio.h"
void main()
{
struct boot
{
unsigned char code[3] ; /* Jump Code */
unsigned char system_id[8] ; /* OEM name & Version */
int bytes_per_sec ; /* Bytes Per Sector */
char sec_per_clus ; /* Sectors Per Cluster*/
unsigned int res_sec ; /* Number of Reserved
Sectors */
char fat_copies ; /* Number of FATs */
unsigned int root_dir_entry ;/* Number of Root
Directory Entry */
unsigned int no_sects ; /* Number of Sectors in
Logical Volume (if
Volume is <= 32MB) */
unsigned char Media_id ; /* Media Descriptor Byte
*/
unsigned int sec_per_fat ; /* Sector Per FAT */
unsigned int sec_per_trk ; /* Sectors Per Track */
unsigned int no_sides ; /* Number of Heads */
unsigned long no_sp_res_sect ; /* Number of Hidden
Sectors */
unsigned long long_sec_num ; /* Total Sectors in
Logical Volume
( Size >32MB) */
unsigned long num_sec_per_FAT; /* Sectors Per FAT */
unsigned int binary_flags; /* Binary Flags */
unsigned char version_of_FAT1; /* First Byte of FAT
Version */
unsigned char version_of_FAT2; /* Second Byte of FAT
Version */
unsigned long root_dir_start_cluster;
/* Root Directory
Starting Cluster
Number */
unsigned int sec_num_of_file_sys;
/* Sector Number of
File System
Information Sector
*/
unsigned int sec_num_of_backup_boot_sec;
/* Sector Number of
Backup Boot Sector
*/
unsigned char reserved[12]; /* Reserved */
unsigned char logical_drive_number;
/* Physical Drive
Number of Logical
Volume */
unsigned char unused_byte; /* Unused Byte */
unsigned char hex_extd_boot_signature;
/* Extended Boot
Signature(29H) */
unsigned long binary_volume_ID;/* Binary Volume ID */
unsigned char volume_label[11];/* Volume Label */
unsigned char FAT_name[8]; /* FAT Name */
unsigned char rest_code[420] ; /* Rest 420 Bytes of
The DBR */
unsigned char magic_number[2]; /* Magic Number */
} ;
struct boot b ;
char temp[4] ;
int val, drive,i;
val = biosdisk( 2, 0x80, 1,0,1,1, &b ) ;
/* For First Hard Disk */
if ( val == -1 )
{
printf ( "Disk read Error...bad sector\n" ) ;
exit ( 1 ) ;
}
clrscr ( ) ;
printf ( " Jump Instruction Code = ");
for(i=0;i<=2;i++)
{
printf("%X",b.code[i]);
}
printf("(H)\n ");
printf ( "OEM name and version = %s\n ",
b.system_id ) ;
printf ( "Bytes per sector = %u\n ",
b.bytes_per_sec ) ;
printf ( "Sectors per cluster = %u\n ",
b.sec_per_clus ) ;
printf ( "Reserved sectors = %u\n ",
b.res_sec ) ;
printf ( "FAT copies = %d\n ",
b.fat_copies ) ;
printf ( "Root directory entries = %u\n ",
b.root_dir_entry ) ;
printf ( "No. of sectors on disk = %u\n ",
b.no_sects ) ;
printf ( "Media Descriptor Byte = %X(H)\n",
b.Media_id ) ;
printf ( "Sectors per FAT = %u\n ",
b.sec_per_fat ) ;
printf ( "Sectors per track = %u\n ",
b.sec_per_trk ) ;
printf ( "No. of sides = %u\n ",
b.no_sides ) ;
printf ( "No. of reserved (Hidden) sectors= %lu\n ",
b.no_sp_res_sect ) ;
printf ( "========== For Large(>32MB) Disks ========\n");
printf ( "No. of sectors,(if Volume is >32MB) = %lu\n ",
b.long_sec_num) ;
printf ( “Number of Sectors Per FAT = %lu\n “,
b.num_sec_per_FAT );
printf ( "Root Directory Starting Cluster = %lu\n ",
b.root_dir_start_cluster);
printf ( "File System Information Sector = %u\n ",
b.sec_num_of_file_sys);
printf ( "Sector Number of Backup Boot Sector = %u\n ",
b.sec_num_of_backup_boot_sec);
printf ( "Physical Drive Number = %X(H)\n",
b.logical_drive_number);
printf ( "Extended Boot Signature = %X(H)\n",
b.hex_extd_boot_signature);
printf ( "32-Bit Binary Volume ID = ");
Decimal_to_Binary (b.binary_volume_ID,32);
printf ( " (B)\n ");
printf ( "Volume Label = ");
for(i=0;i<=10;i++)
{
printf ( "%c",b.volume_label[i]);
}
printf ( "\n FAT name = ");
for(i=0;i<=7;i++)
{
printf ( "%c",b.FAT_name[i]);
}
printf ( "\n ");
printf ( "Magic Number = %X%X(H)",
b.magic_number[0],b.magic_number[1]);
getch();
}
//////// Decimaal naar binaire conversiefunctie \\\\\\\\
Decimal_to_Binary(unsigned long input)
{
unsigned long i;
int count = 0;
int binary [32]; /* 32 Bit MAX only 32
elements total */
do
{
i = input%2; /* MOD 2 to get 1 or a 0*/
binary[count] = i; /* Load Elements into the
Binary Array */
input = input/2; /* Divide input by 2 to
decrement via binary */
count++; /* Count howy elements
are needed */
}while (input > 0);
/* Omgekeerde en uitvoer binaire cijfers */
do
{
printf ("%d", binary[count - 1]);
count--;
} while (count > 0);
return 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 name and version = MSWIN4.1
Bytes per sector = 512
Sectors per cluster = 8
Reserved sectors = 32
FAT copies = 2
Root directory entries = 0
No. of sectors on disk = 0
Media Descriptor Byte = F8 (H)
Sectors per FAT = 0
Sectors per track = 63
No. of sides = 255
No. of reserved (Hidden) sectors = 63
=========== For Large (>32MB) Disks ===========
No. of sectors, (if Volume is >32MB) = 11277567
Number of Sectors per FAT = 11003
Root Directory Starting Cluster = 2
File System Information Sector = 1
Sector Number of Backup Boot Sector = 6
Physical Drive Number = 80 (H)
Extended Boot Signature = 29 (H)
32-Bit Binary Volume ID = 110101010001100001110111100101 (B)
Volume Label = SAAYA
FAT name = FAT32
Magic Number = 55AA (H)
In de uitvoer van het programma zien we dat de volgende parameters nul worden weergegeven:
- Hoofdmapinvoer
- Aantal sectoren op schijf
- Aantal sectoren per FAT
Deze parameters zijn zo omdat deze waarden zijn ingesteld op nul, als het partitievolume groter is dan 32 MB en de feitelijke informatie wordt gevonden in het Extended Volume Information Block van de DBR.
Bijvoorbeeld, in het eerste deel van de DBR-informatie is het aantal sectoren per FAT 0 en in het uitgebreide volume-informatieblok van DBR is het aantal sectoren per FAT 11003, wat de werkelijke waarde is voor dit grote volume .
De DBR van het volume bevat de belangrijke informatie over de schijfparameters, die kan worden gebruikt om alle gegevensinformatie voor programmeerdoeleinden te koppelen. Als u bijvoorbeeld toegang wilt tot de DBR's van een ander partitievolume op de schijf, kunt u dit berekenen op basis van het aantal sectoren, geschreven in DBR en andere gerelateerde informatie.
Als u de schijf wilt benaderen met clusterbenadering, kunt u berekeningen maken met behulp van Sectoren per cluster, sectoren per FAT en andere informatie.
Als u een harde schijf gebruikt die groter is dan 8,4 GB (zie het hoofdstuk, "Logische benadering van schijven en besturingssysteem", eerder in dit boek besproken), gebruik dan extensies om toegang te krijgen tot alle DBR's van de schijf groter dan 8,4 GB. Raadpleeg de uitgebreide lees-schrijffuncties, gegeven 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 hebben besproken over logische benaderingen van bestandssystemen in het hoofdstuk "Logische benadering van schijven en besturingssysteem", eerder in dit boek, is alle informatie in DBR geschreven binnen een bepaalde limiet of regel.
Elke parameter die in de DBR is geschreven, heeft een specifieke betekenis en wordt zo geschreven door een specifieke regel en reden te volgen. Dat is de reden waarom de informatie van DBR, indien verloren, opnieuw kan worden gekoppeld of handmatig kan worden herschreven als u deze regel volgt en de lastige geest gebruikt om erachter te komen wat en hoe te genezen.
Bijvoorbeeld, de volgende tabel beschrijft het aantal sectoren per cluster voor verschillende bestandssystemen, aan de hand waarvan 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, indien van toepassing, hoe de "Sectors per cluster"-informatie van de DBR van het volume is beschadigd. Laten we proberen te achterhalen welk bestandssysteem en hoeveel sectoren per cluster je op het volume van je schijf had.
Omdat het besturingssysteem op uw schijf Windows 98 was, dat alleen het FAT-bestandssysteem ondersteunt, was het bestandssysteem van uw Volume daarom FAT. Laten we nu eens nadenken over de grootte van het volume, dat ongeveer 10 GB was.
We weten dat de partitie van 10 GB niet wordt ondersteund door FAT16 (zie de tabel hierna) en 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 het bestandssysteem in het volume FAT32 was met 8 sectoren per cluster. Op dezelfde manier kunnen we de andere informatie van de DBR verzamelen 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 in DBR van 1,44 Mb, 3½ inch floppydisk, met 80 sporen, 2 koppen (zijkanten) en 18 sectoren per spoor.
/* Programma om de parameters van 1,44 MB, 3½ inch diskette naar zijn DBR . te herschrijven */
# include "dos.h"
# include "stdio.h"
struct boot
{
unsigned char code[3] ; /* Jump Code */
unsigned char system_id[8] ; /* OEM ID and Version*/
int bytes_per_sec ; /* Bytes Per Sector */
char sec_per_clus ; /* Number of Sectors
Per Cluster */
int res_sec ; /* Reserved Sectors */
char fat_copies ; /* Number of FATs */
int root_dir_entry ; /* Number of Root
Directory Entries */
unsigned int no_sects ; /* Number of Total
Sectors */
unsigned char format_id ; /* Media Descriptor
Byte */
int sec_per_fat ; /* Sectors Per FAT */
int sec_per_trk ; /* Sectors Per FAT */
int no_sides ; /* Number of
Sides(Heads) */
int no_sp_res_sect ; /* Number of Hidden
Sectors */
unsigned char rest_code[482] ;/* Rest 482 Bytes code
of DBR */
} ;
struct boot b ;
main( )
{
int val ;
val = absread(0, 1, 0, &b); /* Use For Floppy Disk */
if ( val == -1 )
{
printf ( "\n Disk read Error...bad sector\n" ) ;
exit ( 1 ) ;
}
clrscr ( ) ;
display_info();
getch();
printf("\n Now Recovering BDR of Floppy.....\n");
Recover_with_values();
printf ( "\n Disk Recovered Successfully." ) ;
display_info();
return 0;
}
/* Functie om de parameters van DBR . te wijzigen */
Recover_with_values()
{
int val =0;
/* Jump Code of 3 Bytes For Floppy */
b.code[0] = 0xEB;
b.code[1]= 0x3E;
b.code[2]= 0x90 ;
/* System Id of 8 Bytes */
strcpy(b.system_id, "+05PSIHC");
/* Bytes Per Sector = 512 */
b.bytes_per_sec = 512;
/* Sector per Cluster for 1.44M 3.5" Floppy = 1 */
b.sec_per_clus = 1;
/* Number of Reserved Sectors = 1 */
b.res_sec =1;
/* Number of FAT Copies = 2 */
b.fat_copies =2;
/* Number of Root Directory Entry = 224 */
b.root_dir_entry =224;
/* Number of Sectors on Disk = 2880 */
b.no_sects =2880;
/* Media Descriptor Byte For Floppy = F0 (H) */
b.format_id =0xF0;
/* Sectors Per FAT = 9 */
b.sec_per_fat =9;
/* Sectors Per Track = 18 */
b.sec_per_trk =18;
/* Number of Sides = 2 */
b.no_sides =2;
/* Number of Special Reserved Sectors (or Hidden
Sectors) = 0 */
b.no_sp_res_sect =0;
/* Use For Floppy Disk*/
val = abswrite ( 0, 1, 0, &b ) ;
if ( val == -1 )
{
printf ( "\n Disk Write Error...bad sector\n" ) ;
printf ( " Disk was not Recovered." ) ;
exit ( 1 ) ;
}
return 0;
}
display_info()
{
printf ( "\n Jump Code (Hex) = %X%X%X (H)\n",
b.code[0],b.code[1],b.code[2]);
printf ( " System ID = %s\n",
b.system_id ) ;
printf ( " Bytes per sector = %d\n",
b.bytes_per_sec ) ;
printf ( " Sectors per cluster = %d\n",
b.sec_per_clus ) ;
printf ( " Reserved sectors = %d\n",
b.res_sec ) ;
printf ( " FAT copies = %d\n",
b.fat_copies ) ;
printf ( " Root directory entries = %d\n",
b.root_dir_entry ) ;
printf ( " No. of sectors on disk = %u\n",
b.no_sects ) ;
printf ( " Media Descriptor Byte = %X\n",
b.format_id ) ;
printf ( " Sectors per FAT = %d\n",
b.sec_per_fat ) ;
printf ( " Sectors per track = %d\n",
b.sec_per_trk ) ;
printf ( " No.sides = %d\n",
b.no_sides ) ;
printf ( " No. of reserved sectors = %d\n",
b.no_sp_res_sect ) ;
return 0;
}
Opmerkingen over codering:
De structuur boot wordt gebruikt om toegang te krijgen tot de DBR, om de parameters van de schijf te lezen en te schrijven. De functie display_info(), geeft de verschillende parameters van de schijf weer, lezend uit de DBR. De functie Recover_with_values() wordt gebruikt om de parameters van DBR van Floppy te wijzigen en te herstellen.
De waarden die worden gebruikt door de functie Recover_with_values(), zijn voor parameters van 1,44 MB, 3 ½ inch floppydisk's DBR. De beschrijving van deze waarden is gegeven in de onderstaande tabel:
Pagina aangepast op: 17/01/2022
Home