| к содержанию |
|
Приведённая ниже программа демонстрирует использование функций интерфейса DPMI, описанного в предыдущей главе. Эта программа может работать только под управлением WINDOWS версий 3.0, 3.1 и только в расширенном режиме на процессорах i80386 или i80486. Такое ограничение связано с тем, что только в расширенном режиме существует понятие виртуальной DOS-машины, и только в этом режиме DOS-программа может воспользоваться сервисом DPMI.
Вы можете также попробовать запустить эту программу под управлением DOS-экстендера, входящего в состав интегрированной системы разработки программ Borland C++ 3.1. Запустите программу DPMIRES.EXE, входящую в состав Borland C++ 3.1, и затем - программу, приведённую ниже. (DOS-экстендеры, входящие в состав Borland C++ 2.0 или 3.0, не вполне совместимы с DPMI, поэтому наш пример с этими системами работать не будет).
Программа начинает свою работу с проверки доступности сервера DPMI, при этом не делается никаких предположений относительно средств, обеспечивающих присутствие DPMI. Это означает, что вы можете проверить работоспособность этой программы в различных средах, предоставляющих интерфейс DPMI, например на виртуальной DOS-машине операционной системы OS/2 версии 2.0.
Программа демонстрирует возможность вызова в защищённом режиме прерываний реального режима. В первой части программы вывод на экран и ввод с клавиатуры выполняется в защищённом режиме, но с использованием привычных вам прерываний реального режима.
Во второй части программы демонстрируется непосредственная запись в видеопамять. При этом для адресации видеопамяти программа заказывает селектор в таблице LDT с помощью специально предназначенных для этого функций DPMI.
Листинг 21. Использование интерфейса DPMI
Файл dpmi.c
-----------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <conio.h>
#include <stdarg.h>
typedef struct {
unsigned long edi, esi, ebp, reserved, ebx, edx, ecx, eax;
unsigned flags, es, ds, fs, gs, ip, cs, sp, ss;
} RM_INT_CALL;
#define MONO_MODE 0x07
#define BW_80_MODE 0x02
#define COLOR_80_MODE 0x03
// Макро для вычисления линейного адреса исходя из
// логического адреса реального режима
#define ABSADDR(seg, ofs) \
((((unsigned long) seg) << 4) + ((ofs) & 0xFFFF))
typedef struct { // байт доступа
unsigned accessed : 1;
unsigned read_write : 1;
unsigned conf_exp : 1;
unsigned code : 1;
unsigned xsystem : 1;
unsigned dpl : 2;
unsigned present : 1;
} ACCESS;
typedef struct { // дескриптор
unsigned limit;
unsigned addr_lo;
unsigned char addr_hi;
ACCESS access;
unsigned reserved;
} DESCRIPTOR;
// Структура для записи информации о памяти
typedef struct {
unsigned long avail_block;
unsigned long max_page;
unsigned long max_locked;
unsigned long linadr_space;
unsigned long total_unlocked;
unsigned long free_pages;
unsigned long tot_phys_pages;
unsigned long free_linspace;
unsigned long size_fp;
char reserved[12];
} PMI;
void dos_exit(unsigned);
void dpmi_init(void);
void set_pmode(void);
void cdecl pm_printf(const char *, ...);
void pm_puts(char *);
void pm_putch(int);
int rm_int(unsigned, unsigned , RM_INT_CALL far *);
int mi_show(void);
unsigned get_sel(void);
int set_descriptor(unsigned pm_sel, DESCRIPTOR far *desc);
void vi_print(unsigned int x, unsigned int y, char *s, char attr);
void vi_hello_msg(void);
void main() {
clrscr();
printf("DOS Protected Mode Interface Demo, © Frolov A.V., 1992\n\r"
"--------------------------------------------------------\n\r\n\r");
// Определяем текущий видеорежим и
// сегментный адрес видеобуфера
video_init();
// Инициализируем защищённый режим
dpmi_init();
printf("\n\r\n\r\n\rДля входа в защищённый режим нажмите любую клавишу...");
getch();
// Входим в защищённый режим
set_pmode();
// Стираем экран и выводим сообщение, находясь в
// защищённом режиме. Пользуемся выводом через
// эмулируемое прерывание реального режима DOS
textcolor(BLACK); textbackground(LIGHTGRAY); clrscr();
pm_printf(" Установлен защищённый режим работы процессора!\n\r"
" ----------------------------------------------\n\r\n\r");
// Выводим текущую информацию о распределении памяти
mi_show();
pm_printf("\n\r\n\r\n\r Для продолжения нажмите любую клавишу...");
getch();
clrscr();
// Получаем селектор для непосредственного доступа к видеопамяти
alloc_videosel();
pm_printf("\n\r\n\r\n\r Для продолжения нажмите любую клавишу...");
getch();
clrscr();
// Выводим сообщения, пользуясь непосредственным доступом
// к видеопамяти
vi_hello_msg();
vi_print(0, 3,
" Для возврата в реальный режим нажмите любую клавишу", 0x7f);
getch();
// Освобождаем полученный селектор
free_videosel();
textcolor(LIGHTGRAY); textbackground(BLACK); clrscr();
// Завершаем работу программы выходом в DOS
dos_exit(0);
}
// -------------------------------------------------
// Процедура для завершения работы программы
// -------------------------------------------------
void dos_exit(unsigned err) {
asm mov ax, err
asm mov ah, 04ch
asm int 21h
}
// -------------------------------------------------
// Инициализация для работы с DPMI
// -------------------------------------------------
union REGS inregs, outregs;
struct SREGS segregs;
void (far *pm_entry)();
unsigned hostdata_seg, hostdata_size, dpmi_flags;
void dpmi_init(void) {
// Проверяем доступность и параметры сервера DPMI
inregs.x.ax = 0x1687;
int86x(0x2F, &inregs, &outregs, &segregs);
if(outregs.x.ax != 0) {
printf("Сервер DPMI не активен."); exit(-1);
}
// Определяем версию сервера DPMI
printf("Версия сервера DPMI: \t\t\t%d.%d\n",
outregs.h.dh, outregs.h.dl);
// Определяем тип процессора
printf("Тип процессора:\t\t\t\t");
if(outregs.h.cl == 2) printf("80286");
else if(outregs.h.cl == 3) printf("80386");
else if(outregs.h.cl == 4) printf("80486");
// Определяем возможность работы с 32-разрядными
// программами
dpmi_flags = outregs.x.bx;
printf("\nПоддержка 32-разрядных программ:\t");
if(dpmi_flags && 1) printf("ПРИСУТСТВУЕТ");
else printf("ОТСУТСТВУЕТ");
// Определяем размер области памяти для сервера DPMI
hostdata_size = outregs.x.si;
printf("\nРазмер памяти для сервера DPMI:\t\t%d байт",
hostdata_size * 16);
// Определяем адрес точки входа в защищённый режим
FP_SEG(pm_entry) = segregs.es;
FP_OFF(pm_entry) = outregs.x.di;
printf("\nАдрес точки входа в защищённый режим: \t%Fp\n",
pm_entry);
// Заказываем память для сервера DPMI
if(hostdata_size) {
if(_dos_allocmem(hostdata_size, &hostdata_seg) != 0) {
printf("Мало стандартной памяти"); exit(-1);
}
}
}
// ------------------------------------------------
// Процедура для установки защищённого режима
// ------------------------------------------------
void set_pmode() {
// Входим в защищённый режим
asm {
mov ax, hostdata_seg
mov es, ax
mov ax, dpmi_flags
}
(*pm_entry)();
}
// -------------------------------------------
// Процедура вывода символа на экран в
// защищённом режиме
// -------------------------------------------
void pm_putch(int chr) {
// Структура для вызова прерывания должна
// быть определена как статическая
static RM_INT_CALL regs;
static RM_INT_CALL far *pregs = (void far *) 0;
// В первый раз инициализируем структуру
// и указатель на неё
if (!pregs) {
pregs = ®s;
memset(pregs, 0, sizeof(RM_INT_CALL));
regs.eax = 0x0200;
}
regs.edx = chr;
// Вызываем прерывание DOS для вывода символа
rm_int(0x21, 0, pregs);
}
// -------------------------------------------
// Процедура вывода строки на экран в
// защищённом режиме
// -------------------------------------------
void pm_puts(char *str_ptr) {
while (*str_ptr) { pm_putch(*str_ptr); str_ptr++; }
}
// -------------------------------------------
// Процедура вывода строки на экран в
// защищённом режиме, аналог функции printf()
// -------------------------------------------
void cdecl pm_printf(const char *fmt, ...)
{
char buffer[512], *sptr=buffer;
va_list marker;
va_start(marker, fmt);
vsprintf(buffer, fmt, marker);
va_end(marker);
while (*sptr) pm_putch(*sptr++);
}
// --------------------------------------------
// Процедура вызова прерывания реального режима
// --------------------------------------------
int rm_int(unsigned int_number, // номер прерывания
unsigned params, // количество слов параметров,
// передаваемых через стек
RM_INT_CALL far *rm_call) // адрес структуры
// для вызова прерывания
{
asm {
push di
push bx
push cx
mov ax, 0300h // функция вызова прерывания
mov bx, int_number
mov cx, params;
les di, rm_call // запись в ES:DI адреса структуры
int 31h // вызов сервера DPMI
jc error
mov ax, 0 // нормальное завершение
jmp short rm_int_end
}
error: asm mov ax, 0 // завершение с ошибкой
rm_int_end: asm pop cx
asm pop bx
asm pop di
}
// -----------------------------------------------------
// Процедура отображает текущее состояние памяти
// -----------------------------------------------------
int mi_show(void) {
PMI minfo, far *minfoptr = &minfo;
unsigned long psize, far *psizeptr=&psize;
unsigned sel;
void far *fp;
get_mi(minfoptr);
pm_printf(" Информация об использовании памяти\n\r"
" ----------------------------------\n\r"
"\r\n Размер максимального доступного блока:\t\t%ld байт"
"\r\n Доступно незафиксированных страниц:\t\t%ld",
minfo.avail_block,
minfo.max_page);
pm_printf("\r\n Доступно зафиксированных страниц:\t\t%ld"
"\r\n Размер линейного адресного пространства:\t%ld страниц"
"\r\n Всего имеется незафиксированных страниц:\t%ld",
minfo.max_locked,
minfo.linadr_space,
minfo.total_unlocked);
pm_printf("\r\n Количество свободных страниц:\t\t\t%ld"
"\r\n Общее количество физических страниц:\t\t%ld",
minfo.free_pages,
minfo.tot_phys_pages);
pm_printf("\r\n Свободное линейное адресное пространство:\t%ld страниц"
"\r\n Размер файла/раздела для страничного обмена:\t%ld страниц",
minfo.free_linspace,
minfo.size_fp);
get_page_size(psizeptr);
pm_printf("\r\n Размер страницы:\t\t\t\t%ld байт\r\n", psize);
// Выводим текущие значения регистров CS и DS
asm mov sel,cs
pm_printf("\n\r CS = %04.4X, ",sel);
asm mov sel,ds
pm_printf("DS = %04.4X",sel);
// Выводим значение текущего приоритетного кольца
fp = (void far *) main;
sel = FP_SEG(fp) & 3;
pm_printf("\n\r Номер приоритетного кольца = %d\n\r",sel);
}
// -----------------------------------------------
// Процедура для получения информации об
// использовании памяти
// -----------------------------------------------
int get_mi(PMI far *minfo) {
asm {
mov ax, 0500h
les di, minfo // ES:DI = адрес структуры DMI
int 31h
jc error
mov ax, 0
jmp short get_mi_end
}
error: asm mov ax, 1
get_mi_end:
}
// ------------------------------------------------
// Процедура для получения размера страницы памяти
// ------------------------------------------------
int get_page_size(long far *page_size) {
asm {
mov ax, 0604h
int 31h
jc error
les di, page_size // ES:DI = адрес page_size
mov es:[di], cx
mov es:[di+2], bx
mov ax, 0
jmp short gps_end
}
error: asm mov ax, 1
gps_end:
}
// --------------------------------------------------
// Определение сегментного адреса видеопамяти
// --------------------------------------------------
unsigned crt_mode, crt_seg;
int video_init(void) {
union REGS r;
// Определяем текущий видеорежим
r.h.ah=15;
int86(0x10,&r,&r);
crt_mode = r.h.al;
if(crt_mode == MONO_MODE) crt_seg = 0xb000;
else if(crt_mode == BW_80_MODE || crt_mode == COLOR_80_MODE)
crt_seg = 0xb800;
else {
printf("\nИзвините, этот видеорежим недопустим.");
exit(-1);
}
}
// ---------------------------------------------------
// Получение селектора для адресации видеопамяти
// ---------------------------------------------------
char far *vid_ptr;
DESCRIPTOR d;
unsigned ldtsel;
int alloc_videosel(void) {
void far *fp;
unsigned long addr;
FP_SEG(vid_ptr) = crt_seg;
FP_OFF(vid_ptr) = 0;
pm_printf(" Адрес видеопамяти реального режима:\t %Fp\r\n", vid_ptr);
// Получаем свободный LDT-селектор
if (! (ldtsel = get_sel())) {
pm_printf(" Ошибка при получении селектора");
dos_exit(-1);
}
pm_printf(" Получен селектор:\t\t\t%04.4X\n\r", ldtsel);
// Подготавливаем дескриптор для полученного селектора
d.limit = 0x2000;
addr = ABSADDR(crt_seg, 0);
d.addr_lo = addr & 0xFFFF;
d.addr_hi = addr >> 16;
d.access.accessed = 0; // не использовался
d.access.read_write = 1; // разрешены чтение/запись
d.access.conf_exp = 0; // не стек
d.access.code = 0; // это сегмент данных
d.access.xsystem = 1; // не системный дескриптор
d.access.dpl = 3; // приоритетное кольцо 3
d.access.present = 1; // сегмент присутствует в памяти
d.reserved = 0;
// Устанавливаем дескриптор
if (!set_descriptor(ldtsel, &d)) {
pm_printf(" Ошибка при установке дескриптора"); getch();
dos_exit(-1);
}
// Выводим на экран адрес видеопамяти
FP_SEG(vid_ptr) = ldtsel;
FP_OFF(vid_ptr) = 0;
pm_printf(" Адрес видеопамяти защищённого режима:\t%Fp\r\n", vid_ptr);
}
// --------------------------------------------------
// Освобождение селектора видеопамяти
// --------------------------------------------------
int free_videosel(void) {
if (!sel_free(ldtsel)) {
pm_printf(" Ошибка при освобождении селектора");
dos_exit(-1);
}
}
// ----------------------------------------------
// Получить один селектор в LDT
// ----------------------------------------------
unsigned get_sel(void) {
asm {
mov ax, 0 // получить селектор
mov cx, 1 // нужен один селектор
int 31h
jc error
jmp short gs_end // AX содержит новый LDT-селектор
}
error: asm mov ax, 0 // произошла ошибка
gs_end:
}
// --------------------------------------------------
// Установить дескриптор для LDT-селектора
// --------------------------------------------------
int set_descriptor(unsigned pm_sel, DESCRIPTOR far *desc) {
asm {
push di
push bx
mov ax, 000Ch
mov bx, pm_sel
les di, desc
int 31h
jc error
mov ax, 1
jmp short sd_end
}
error: asm mov ax, 0
sd_end: asm pop bx
asm pop di
}
// --------------------------------------------------
// Освободить LDT-селектор
// --------------------------------------------------
int sel_free(unsigned pmodesel) {
asm {
mov ax, 0001h
mov bx, pmodesel
int 31h
jc error
mov ax, 1
jmp short done
}
error: asm mov ax, 0
done:
}
// -------------------------------------------------------
// Вывод символа непосредственной записью в видеопамять
// -------------------------------------------------------
void vi_putch(unsigned int x, unsigned int y ,char c, char attr) {
register unsigned int offset;
char far *vid_ptr;
offset=(y*160) + (x*2);
vid_ptr=MK_FP(ldtsel, offset);
*vid_ptr++=c; *vid_ptr=attr;
}
// -------------------------------------------------------
// Вывод строки непосредственной записью в видеопамять
// -------------------------------------------------------
void vi_print(unsigned int x, unsigned int y, char *s, char attr) {
while(*s) vi_putch(x++, y, *s++, attr);
}
// -------------------------------------------------------
// Вывод сообщения непосредственной записью в видеопамять
// -------------------------------------------------------
void vi_hello_msg(void) {
vi_print(0, 0,
" Демонстрация работы с интерфейсом "
"DPMI ¦ © Frolov A.V., 1992 ", 0x30);
}
| к содержанию |
