Capítulo – 11
Fazendo backups
Por que fazer backups?
“A prevenção é sempre melhor que a cura”. Fazer backups também é uma parte importante da prevenção de desastres de dados, o que pode nos ajudar a superar a falha do disco ou qualquer outro tipo de perda de dados. Neste capítulo, discutiremos como podemos recuperar os dados mesmo após algumas falhas graves de disco, apenas com a ajuda de backups feitos anteriormente.
A recuperação feita pelos backups armazenados anteriormente é, quase sempre, de até 100%, porém os diversos tipos de travamento de disco podem causar variação nos resultados de recuperação em alguns casos particulares.
Recuperar dados com a ajuda de backups é bastante fácil, rápido e confiável e pode dar os melhores resultados, enquanto a recuperação de dados sem backups é um processo difícil, complicado pode levar muito tempo e, mesmo assim, temos medo de não obtendo os dados 100% em vários casos.
Quando e o que fazer backup
Existem várias áreas diferentes no disco que devem ser copiadas uma vez ou em intervalos de tempo diferentes. A tabela a seguir dá a ideia de medidas de backup completas e ajuda a descobrir quando e o que fazer 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. |
Além disso, você deve fazer um disquete de inicialização de emergência para o sistema. Se houver algum tipo de desastre com os dados em seu disco rígido, você pode inicializar seu sistema com a ajuda deste disquete e analisar o disco em busca de erros.
Backup do MBR (Master Boot Record) e seu uso
O Master Boot Record (MBR) ou às vezes referido como The master partition table (MPT), contém um pequeno programa para carregar e iniciar a partição ativa (ou inicializável) da unidade de disco rígido. O registro mestre de inicialização contém informações sobre todas as quatro partições primárias.
Para um estudo detalhado sobre MBR, consulte o capítulo “Abordagem lógica para discos e SO”, discutido anteriormente neste livro.
O MBR está localizado no Setor Absoluto 0 ou podemos dizer no cilindro 0, cabeça 0 e setor1. Ele é criado no disco rígido executando o comando FDISK.EXE do DOS.
Por que fazer backup do MBR:
O MBR permite que o setor de inicialização da partição ativa receba o controle quando o sistema for iniciado.
Após o Power-On Self Test (POST), o BIOS carrega o MBR (Master Boot Record) do disco rígido na memória e o executa. Primeiro, o MBR verifica se há uma partição ativa no disco rígido, depois carrega o registro de inicialização do DOS (DBR) na memória e passa o controle para o código de inicialização do sistema operacional e, em seguida, o código de registro de inicialização do sistema operacional carrega o restante do sistema operacional em Memória.
Por isso podemos dizer que se o MBR do disco estiver corrompido, o disco rígido está quase morto e o sistema fica completamente incapaz de inicializar ou executar o sistema operacional. Em tal condição, todos os dados armazenados no disco rígido tornam-se inacessíveis. Geralmente as mensagens de erro são exibidas da seguinte forma:
“Tabela de partição inválida” “Erro ao carregar o sistema operacional” “Sistema operacional ausente"
O que pode ser recuperado com o backup do MBR?
O backup do MBR pode ajudá-lo a se livrar das mensagens de erro acima. Com o backup, os seguintes problemas podem ser corrigidos:
- Erro ao carregar o sistema operacional, devido a IPL corrompido (inicializador de programa)
- Partições primárias perdidas
- Informações da partição corrompida
- Número mágico inválido
Escrevendo o programa para fazer backup do MBR:
/* Programa para fazer Backup do 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);
// Abra o arquivo para armazenar o 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");
////Leia o setor de disco especificado \\\\
result = _bios_disk(_DISK_READ, &dinfo);
if ((result & 0xff00) == 0)
{
printf("Disk read from hard disk drive :
successful.\n");
/// Grave 512 bytes de MBR no arquivo \\\\
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;
}
Comentários sobre a codificação do programa:
Na codificação do programa fornecida anteriormente, basicamente estamos realizando as seguintes tarefas passo a passo:
- dinfo aponta para a estrutura diskinfo_t que contém as informações dos parâmetros requeridos pela operação realizada pela função _bios_disk.
- Como queremos ler o primeiro setor do disco, a localização do setor será a seguinte:
| 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 |
- Abra um fluxo de arquivo de nome de arquivo e caminho determinado pelo usuário para armazenar o backup do MBR de exatos 512 bytes. O nome e o caminho do arquivo são armazenados no nome do arquivo da matriz de caracteres.
- _bios_disk(_DISK_READ, &dinfo) lê o primeiro setor do disco rígido (80H), especificado por dinfo.
- O status retornado é armazenado em resultado que é usado para exibir a mensagem de operação bem-sucedida ou para exibir uma mensagem de erro na tela se ocorrer algum erro.
Programa para restaurar o MBR do backup:
Se o MBR estiver corrompido de alguma forma, o programa fornecido a seguir ajuda a restaurar o MBR Back.
Deve-se sempre ter em mente que o uso ilegal ou desconhecimento deste programa pode destruir suas informações de dados no disco rígido e tornar todos os dados inacessíveis. Você deve ter certeza do que vai fazer. Caso contrário, você pode complicar ainda mais o problema.
Programa para restaurar o MBR do backup:
A codificação do programa é a seguinte:
/* Programa para restaurar o backup do MBR a partir do arquivo de 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;
/* Obter a entrada do usuário para o caminho do arquivo de 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);
}
/*Os dados MBR devem ter Exatas 512 Bytes */
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;
}
Comentários sobre a codificação do programa:
Na codificação do programa fornecida acima, basicamente estamos realizando as seguintes tarefas passo a passo:
- dinfo aponta para a estrutura diskinfo_t que contém as informações dos parâmetros requeridos pela operação realizada pela função _bios_disk.
- Como queremos escrever no primeiro setor do disco, a localização do setor será a seguinte:
| 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 |
- O nome do arquivo e o caminho do Backup do MBR, fornecidos pelo usuário, são armazenados na matriz de caracteres nome do arquivo. Deve-se ter em mente que as informações do MBR devem ter exatamente 512 bytes.
- _bios_disk(_DISK_WRITE, &dinfo) grava os dados no primeiro setor do disco rígido (80H), especificado por dinfo.
- O status retornado é armazenado em resultado que é usado para exibir a mensagem de operação bem-sucedida ou para exibir uma mensagem de erro na tela se ocorrer algum erro.
Backup do DBR (DOS Boot Record) e seu uso
Após a tabela de partições, o DOS Boot Record (DBR) ou às vezes chamado DOS Boot Sector é a segunda informação mais importante em seu disco rígido.
Para um estudo detalhado sobre DBR, consulte o capítulo “Abordagem lógica para discos e SO”, discutido anteriormente neste livro.
O primeiro setor lógico de cada partição DOS conterá um DOS Boot Record (DBR) ou DOS Boot Sector. O trabalho do DBR é carregar o sistema operacional do disco rígido para a memória principal do computador e dar o controle do sistema ao programa carregado.
O DOS Boot Record (DBR) para a primeira partição em um disco rígido geralmente é encontrado no Setor Absoluto 63 (o 64º setor na unidade de disco) ou na forma CHS podemos dizer C–H–S = 0–1&ndash ;1 para a maioria das unidades.
No entanto, esta localização pode variar dependendo do SPT (Setores por Pista) do Drive. Por exemplo, em uma unidade antiga de 245 MB com apenas 31 SPT, o Boot Record estava localizado no 32º setor (Absolute Sector 31).
O DBR é criado pelo comando FORMAT do DOS, após o particionamento ser feito usando o comando FDISK. O setor no qual o DBR reside torna-se o setor lógico 1 dessa partição específica para o DOS. O número do setor usado pelo DOS começa no setor físico no qual o DBR está localizado.
O DBR contém um pequeno programa que é executado pelo programa executável Master Boot Record (MBR). Todas as partições do DOS contêm o código do programa para inicializar a máquina, ou seja, carregar o sistema operacional, mas apenas essa partição recebe controle do Master Boot Record que, conforme especificado como partição ativa, na entrada da tabela de partições.
Por que fazer backup do DBR:
O DBR contém algumas informações importantes sobre a geometria do disco. Essas informações estão localizadas no primeiro setor de cada partição, como:
- Código de salto + NOP
- Nome e versão do OEM
- Bytes por setor
- Setores por cluster
- Setores reservados
- Número de cópias do FAT
- Máximo de entradas do diretório raiz (mas não disponível para FAT32)
- Número de setores na partição menor que 32 MB (portanto, não disponível para FAT32)
- Descritor de mídia (F8H para discos rígidos)
- Setores por FAT (em sistemas FAT mais antigos e não disponíveis para FAT32)
- Setores por faixa
- Número de cabeças
- Número de setores ocultos na partição
- Número de setores na partição
- Número de setores por FAT
- Sinalizadores do descritor de informações FAT
- Versão da unidade FAT32
- Número do cluster do início do diretório raiz
- Número do Setor de Informações do Sistema de Arquivos
- Número do setor do setor de inicialização de backup
- Reservado
- Número da partição da unidade lógica
- Assinatura Estendida (29H)
- Número de série da partição
- Nome do volume da partição
- Nome FAT
- Código executável
- Marcador executável ou número mágico (AAH 55H)
Geralmente, as seguintes mensagens de erro são exibidas na tela:
“Falha na inicialização do disco”
“Disco não sistema ou erro de disco”
“Disco de sistema inválido ou erro de E/S de disco”
“Substitua o disco e pressione qualquer tecla…”
O que pode ser recuperado com o Backup do DBR?
O backup do DBR pode ajudá-lo a se livrar das mensagens de erro acima. Essas mensagens de erro Na tela espere o usuário colocar um disco inicializável com os programas mencionados acima no drive de disquete e pressione uma tecla.
A unidade deve estar acessível se você inicializar o sistema a partir do disquete ou CD inicializável. Embora o disco rígido não seja inicializável, isso geralmente não deve afetar o acesso aos dados da unidade de disco. Depois de inicializar o sistema com o disco inicializável, você pode acessar os dados.
Restaurando o backup do DBR Você pode superar os problemas gerados, conforme mencionado acima.
Programs for Making and Restoring Backups of DBR:
The programs for making the Backups of DBR’s and restoring them are almost similar to the programs of MBR backup and to restore.
For example, if you are going to write the programs for making backup of DBR of First logical drive of the disk and to restore it back, the parameters specified by dinfo structure will be changed as follows:
| 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 |
Here we see that only the location of the sector to read/write is changed. Here the C-H-S is given as 0-1-1 as the DBR of first logical drive is stored here.
Imagem de disco completa
Esse tipo de backup está se tornando cada vez mais popular hoje em dia e preferido por organizações que possuem dados muito confidenciais em seus sistemas. Essas pessoas não podem correr o risco de nem mesmo um único por cento de perda de dados.
Tais organizações fazem seus backups como imagem de disco inteira regularmente. Embora demore algum tempo, mas lhe dá a certeza de que você não perderá nada. Devido à sua crescente popularidade, os programadores tentaram ao máximo tornar o software de imagem de disco cada vez mais rápido para minimizar o período de tempo gasto pelo processo de imagem.
A criação de imagens de disco é uma boa ideia, porque apenas gastando algumas dezenas de minutos você pode ter a tranquilidade de ter backup de tudo no seu bolso. Todos os fatores como MBR, BDR, FATs, diretórios raiz são copiados para o disco de destino como está.
O que precisamos para a criação de imagens de disco é um disco rígido de destino Idêntico (ou quase Idêntico), ao nosso disco rígido de origem no qual temos nossos dados valiosos. Uma coisa é sempre mantida em mente que o disco de destino não deve ser menor que o disco de origem.
Depois de obter a imagem completa, se você inicializar o sistema com o disco de destino, no qual você obteve a imagem do disco, geralmente obterá todos os dados como estão.
Escrevendo o programa para imagens de disco completas
O programa para geração de imagens de disco foi apresentado a seguir. O Programa usa as extensões INT 13H, portanto, também pode suportar discos grandes.
O programa faz a imagem da primeira unidade de disco rígido física (0x80) para a segunda unidade de disco rígido física (0x81) portanto antes de fazer a imagem de backup você deve ter em mente que todos os dados no disco de destino (0x81) serão ser substituído pelos dados do disco de origem (0x80) no padrão de setor por setor.
A codificação do programa foi dada a seguir:
/* Programa para fazer a Imagem do Primeiro Disco Rígido (0x80) para o Segundo Disco Rígido (0x81) */
#include<stdio.h>
#include<dos.h>
#include<conio.h>
/* Estrutura a ser utilizada pela função getdrivegeometry usando INT 13H Extension, Function Number 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 */
} ;
/* Estrutura do formato de pacote de endereço de disco, para ser usado pelas funções, 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 */
} ;
///// Função para obter os parâmetros do inversor \\\\\
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 ) ;
/* Invoque o número de função especificado da extensão INT 13H com valores de registro de segmento */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n", g.heads, g.spt, g.cyl);
/* Se a função Get Drive Geometry falhar, exibir mensagem de erro e sair */
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 */
}
////// Início do principal \\\\\\
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 total não. de discos rígidos conectados é menor que dois Exibir mensagem de erro e sair. */
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);
}
/// Obter parâmetros do primeiro disco rígido (0x80) \\\
Sectors_in_HDD1 = getdrivegeometry (0x80);
printf(" Total Sectors in First Hard Disk = %lu\n\n",
Sectors_in_HDD1);
/// Obter parâmetros do segundo disco Hsrd (0x81) \\\
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk = %lu\n\n",
Sectors_in_HDD2);
/// Primeiro confirme, depois prossiga \\\
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);
}
/*O destino não deve ser menor que a Origem*/
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 tudo estiver bem, copie todos os setores do disco de origem para o disco rígido de destino */
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);
}
}
//// Mostrar a mensagem de conclusão\\\
printf("\n\n Disk Imaging is Now Completed, Press any Key
To Exit...");
getch();
}
////Fim do principal
Comentários sobre a codificação:
Na codificação do programa dada anteriormente, para imagem de disco, estamos realizando as seguintes tarefas:
- A estrutura, geometria é usada pela função getdrivegeometry usando INT 13H Extension, Function Number 0x48. Para obter uma descrição detalhada das Extensões INT 13H, consulte o capítulo “Manuseando discos rígidos grandes”, discutido anteriormente neste livro.
Os tipos de dados que representam vários parâmetros do disco têm os seguintes significados:
| 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 |
- A estrutura diskaddrpacket é usada pelas funções readabsolutesectors e writeabsolutesectors. O formato do pacote de endereço de disco foi dado na tabela a seguir:
| 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 |
- A função getdrivegeometry é usada para obter os parâmetros do Drive especificado. A função getdrivegeometry usa o número de função 0x48 de INT 13H Extensions.
O significado dos parâmetros foi descrito na tabela a seguir:
| 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 |
A função int86x(0x13, &i, &o, &s) invoca a interrupção 13H com valores de registro de segmento. A função getdrivegeometry retorna o número total na unidade.
- Na função main(), (char)peekb(0x0040, 0x0075); (a função peekb é definida no DOS.H) retorna o número de discos rígidos conectados ao sistema.
O número de discos rígidos conectados ao sistema é representado pelo byte armazenado no local de memória 0040H:0075H (Segmento 0040H: Offset 0075H). Se o número de discos rígidos conectados ao sistema for menor que dois programas mostra a mensagem de erro e sai.
Sectors_in_HDD1 = getdrivegeometry (0x80); obtém os parâmetros do primeiro disco rígido (0x80) e retorna o número total de setores no primeiro disco rígido.
Da mesma forma, Sectors_in_HDD2 = getdrivegeometry (0x81); obtém os parâmetros do segundo disco rígido (0x81) e retorna o número total de setores no segundo disco rígido.
Após a confirmação do usuário para continuar com a geração de imagens, verifique primeiro a condição de que o tamanho do disco rígido de origem não deve ser maior que o tamanho do disco rígido de destino. Se o destino for menor, exiba a mensagem de erro e saia.
Se tudo estiver indo bem, copie os setores do disco de origem para o disco de destino. Aqui estamos lendo e gravando 61.440 bytes (120 setores com 512 bytes cada) de cada vez para tornar o processo de criação de imagens mais rápido.
Se você quiser usar mais setores por vez, mesmo além do limite de 64 K, poderá fazê-lo usando o “huge Pointer” no modelo de memória grande. O Exemplo de Especificação é o seguinte:
char enorme array[100000L];
- A função, readabsolutesectors ( 0x80, loop, 120, buffer ); lê os 120 setores do primeiro disco rígido (0x80), começando pelo número do setor especificado pelo loop de inteiro longo não assinado e armazena os dados no buffer de dados.
- A Função, writeabsolutesectors ( 0x81, loop, 120, buffer ); grava os dados do buffer de dados em 120 setores do segundo disco rígido (0x81), começando pelo número do setor especificado pelo loop de inteiro longo não assinado.
A codificação das funções readabsolutesectors ( ) e writeabsolutesectors ( ) foram fornecidas a seguir:
//// Função para ler setor(es) absoluto(s) \\\\
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 */
/* para buffer de dados */
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 */
/* Invoque a função especificada de INT 13H com valores de registro de segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /*failure */
else
return 1 ; /* success */
}
//// Função para escrever setor(es) absoluto(s) \\\\
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 */
/*para buffer de dados */
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 ) ;
/*Invoque a função especificada de INT 13H com valores de registro de segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; /* failure */
else
return 1 ; /* success */
}
Comentários sobre a codificação:
Os parâmetros usados por ambas as funções têm os seguintes significados:
| 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 |
Página modificada em: 15/01/2022
Home