Comment employer les prolongements 13H INTERNES dans C programmant, nous pouvons appeler les fonctions de prolongation de 13H INTERNE avec les mêmes fonctions de C (int86 (), int86x () etc.), que nous employions dans les chapitres premiers. L'exemple suivant donne le foyer aux trois fonctions (les prolongements de contrôle actuels, lue prolongée et prolongé écrivent)

Comment employer les prolongements 13H INTERNES dans la programmation de C

Nous pouvons appeler les fonctions de prolongation de 13H INTERNE avec les mêmes fonctions de C (int86 (), int86x () etc.), que nous employions dans les chapitres premiers. Apprenons-le par un exemple.

L'exemple suivant donne le foyer aux trois fonctions (les prolongements de contrôle actuels, lue prolongée et prolongé écrivent). Cependant nous n'allons pas à l'utilisation prolongée écrivons la fonction en ce chapitre.

De programme les contrôles d'abord si des prolongements sont soutenus ou pas si les prolongements sont présents pour 13H INTERNE, il lit le secteur absolu 0 (ainsi MBR) du disque. Le codage du programme procède de la façon suivante :

/* Programme pour accéder à des secteurs au delà de 8.46 gigaoctets en utilisant des 13 prolongements INTERNES de BIOS */

#include<stdio.h>
#include<dos.h>

/* Assigns the identifier to the data type */
typedef unsigned char Byte;
typedef unsigned int Word;
typedef unsigned long DWord;

/* disk_packet structure is loaded in DS:SI and command executed */

struct disk_packet
{
Byte size_pack; // Size of packet must be 16 or 16+
Byte reserved1; // Reserved
Byte no_of_blocks;// Number of blocks for transfer
Byte reserved2; // Reserved

/* Address in Segment:Offset format */
Word offset; //offset address
Word segment; //segment address

/* To Support the Disk Even of Capacity of 1152921504.607 GB */

DWord lba1;
DWord lba2;
}disk_pack;

/* Function to check if the Extensions are supported */

void check_ext_present()
{
union REGS inregs, outregs; /* Input Registers and
Output */
inregs.h.ah=0x41; /* Function to Check
Extension Present */
inregs.x.bx=0x55AA;
inregs.h.dl=0x80; /* Drive No for first Hard Disk */

int86(0x13,&inregs,&outregs); /*Call interrupt */

if(outregs.x.cflag)
{
/* Extension Not Supported */
printf("\nBios extension not supported");
exit(1);
}

if(outregs.x.bx==0xAA55)
if(outregs.x.cx & 0x1)

/* Extension Present */
printf("\nExtended I/O supported");
}

/* Function to read the Sector */

void read_sectors(void *buffer)
{
union REGS inregs, outregs; /* Input and Output
Registers */
struct SREGS segregs; // Segment Registers
disk_pack.size_pack=16; // Set size to 16
disk_pack.no_of_blocks=1; // One block
disk_pack.reserved1=0; // Reserved Word
disk_pack.reserved2=0; // Reserved Word
disk_pack.segment=FP_SEG(buffer);// Segment of buffer
disk_pack.offset=FP_OFF(buffer); // Offset of buffer

/* request for MBR of hard disk 1 */
/* Read Absolute sector 0 */

disk_pack.lba1=0; /* LBA address, Contains first
32 bits */

/* We normally require( drives < 2.1 T.B) to set
only this */

disk_pack.lba2=0; // Last 32 bit address
inregs.h.ah=0x42; // Function to read
inregs.h.dl=0x80; // Drive Number for First Hard Disk inregs.x.si = FP_OFF(&disk_pack); /*Make DS:SI point
to disk_pack */
segregs.ds = FP_SEG(&disk_pack);

/* Call Interrupt */
int86x(0x13,&inregs,&outregs,&segregs);

if(outregs.x.cflag)
printf("\n\nError %d\n",outregs.h.ah);
else
printf("\n\nI hope Everything is all Right");
}

//// Write Sector Function \\\\

void write_sector()
{

/* On lui écrira comme les read_sectors fonctionnent, à moins que le nombre de fonction, qui sera 0x43 dans cette fonction. Nous discuterons prolongé écrivons la fonction en prochains chapitres.

Avant d'employer cette fonction svp vérifier et vérifier ce qui sont toi allant faire. Vous devriez avoir la connaissance appropriée de ce que vous allez faire. L'utilisation de cette fonction dans le manque de la connaissance ou négligemment peut détruire vos données. */

}

/// Main Function \\\\
void main()
{
int i=0;

/* buffer to hold MBR */
Byte mbr[512];
clrscr();

/* check for BIOS extension present */
check_ext_present();

/* read sector */
read_sectors(&mbr);

printf("\n\n Data of MBR \n");
printf("▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀\n\n\n");
while(i++<512)
{
/* display the MBR buffer */
printf("%c",mbr[i]);
}
}

Commentaires sur le codage du programme

le typedef assigne à la marque au type de données tels que byte non signé de char de typedef ; assigne le byte de marque pour le type de données char. De même le Word de marque est assigné à interne et DWord est assigné pour désirer ardemment.

La structure de disk_packet est chargée dans le DS : Le SI et la commande (telle que lue prolongée, prolongé écrire ou vérifier etc.) est exécuté. Voir les fonctions des prolongements 13H INTERNES d'IBM/MS (fonction 41H à fonctionner 49H) donnés avant.

Les contrôles de fonctionnement check_ext_present() si les prolongements sont disponibles/soutenus ou pas. La fonction s'appelle avec BX=55AAH (inregs.x.bx=0x55AA ;) et si des prolongements sont soutenus le registre de BX est placé à AA55H. (Voir la fonction 41H donnée avant)

Les read_sectors de fonction est employés pour lire le secteur absolu du disque, indiqué par disk_pack.lba1. Dans ce programme nous avons donné disk_pack.lba1=0, de ce fait nous allons lire le secteur absolu 0 (voir la note ci-dessous) allant de ce fait lire le MBR du disque.

La fonction de write_sector est également même que les read_sectors fonctionnent et seront écrit de la même manière mais avec les différentes options de fonction. Nous l'emploierons dans les prochains chapitres.

Note:

Nous avons lu les secteurs de disque des deux manières suivantes :

1. Le secteur relatif a lu (ou écrire)
2. Secteur absolu lu (ou écrire)

Dans le secteur relatif lu nous avons lu les secteurs de disque selon la géométrie de CHS (cylindre, principal et secteur) du disque. Dans le secteur relatif lu le MBR du disque (premier secteur du disque) est sur le cylindre 0, la tête 0 et le secteur 1.

Dans la lecture absolue des secteurs de disque, nous n'avons pas besoin d'indiquer le cylindre ou les nombres principaux dans notre programme. Les secteurs absolus sont comptés du secteur absolu 0.

Ainsi si nous allons lire le MBR du disque (premier secteur du disque), nous allons lire le secteur absolu 0. C'est le travail du BIOS pour convertir le nombre absolu de secteur en son nombre correspondant de cylindre, principal et de secteur.

Comme dans la lecture absolue de secteur (ou l'écriture), nous devons calculer seulement les secteurs absolus dans la boucle dans les opérations telles que la lecture entière de disque ou l'écriture, tandis qu'en cas de lecture relative de secteur (ou d'écriture), nous devons courir trois boucles à la fois pour calculer la lecture/écriture absolues de secteur de CHS donc est beaucoup plus rapide que la lecture/écriture relatives de secteur.

Par exemple, si nous avons n'importe quel disque dur avec les 16 chefs (côtés), 12 cylindres et avec 63 secteurs, la table donnée après, des expositions le procédé et la différence les des deux les méthodes et ainsi expositions de lecture comment l'approche absolue de secteur peut faire notre temps prenant des programmes (tels que l'écriture entière de lecture de disque ou le disque entier essuyant programmes etc.) à la course beaucoup plus rapidement :

L'information de la table de cloison de MBR, qui est montré par n'importe quel disque MBR analysant l'outil, a été fournie ci-dessous :

Dans l'information ci-dessus, les nombres relatifs de secteur pour commencer des deux cloisons sont 63 et 11277630 respectivement, qui sont exemptes des cloisons et sont comptées selon le nombre de secteurs, disponible dans le disque.

page 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 19 | 20

Chapter 10 page 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 page 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33