Capitolo – 11
Fare backup
Perché i backup?
“Prevenire è sempre meglio che curare”. Anche l'esecuzione di backup è una parte importante della prevenzione del disastro dei dati, che può aiutarci a superare il crash del disco o qualsiasi altro tipo di perdita di dati. In questo capitolo discuteremo di come recuperare i dati anche dopo alcuni gravi crash del disco, solo con l'aiuto di backup precedentemente effettuati.
Il ripristino eseguito dai backup archiviati in precedenza è, quasi sempre, fino al 100 percento, tuttavia i diversi tipi di crash del disco possono causare la variazione dei risultati del ripristino in alcuni casi particolari.
Recuperare i dati con l'aiuto dei backup è abbastanza facile, veloce e affidabile e può dare i migliori risultati mentre il recupero dei dati senza backup è un processo difficile, complicato può richiedere molto tempo e anche in questo caso abbiamo paura non ottenendo i dati del 100 percento in diversi casi.
Quando e cosa eseguire il backup
Ci sono diverse aree del disco di cui è necessario eseguire il backup una volta o a intervalli di tempo diversi. La tabella seguente dà l'idea delle misure di backup complete e aiuta a scoprire quando e cosa eseguire il backup:
| 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. |
Oltre a questo dovresti creare un floppy di avvio di emergenza per il sistema. Se si verifica un qualsiasi tipo di disastro con i dati nel tuo disco rigido, puoi avviare il tuo sistema con l'aiuto di questo floppy e analizzare il disco per errori.
Backup di MBR (Master Boot Record) e suo utilizzo
Il Master Boot Record (MBR) o talvolta indicato come la tabella delle partizioni master (MPT), contiene un piccolo programma per caricare e avviare la partizione attiva (o avviabile) dal disco rigido. Il record di avvio principale contiene informazioni su tutte e quattro le partizioni primarie.
Per uno studio dettagliato sull'MBR, fare riferimento al capitolo "Approccio logico a dischi e sistemi operativi", discusso in precedenza in questo libro.
L'MBR si trova nel settore assoluto 0 o possiamo dire nel cilindro 0, testa 0 e settore1. Viene creato sul disco rigido eseguendo il comando FDISK.EXE di DOS.
Perché eseguire il backup dell'MBR:
MBR consente al settore di avvio della partizione attiva di ricevere il controllo all'avvio del sistema.
Dopo il POST (Power-On Self Test), il BIOS carica l'MBR (Master Boot Record) dal disco rigido nella memoria e quindi lo esegue. Prima l'MBR controlla l'hard disk per una partizione attiva, quindi carica il DOS Boot Record (DBR) in memoria e passa il controllo al codice di avvio del sistema operativo, quindi il codice del record di avvio del sistema operativo carica il resto del sistema operativo in Memoria.
Quindi possiamo dire che se l'MBR del disco è danneggiato, il disco rigido è quasi morto e il sistema non è completamente in grado di avviare o eseguire il sistema operativo. In tale condizione, tutti i dati memorizzati nell'hard disk, diventano inaccessibili. Generalmente i messaggi di errore vengono visualizzati come segue:
“Tabella delle partizioni non valida” “Errore durante il caricamento del sistema operativo” “Sistema operativo mancante"
Cosa è possibile recuperare con il backup di MBR?
Il backup di MBR può aiutarti a eliminare i messaggi di errore sopra riportati. Con il backup è possibile correggere i seguenti problemi:
- Errore durante il caricamento del sistema operativo, dovuto a IPL (Initial Program Loader) danneggiato
- Partizione/e primaria/e perse
- Informazioni sulla partizione danneggiata
- Numero Magic non valido
Scrittura del programma per eseguire il backup di MBR:
/* Programma per eseguire il backup di 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);
// Apri il file per archiviare il backup MBR \\
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");
//// Leggi il settore dei dischi specificato \\\\
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Disk read from hard disk drive :
successful.\n");
/// Scrivi 512 byte di MBR nel file \\\\
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;
}
Commenti sulla codifica del programma:
Nella codifica del programma data in precedenza, fondamentalmente stiamo procedendo a eseguire le seguenti attività passo dopo passo:
- dinfo punta alla struttura diskinfo_t che contiene le informazioni sui parametri richiesti dall'operazione eseguita dalla funzione _bios_disk.
- Dato che vogliamo leggere il primo settore del disco, la posizione del settore sarà la seguente:
| 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 |
- Aprire un flusso di file di nome file e percorso dati dall'utente per archiviare il backup di MBR di 512 byte esatti. Il nome e il percorso del file sono memorizzati nella matrice di caratteri nomefile.
- _bios_disk(_DISK_READ, &dinfo) legge il primo settore del disco rigido (80H), specificato da dinfo.
- Lo stato restituito viene memorizzato nel risultato utilizzato per visualizzare il messaggio di avvenuta operazione o per visualizzare un messaggio di errore sullo schermo in caso di errore.
Programma per ripristinare l'MBR dal backup:
Se l'MBR è danneggiato in qualche modo, il programma fornito di seguito aiuta a ripristinare l'MBR indietro.
Bisogna sempre tenere a mente che l'uso illegale o l'uso inconsapevole di questo programma può distruggere le informazioni dei tuoi dati nel disco rigido e può rendere inaccessibili tutti i dati. Dovresti essere sicuro di quello che farai. Altrimenti potresti complicare ulteriormente il problema.
Programma per ripristinare l'MBR dal backup:
La codifica del programma è la seguente:
/* Programma per ripristinare il backup di MBR dal file di backup */
#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;
/* Ottieni l'input utente per il percorso del file di backup MBR */
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);
}
/* I dati MBR devono essere di 512 byte esatti */
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;
}
Commenti sulla codifica del programma:
Nella codifica del programma data sopra, sostanzialmente stiamo procedendo a eseguire le seguenti attività passo dopo passo:
- dinfo punta alla struttura diskinfo_t che contiene le informazioni sui parametri richiesti dall'operazione eseguita dalla funzione _bios_disk.
- Dato che vogliamo scrivere sul primo settore del disco, la posizione del settore sarà la seguente:
| 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 |
- Il nome del file e il percorso del backup dell'MBR, forniti dall'utente, sono archiviati nel nome del file dell'array di caratteri. Va tenuto presente che le informazioni MBR dovrebbero essere di 512 byte esatti.
- _bios_disk(_DISK_WRITE, &dinfo) scrive i dati sul primo settore del disco rigido (80H), specificato da dinfo.
- Lo stato restituito viene memorizzato nel risultato utilizzato per visualizzare il messaggio di avvenuta operazione o per visualizzare un messaggio di errore sullo schermo in caso di errore.
Backup di DBR (DOS Boot Record) e suo utilizzo
Dopo la tabella delle partizioni, il DOS Boot Record (DBR) o talvolta chiamato DOS Boot Sector è la seconda informazione più importante sul disco rigido.
Per uno studio dettagliato su DBR, fare riferimento al capitolo “Approccio logico a dischi e sistemi operativi”, discusso in precedenza in questo libro.
Il primo settore logico di ciascuna partizione DOS conterrà un record di avvio DOS (DBR) o un settore di avvio DOS. Il compito del DBR è caricare il sistema operativo dall'unità disco rigido nella memoria principale del computer e dare il controllo del sistema al programma caricato.
Il DOS Boot Record (DBR) per la prima partizione su un disco rigido si trova solitamente in Absolute Sector 63 (il 64° settore dell'unità disco) o in forma CHS possiamo dire C–H–S = 0–1&ndash ;1 per la maggior parte delle unità.
Tuttavia, questa posizione può variare a seconda dell'SPT (Settori per traccia) del Drive. Ad esempio, su una vecchia unità da 245 MB con solo 31 SPT, il record di avvio si trovava nel 32° settore (Settore 31 assoluto).
Il DBR viene creato dal comando FORMAT di DOS, dopo che il partizionamento è stato eseguito utilizzando il comando FDISK. Il settore su cui risiede DBR diventa il settore logico 1 di quella particolare partizione per il DOS. Il numero di settore utilizzato da DOS inizia dal settore fisico su cui si trova DBR.
Il DBR contiene un piccolo programma che viene eseguito dal programma eseguibile Master Boot Record (MBR). Tutte le partizioni DOS contengono il codice del programma per avviare la macchina, ovvero caricare il sistema operativo, ma solo quella partizione riceve il controllo dal Master Boot Record che è specificato come partizione attiva, nella voce della tabella delle partizioni.
Perché eseguire il backup di DBR:
Il DBR contiene alcune informazioni importanti sulla geometria del disco. Queste informazioni si trovano nel primo settore di ogni partizione, ad esempio:
- Codice salto + NOP
- Nome e versione OEM
- Byte per settore
- Settori per cluster
- Settori Riservati
- Numero di copie di FAT
- Numero massimo di voci nella directory principale (ma non disponibile per FAT32)
- Numero di settori nella partizione inferiore a 32 MB (quindi non disponibile per FAT32)
- Descrittore multimediale (F8H per dischi rigidi)
- Settori per FAT (nei vecchi sistemi FAT e non disponibile per FAT32)
- Settori per traccia
- Numero di capi
- Numero di settori nascosti nella partizione
- Numero di settori in partizione
- Numero di settori per FAT
- Flag del descrittore delle informazioni FAT
- Versione dell'unità FAT32
- Numero del cluster dell'inizio della directory principale
- Numero di settore del settore delle informazioni sul file system
- Numero di settore del settore di avvio di backup
- Riservato
- Numero di partizione dell'unità logica
- Firma estesa (29H)
- Numero di serie della partizione
- Nome volume della partizione
- Nome FAT
- Codice eseguibile
- Marcatore eseguibile o numero magico (AAH 55H)
In genere, sullo schermo vengono visualizzati i seguenti messaggi di errore:
“Errore di avvio del disco”
“Disco non di sistema o errore del disco”
“Disco di sistema non valido o errore di I/O del disco”
“Sostituisci il disco, quindi premi un tasto qualsiasi…”
Cosa è possibile recuperare con il backup di DBR?
Il backup di DBR può aiutarti a eliminare i messaggi di errore sopra riportati. Questi messaggi di errore sullo schermo aspettano che l'utente inserisca un disco di avvio con i programmi sopra menzionati nell'unità floppy e prema un tasto.
L'unità dovrebbe essere accessibile se si avvia il sistema dal floppy o dal CD avviabile. Sebbene il disco rigido non sia avviabile, in genere ciò non dovrebbe influire sull'accesso ai dati dell'unità disco. Dopo aver avviato il sistema con il disco di avvio è possibile accedere ai dati.
Ripristinando il backup di DBR puoi superare i problemi generati, come accennato in precedenza.
Programmi per la creazione e il ripristino di backup di DBR:
I programmi per eseguire i backup dei DBR e ripristinarli sono quasi simili ai programmi di backup e ripristino MBR.
Ad esempio, se stai per scrivere i programmi per fare il backup del DBR della prima unità logica del disco e per ripristinarlo, i parametri specificati dalla struttura dinfo verranno modificati come segue:
| 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 |
Qui vediamo che viene modificata solo la posizione del settore da leggere/scrivere. Qui il C-H-S è dato come 0-1-1 poiché il DBR della prima unità logica è memorizzato qui.
Imaging del disco completo
Questo tipo di backup sta diventando sempre più popolare al giorno d'oggi ed è il preferito da tali organizzazioni che hanno dati molto sensibili nei loro sistemi. Le persone non possono correre il rischio nemmeno di una singola percentuale di perdita di dati.
Tali organizzazioni eseguono regolarmente i backup come immagine intera del disco. Anche se ci vuole del tempo, ma ti dà la certezza che non ti mancherà nulla. A causa della sua crescente popolarità, i programmatori hanno fatto del loro meglio per rendere il software di imaging del disco sempre più veloce per ridurre al minimo il periodo di tempo impiegato dal processo di imaging.
L'imaging del disco è una buona idea perché solo spendendo qualche decina di minuti puoi avere la tranquillità di avere il backup di tutto in tasca. Tutti i fattori come MBR, BDR, FAT, directory principali vengono copiati sul disco di destinazione così com'è.
Ciò di cui abbiamo bisogno per l'imaging del disco è un disco rigido di destinazione identico (o quasi identico), al nostro disco rigido di origine in cui abbiamo i nostri dati preziosi. Una cosa è sempre tenuta a mente che il disco di destinazione non dovrebbe essere più piccolo del disco di origine.
Dopo aver preso l'immagine completa, se avvii il sistema con il disco di destinazione, in cui hai preso l'immagine del disco, generalmente otterrai tutti i dati così come sono.
Scrittura del programma per l'imaging del disco completo
In seguito è stato fornito il programma per l'imaging del disco. Il Programma utilizza le estensioni INT 13H quindi può supportare anche dischi di grandi dimensioni.
Il programma esegue l'immagine del primo disco rigido fisico (0x80) sul secondo disco rigido fisico (0x81), quindi prima di creare l'immagine di backup dovresti tenere presente che tutti i dati nel disco di destinazione (0x81) verranno essere sovrascritto dai dati del disco di origine (0x80) nel modello settore per settore.
La codifica del programma è stata data di seguito:
/* Programma per trasformare l'immagine del primo disco rigido (0x80) nel secondo disco rigido (0x81) */
#include<stdio.h>
#include<dos.h>
#include<conio.h>
/* Struttura che deve essere utilizzata dalla funzione getdrivegeometry utilizzando l'estensione INT 13H, numero funzione 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 */
} ;
/* Struttura del formato del pacchetto Disk Address, da utilizzare con le funzioni, readabsolutesectors e writeabsolutesectors */
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 */
} ;
///// Funzione per ottenere i parametri dell'unità \\\\\
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 ) ;
/* Richiama il numero di funzione specificato dell'interno INT 13H con valori del registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n", g.heads, g.spt, g.cyl);
/* Se la funzione Get Drive Geometry non riesce, visualizza un messaggio di errore ed esci */
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 */
}
////// Inizio del principale \\\\\\
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();
/* Se il totale n. di dischi rigidi collegati è inferiore a due Visualizza messaggio di errore ed esci. */
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);
}
/// Ottieni i parametri del primo disco rigido (0x80) \\\
Sectors_in_HDD1 = getdrivegeometry (0x80);
printf(" Total Sectors in First Hard Disk = %lu\n\n",
Sectors_in_HDD1);
/// Ottieni parametri del secondo disco Hsrd (0x81) \\\
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk = %lu\n\n",
Sectors_in_HDD2);
/// Prima conferma, poi procedi \\\
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);
}
/* La destinazione non deve essere inferiore alla sorgente */
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);
}
/* Se tutto è a posto, copia tutti i settori del disco di origine sul disco rigido di destinazione */
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);
}
}
//// Mostra il messaggio di completamento \\\
printf("\n\n Disk Imaging is Now Completed, Press any Key
To Exit...");
getch();
}
//// End of main
Commenti sulla codifica:
Nella codifica del programma data in precedenza, per l'imaging del disco stiamo procedendo eseguendo le seguenti attività:
- La struttura, la geometria viene utilizzata dalla funzione getdrivegeometry utilizzando l'estensione INT 13H, numero funzione 0x48. Per una descrizione dettagliata delle estensioni INT 13H, fare riferimento al capitolo "Gestione di dischi rigidi di grandi dimensioni", discusso in precedenza in questo libro.
I tipi di dati che rappresentano diversi parametri del disco hanno i seguenti significati:
| 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 |
- La struttura diskaddrpacket è utilizzata dalle funzioni readabsolutesectors e writeabsolutesectors. Il formato del pacchetto di indirizzi del disco è stato fornito nella tabella seguente:
| 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 |
- La funzione getdrivegeometry viene utilizzata per ottenere i parametri dell'azionamento specificato. La funzione getdrivegeometry utilizza la funzione numero 0x48 delle estensioni INT 13H.
Il significato dei parametri è stato descritto nella tabella seguente:
| 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 |
La funzione int86x(0x13, &i, &o, &s) richiama l'interrupt 13H con i valori del registro di segmento. La funzione getdrivegeometry restituisce il numero totale sull'unità.
- Nella funzione main(), (char)peekb(0x0040, 0x0075); (la funzione peekb è Definita in DOS.H) restituisce il numero di dischi rigidi collegati al sistema.
Il numero di dischi rigidi collegati al sistema è rappresentato dal byte archiviato nella posizione di memoria 0040H:0075H (segmento 0040H: offset 0075H). Se il numero di dischi rigidi collegati al sistema è inferiore a due programmi mostra il messaggio di errore ed esce.
Settori_in_HDD1 = getdrivegeometry (0x80); ottiene i parametri del primo disco rigido (0x80) e restituisce il numero totale di settori sul primo disco rigido.
Allo stesso modo, Settori_in_HDD2 = getdrivegeometry (0x81); ottiene i parametri del secondo disco rigido (0x81) e restituisce il numero totale di settori sul secondo disco rigido.
Dopo la conferma da parte dell'utente di continuare con l'imaging, verificare prima la condizione che la dimensione del disco rigido di origine non sia maggiore della dimensione del disco rigido di destinazione. Se la destinazione è più piccola, Visualizza il messaggio di errore ed esci.
Se tutto va bene, copia i settori del disco di origine sul disco di destinazione. Qui leggiamo e scriviamo 61440 byte (120 settori con ciascuno di 512 byte) alla volta per rendere il processo di imaging più veloce.
Se vuoi utilizzare più settori alla volta, anche oltre il limite di 64K, puoi farlo utilizzando “huge Pointer” nel modello di memoria grande. L'esempio di specifica è il seguente:
array enorme di caratteri[100000L];
- La funzione, readabsolutesectors ( 0x80, loop, 120, buffer ); legge i 120 settori del primo disco rigido (0x80), partendo dal numero di settore specificato da unsigned long integer loop e memorizza i dati nel buffer di dati.
- La funzione, writeabsolutesectors ( 0x81, loop, 120, buffer ); scrive i dati del buffer di dati in 120 settori del secondo disco rigido (0x81), a partire dal numero di settore specificato dal ciclo intero lungo senza segno.
Di seguito è stata data la codifica delle funzioni readabsolutesectors ( ) e writeabsolutesectors ( ):
//// Funzione per leggere i settori assoluti \\\\
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 */
/* per Buffer dati */
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 */
/* Richiama la funzione specificata di INT 13H con valori di registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /*failure */
else
return 1 ; /* success */
}
//// Funzione per scrivere i settori assoluti \\\\
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 */
/* per Buffer dati */
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 ) ;
/* Richiama la funzione specificata di INT 13H con valori di registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /* failure */
else
return 1 ; /* success */
}
Commenti sulla codifica:
I parametri utilizzati da entrambe le funzioni hanno i seguenti significati:
| 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 modificata il: 10/03/2022
Casa