Электронная библиотека книг Александра Фролова и Григория Фролова.
 
Библиотека
Братьев
Фроловых
Электронная библиотека книг Александра Фролова и Григория Фролова.
Библиотека системного программиста
Программирование на JAVA
ПК. Шаг за шагом
Другие книги
Восстановление данных
Антивирусная защита
Статьи для
программистов
Пользователю компьютера

Защищенный режим процессоров Intel 80286/80386/80486

© Александр Фролов, Григорий Фролов
Том 4, М.: Диалог-МИФИ, 1993, 234 стр.

[Назад] [Содеожание] [Дальше]

4.4. Пример мультизадачного монитора

Для того, чтобы вы могли почувствовать мультизадачность, мы подготовили пример программы, реализующей параллельную работу нескольких задач в режиме разделения времени.

Эта программа состоит из нескольких модулей, составленных на языках ассемблера и Си.

Первые два файла предназначены для определения используемых констант и структур данных.

Листинг 4. Определение констант и структур для модулей,
                составленных на языке ассемблера.

Файл tos.inc
-----------------------------------------------------------

CMOS_PORT               equ     70h
PORT_6845               equ     63h
COLOR_PORT      equ     3d4h
MONO_PORT               equ     3b4h
STATUS_PORT     equ     64h
SHUT_DOWN               equ     0feh
INT_MASK_PORT   equ     21h
VIRTUAL_MODE    equ     0001
A20_PORT                equ     0d1h
A20_ON          equ     0dfh
A20_OFF         equ     0ddh
EOI                     equ     20h
MASTER8259A     equ     20h
SLAVE8259A      equ     0a0h
KBD_PORT_A      equ     60h
KBD_PORT_B      equ     61h

L_SHIFT         equ     0000000000000001b
NL_SHIFT                equ     1111111111111110b
R_SHIFT         equ     0000000000000010b
NR_SHIFT                equ     1111111111111101b

L_CTRL          equ     0000000000000100b
NL_CTRL         equ     1111111111111011b
R_CTRL          equ     0000000000001000b
NR_CTRL         equ     1111111111110111b

L_ALT           equ     0000000000010000b
NL_ALT          equ     1111111111101111b
R_ALT           equ     0000000000100000b
NR_ALT          equ     1111111111011111b

CAPS_LOCK               equ     0000000001000000b
SCR_LOCK                equ     0000000010000000b
NUM_LOCK                equ     0000000100000000b
INSERT          equ     0000001000000000b


STRUC   idtr_struc
        idt_len dw      0
        idt_low dw      0
        idt_hi  db      0
        rsrv    db      0
ENDS            idtr_struc

Листинг 5. Определение констант и структур для модулей,
                составленных на языке Си.

Файл tos.h
-----------------------------------------------------------

#define word unsigned int

// Селекторы, определённые в GDT

#define CODE_SELECTOR        0x08 // сегмент кода
#define DATA_SELECTOR        0x10 // сегмент данных

#define TASK_1_SELECTOR            0x18 // задача TASK_1
#define TASK_2_SELECTOR            0x20 // задача TASK_2
#define MAIN_TASK_SELECTOR      0x28 // главная задача

#define VID_MEM_SELECTOR          0x30 // сегмент видеопамяти
#define IDT_SELECTOR            0x38 // талица IDT

#define KEYBIN_TASK_SELECTOR    0x40 // задача ввода с клавиатуры
#define KEYB_TASK_SELECTOR       0x48 // задача обработки
                                                  // клавиатурного прерывания
#define FLIP_TASK_SELECTOR       0x50 // задача FLIP_TASK

// Байт доступа

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 descriptor {
        word limit;
        word base_lo;
        unsigned char base_hi;
        unsigned char type_dpl;
        unsigned reserved;
} descriptor;

// Структура вентиля вызова, задачи, прерывания,
// исключения

typedef struct gate {
        word offset;
        word selector;
        unsigned char count;
        unsigned char type_dpl;
        word reserved;
} gate;

// Структура сегмента состояния задачи TSS

typedef struct tss {
        word link;      // поле обратной связи

        word sp0;               // указатель стека кольца 0
        word ss0;
        word sp1;               // указатель стека кольца 1
        word ss1;
        word sp2;               // указатель стека кольца 1
        word ss2;

        word ip;                // регистры процессора
        word flags;
        word ax;
        word cx;
        word dx;
        word bx;
        word sp;
        word bp;
        word si;
        word di;
        word es;
        word cs;
        word ss;
        word ds;
        word ldtr;
} tss;

// Размеры сегментов и структур

#define TSS_SIZE            (sizeof(tss))
#define DESCRIPTOR_SIZE     (sizeof(descriptor))
#define GATE_SIZE           (sizeof(gate))
#define IDT_SIZE            (sizeof(idt))

// Физические адреса видеопамяти для цветного
// и монохромного видеоадаптеров

#define COLOR_VID_MEM       0xb8000L
#define MONO_VID_MEM        0xb0000L

// Видеоржеимы

#define MONO_MODE           0x07 // монохромный
#define BW_80_MODE          0x02 // монохромный, 80 символов
#define COLOR_80_MODE       0x03 // цветной, 80 символов

// Значения для поля доступа

#define TYPE_CODE_DESCR     0x18
#define TYPE_DATA_DESCR     0x10
#define TYPE_TSS_DESCR      0x01
#define TYPE_CALL_GATE      0x04
#define TYPE_TASK_GATE      0x85
#define TYPE_INTERRUPT_GATE 0x86
#define TYPE_TRAP_GATE      0x87

#define SEG_WRITABLE        0x02
#define SEG_READABLE        0x02
#define SEG_PRESENT_BIT     0x80

// Константы для обработки аппаратных
// прерываний

#define EOI                             0x20
#define MASTER8259A             0x20
#define SLAVE8259A                      0xa0

// Макро для формирования физического
// адреса из компонент сегменоного адреса
// и смещения

#define MK_LIN_ADDR(seg,off) (((unsigned long)(seg))<<4)+(word)(off)

// Тип указателя на функцию типа void без параметров

typedef void (func_ptr)(void);




Файл tos.c (листинг 6) содержит основную программу, которая инициализирует процессор для работы в защищённом режиме и запускает все задачи. С помощью функции с названием Init_And_Protected_Mode_Entry() мы попадаем в защищённый режим и выводим сообщение на экран о том, что в главной задаче установлен защищённый режим. Регистр TR загружается селектором главной задачи при помощи функции load_task_register().

Сразу после этого программа переключается на выполнение задачи TASK_1. Эта задача просто выводит сообщение о своём запуске на экран и возвращает управление главной задаче. Цель этой процедуры - продемонстрировать процесс переключения задач с помощью команды JMP.

После возврата в главную задачу программа размаскирует прерывания от клавиатуры и таймера. Как только начинают поступать и обрабатываться прерывания таймера, оживают остальные задачи, определённые при инициализации системы.

Начиная с этого момента главная задача разделяет процессорное время наравне с остальными задачами. Что же она делает?

Главная задача сбрасывает семафор с номером 0, вслед за чем ожидает его установку. Этот семафор устанавливается задачей, которая занимается вводом символов с клавиатуры и выводит на экран скан-коды клавиш, а также состояние переключающих клавиш. Как только окажется нажатой клавиша ESC, задача ввода символов с клавиатуры устанавливает семафор 0, что и приводит к завершению работы главной задачи.

Перед тем, как завершить работу, главная задача устанавливает реальный режим работы процессора, стирает экран и возвращает управление операционной системе.

Листинг 6. Программа мультизадачного монитора.

Файл tos.c
-----------------------------------------------------------


#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <conio.h>
#include "tos.h"

// --------------------------------
// Определения вызываемых функций
// --------------------------------

void Init_And_Protected_Mode_Entry(void);

void protected_mode(unsigned long gdt_ptr, unsigned int gdt_size,
                word cseg, word dseg);

word load_task_register(word tss_selector);
void real_mode(void);
void jump_to_task(word tss_selector);
void load_idtr(unsigned long idt_ptr, word idt_size);
void Keyb_int(void);
void    Timer_int(void);
void Int_30h_Entry(void);

extern  word kb_getch(void);
void            enable_interrupt(void);

void    task1(void);
void    task2(void);
void            flipflop_task(void);
void     keyb_task(void);

void init_tss(tss *t, word cs, word ds,
                        unsigned char *sp, func_ptr ip);

void init_gdt_descriptor(descriptor *descr, unsigned long base,
                        word limit, unsigned char type);

void  exception_0(void); //{ prg_abort(0); }
void  exception_1(void); //{ prg_abort(1); }
void  exception_2(void); //{ prg_abort(2); }
void  exception_3(void); //{ prg_abort(3); }
void  exception_4(void); //{ prg_abort(4); }
void  exception_5(void); //{ prg_abort(5); }
void  exception_6(void); //{ prg_abort(6); }
void  exception_7(void); //{ prg_abort(7); }
void  exception_8(void); //{ prg_abort(8); }
void  exception_9(void); //{ prg_abort(9); }
void  exception_A(void); //{ prg_abort(0xA); }
void  exception_B(void); //{ prg_abort(0xB); }
void  exception_C(void); //{ prg_abort(0xC); }
void  exception_D(void); //{ prg_abort(0xD); }
void  exception_E(void); //{ prg_abort(0xE); }
void  exception_F(void); //{ prg_abort(0xF); }
void  exception_10(void); //{ prg_abort(0x10); }
void  exception_11(void); //{ prg_abort(0x11); }
void  exception_12(void); //{ prg_abort(0x12); }
void  exception_13(void); //{ prg_abort(0x13); }
void  exception_14(void); //{ prg_abort(0x14); }
void  exception_15(void); //{ prg_abort(0x15); }
void  exception_16(void); //{ prg_abort(0x16); }
void  exception_17(void); //{ prg_abort(0x17); }
void  exception_18(void); //{ prg_abort(0x18); }
void  exception_19(void); //{ prg_abort(0x19); }
void  exception_1A(void); //{ prg_abort(0x1A); }
void  exception_1B(void); //{ prg_abort(0x1B); }
void  exception_1C(void); //{ prg_abort(0x1C); }
void  exception_1D(void); //{ prg_abort(0x1D); }
void  exception_1E(void); //{ prg_abort(0x1E); }
void  exception_1F(void); //{ prg_abort(0x1F); }

void iret0(void);
void iret1(void);

// --------------------------------------
// Глобальная таблица дескрипторов GDT
// --------------------------------------

descriptor      gdt[11];

// --------------------------------------
// Дескрипторная таблица прерываний IDT
// --------------------------------------

gate            idt[] = {

// Обработчики исключений

 { (word)&exception_0, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 0
 { (word)&exception_1, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1
 { (word)&exception_2, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 2
 { (word)&exception_3, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 3
 { (word)&exception_4, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 4
 { (word)&exception_5, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 5
 { (word)&exception_6, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 6
 { (word)&exception_7, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 7
 { (word)&exception_8, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 8
 { (word)&exception_9, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 9
 { (word)&exception_A, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // A
 { (word)&exception_B, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // B
 { (word)&exception_C, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // C
 { (word)&exception_D, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // D
 { (word)&exception_E, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // E
 { (word)&exception_F, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // F
 { (word)&exception_10, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 10
 { (word)&exception_11, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 11
 { (word)&exception_12, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 12
 { (word)&exception_13, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 13
 { (word)&exception_14, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 14
 { (word)&exception_15, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 15
 { (word)&exception_16, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 16
 { (word)&exception_17, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 17
 { (word)&exception_18, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 18
 { (word)&exception_19, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 19
 { (word)&exception_1A, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1A
 { (word)&exception_1B, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1B
 { (word)&exception_1C, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1C
 { (word)&exception_1D, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1D
 { (word)&exception_1E, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1E
 { (word)&exception_1F, CODE_SELECTOR, 0, TYPE_TRAP_GATE, 0 }, // 1F

// Обработчик прерываний таймера

 { (word)&Timer_int, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 20

// Вентиль задачи, запускающейся по прерыванию от клавиатуры

 { 0, KEYB_TASK_SELECTOR, 0, TYPE_TASK_GATE, 0 }, // 21

// Заглушки для остальных аппаратных прерываний

 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 22
 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 23
 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 24
 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 25
 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 26
 { (word)&iret0, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 27

 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 28
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 29
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2A
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2B
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2C
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2D
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2E
 { (word)&iret1, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 }, // 2F

// Обработчик для программного прерывания, которое
// используется для ввода с клавиатуры

 { (word)&Int_30h_Entry, CODE_SELECTOR, 0, TYPE_INTERRUPT_GATE, 0 },  // 30

// Вентиль задачи FLIP_TASK

 { 0, FLIP_TASK_SELECTOR, 0, TYPE_TASK_GATE, 0 } // 31

};

// -------------------------------------------
// Сегменты TSS для различных задач
// -------------------------------------------

tss main_tss;           // TSS главной задачи
tss task_1_tss; // TSS задачи TASK_1
tss task_2_tss;     // TSS задачи TASK_2
tss keyb_task_tss;  // TSS задач обслуживания
tss keyb_tss;           //              клавиатуры
tss flipflop_tss;       // TSS задачи FLIP_TASK

// -------------------------------------------
// Стеки для задач
// -------------------------------------------

unsigned char task_1_stack[1024];
unsigned char task_2_stack[1024];
unsigned char keyb_task_stack[1024];
unsigned char keyb_stack[1024];
unsigned char flipflop_stack[1024];

word y=0;       // номер текущей строки для вывода на экран



// -------------------------------------------
// Начало программы
// -------------------------------------------

void main(void) {

// Стираем экран

        textcolor(BLACK); textbackground(LIGHTGRAY); clrscr();

// Входим в защищённый режим

        Init_And_Protected_Mode_Entry();

// Выводим сообщение

        vi_hello_msg();
        y=3;
        vi_print(0, y++,
         " Установлен защищённый режим в главной задаче", 0x7f);

// Загружаем регистр TR селектором главной задачи
// т.е. задачи main()

        load_task_register(MAIN_TASK_SELECTOR);

// Переключаемся на задачу TASK_1

        jump_to_task(TASK_1_SELECTOR);

// После возврата в главную задачу выдаём сообщение

        vi_print(0, y++ ," Вернулись в главную задачу", 0x7f);
        y++;

// Запускаем планировщик задач

        vi_print(0, y++ ," Запущен планировщик задач", 0x70);
        enable_interrupt(); // разрешаем прерывание таймера

// Ожидаем установки семафора с номером 0. После того,
// как этот семафор окажется установлен, возвращаемся
// в реальный режим.

// Семафор 0 устанавливается задачей, обрабатывающей ввод с
// клавиатуры, которая работает независимо от
// главной задаче.

        vi_print(0, y++ ," Для возврата в реальный режим нажмите ESC", 0x70);

        sem_clear(0); // сброс семафора 0
        sem_wait(0);  // ожидание установки семафора 0

// Возврат в реальный режим, стирание экрана и
// передача управления MS-DOS

        real_mode();
        textcolor(WHITE); textbackground(BLACK); clrscr();
}

// -----------------------------------
// Функция инициализации сегмента TSS
// -----------------------------------

void init_tss(tss *t, word cs, word ds,
        unsigned char *sp, func_ptr ip) {

        t->cs = cs;          // селектор сегмента кода
        t->ds = ds;          // поля ds, es, ss устанавливаем
        t->es = ds;          // на сегмент данных
        t->ss = ds;
        t->ip = (word)ip;    // указатель команд
        t->sp = (word)sp;    // смещение стека
        t->bp = (word)sp;
}

// -------------------------------------------------
// Функция инициализации дескриптора в таблице GDT
// -------------------------------------------------

void init_gdt_descriptor(descriptor *descr,
                unsigned long base, word limit,
                unsigned char type) {

// Младшее слово базового адреса
        descr->base_lo  = (word)base;

// Старший байт базового адреса
        descr->base_hi  = (unsigned char)(base >> 16);

// Поле доступа дескриптора
        descr->type_dpl = type;

// Предел
        descr->limit    = limit;

// Зарезервированное поле, должно быть
// сброшено в 0
        descr->reserved = 0;
}

// -----------------------------------------------
// Инициализация всех таблиц и вход
// в защищённый режим
// -----------------------------------------------

void Init_And_Protected_Mode_Entry(void) {

        union REGS r;

// Инициализируем таблицу GDT, элементы с 1 по 5

        init_gdt_descriptor(&gdt[1], MK_LIN_ADDR(_CS, 0),
         0xffffL, TYPE_CODE_DESCR | SEG_PRESENT_BIT | SEG_READABLE);

        init_gdt_descriptor(&gdt[2], MK_LIN_ADDR(_DS, 0),
         0xffffL, TYPE_DATA_DESCR | SEG_PRESENT_BIT | SEG_WRITABLE);

        init_gdt_descriptor(&gdt[3],
         MK_LIN_ADDR(_DS, &task_1_tss),
         (unsigned long)TSS_SIZE-1, TYPE_TSS_DESCR | SEG_PRESENT_BIT);

        init_gdt_descriptor(&gdt[4],
         MK_LIN_ADDR(_DS, &task_2_tss),
         (unsigned long)TSS_SIZE-1, TYPE_TSS_DESCR | SEG_PRESENT_BIT);

        init_gdt_descriptor(&gdt[5],
         MK_LIN_ADDR(_DS, &main_tss),
         (unsigned long)TSS_SIZE-1, TYPE_TSS_DESCR | SEG_PRESENT_BIT);


// Инициализируем TSS для задач TASK_1, TASK_2

        init_tss(&task_1_tss, CODE_SELECTOR, DATA_SELECTOR, task_1_stack+
                sizeof(task_1_stack), task1);

        init_tss(&task_2_tss, CODE_SELECTOR, DATA_SELECTOR, task_2_stack+
                sizeof(task_2_stack), task2);

// Инициализируем элемент 6 таблицы GDT -
// дескриптор для сегмента видеопамяти

// Определяем видеорежим
        r.h.ah=15;
        int86(0x10,&r,&r);

// Инициализация для монохромного режима

        if(r.h.al==MONO_MODE)
          init_gdt_descriptor(&gdt[6], MONO_VID_MEM,
          3999, TYPE_DATA_DESCR | SEG_PRESENT_BIT | SEG_WRITABLE);

// Инициализация для цветного режима

        else if(r.h.al == BW_80_MODE || r.h.al == COLOR_80_MODE)
          init_gdt_descriptor(&gdt[6], COLOR_VID_MEM,
          3999, TYPE_DATA_DESCR | SEG_PRESENT_BIT | SEG_WRITABLE);
        else {
                printf("\nИзвините, этот видеорежим недопустим.");
                exit(-1);
        }

// Инициализация элементов 7 и 8 таблицы GDT

        init_gdt_descriptor(&gdt[7],
                MK_LIN_ADDR(_DS, &idt),
                (unsigned long)IDT_SIZE-1,
                TYPE_DATA_DESCR | SEG_PRESENT_BIT | SEG_WRITABLE);

        init_gdt_descriptor(&gdt[8],
                MK_LIN_ADDR(_DS, &keyb_task_tss),
                (unsigned long)TSS_SIZE-1,
                TYPE_TSS_DESCR | SEG_PRESENT_BIT);

// Инициализация TSS для задачи KEYB_TASK

        init_tss(&keyb_task_tss, CODE_SELECTOR, DATA_SELECTOR,
                keyb_task_stack + sizeof(keyb_task_stack), keyb_task);

// Инициализация элемента 9 таблицы GDT

        init_gdt_descriptor(&gdt[9],
                MK_LIN_ADDR(_DS, &keyb_tss),
                (unsigned long)TSS_SIZE-1,
                TYPE_TSS_DESCR | SEG_PRESENT_BIT);

// Инициализация TSS для задачи KEYB обработки ввода с клавиатуры

        init_tss(&keyb_tss, CODE_SELECTOR, DATA_SELECTOR,
                keyb_stack + sizeof(keyb_stack), Keyb_int);


// Инициализация элемента 10 таблицы GDT

        init_gdt_descriptor(&gdt[10],
                MK_LIN_ADDR(_DS, &flipflop_tss),
                (unsigned long)TSS_SIZE-1,
                TYPE_TSS_DESCR | SEG_PRESENT_BIT);

// Инициализация TSS для задачи FLIP_TASK

        init_tss(&flipflop_tss, CODE_SELECTOR, DATA_SELECTOR,
                flipflop_stack + sizeof(flipflop_stack), flipflop_task);

// Загрузка регистра IDTR

        load_idtr(MK_LIN_ADDR(_DS, &idt), IDT_SIZE);

// Вход в защищённый режим

        protected_mode(MK_LIN_ADDR(_DS, &gdt), sizeof(gdt),
                        CODE_SELECTOR, DATA_SELECTOR);
}




Файл tasks.c содержит тексты программ, которые будут работать в режиме разделения времени (кроме задачи TASK_1, эта задача запускается только один раз).

Задача TASK_1 (процедура task1) выдаёт сообщение о своём запуске и передаёт управление главной задаче.

Задача TASK_2 (процедура task2) попеременно выводит на экран строки "FLIP" и "FLOP", переключая попутно семафор с номером 1.

Задача FLIP_TASK (процедура flipflop_task) также попеременно выводит на экран строки "FLIP" и "FLOP", но только тогда, когда семафор с номером 1 установлен. Таким образом, задача TASK_2 управляет работой задачи FLIP_TASK.

Задача KEYB_TASK (процедура keyb_task) вводит символы с клавиатуры и выводит скан-коды нажатых клавиш, а также состояние переключающих клавиш. Как только оказывается нажатой клавиша ESC, задача устанавливает семафор с номером 0, что приводит к завершению работы главной задачи (ожидающей установки этого семафора).

Листинг 7. Задачи, которые будут работать параллельно.

Файл tasks.c
-----------------------------------------------------------

#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

word dispatcher(void);

// Номер текущей строки для вывода на экран

extern unsigned int y;

// Задача TASK_1

void task1(void) {
        while(1){
                vi_print(0,y++," Запущена задача TASK_1, "
                                        "переходим к главной задаче", 0x70);
                jump_to_task(MAIN_TASK_SELECTOR);

// После повторного запуска этой задачи
// снова входим в цикл.

        }
}

// Задача TASK_2

word flipflop1 = 0;
long delay_cnt1 = 0l;

void task2(void) {
        while(1){

// Периодически выводим на экран строки
// FLIP/FLOP, каждый раз переключая
// семафор номер 1. Этот семафор однозначно
// соответствует выведенной на экран строке.

                asm sti
                if(delay_cnt1 > 150000l ) {
                        asm cli
                        if(flipflop1)   {
                                vi_print(73,3," FLIP ", 0x4f);
                                sem_clear(1);
                        }
                        else  {
                                vi_print(73,3," FLOP ", 0x1f);
                                sem_set(1);
                        }
                        flipflop1 ^= 1;
                        delay_cnt1 = 0l;
                        asm sti
                }
                delay_cnt1++;
        }
}

word flipflop = 0;
long delay_cnt = 0l;

void flipflop_task(void) {

// Эта задача также периодически выводит на экран
// строки FLIP/FLOP, но выводит строкой выше и
// с меньшим периодом. Кроме того, эта задача
// работает только тогда, когда установлен
// семафор номер 1.

        while(1){
                asm sti
                if(delay_cnt > 20000l ) {
                        sem_wait(1); // ожидаем установки семафора
                        asm cli
                        if(flipflop)    vi_print(73,2," FLIP ", 0x20);
                        else            vi_print(73,2," FLOP ", 0x20);
                        flipflop ^= 1;
                        delay_cnt = 0l;
                        asm sti
                }
                delay_cnt++;
        }
}

word keyb_code;

extern word keyb_status;

void keyb_task(void) {

// Эта задача вводит символы с клавиатуры
// и отображает скан-коды нажатых клавиш
// и состояние переключающих клавиш на экране.
// Если нажимается клавиша ESC, задача
// устанавливает семафор номер 0.
// Работающая параллельно главная задача
// ожидает установку этого семафора. Как только
// семафор 0 окажется установлен, главная задача
// завершает свою работу и программа возвращает
// процессор в реальный режим, затем передаёт
// управление MS-DOS.


        vi_print(60, 5, " Key code:   .... ", 0x20);
        vi_print(60, 6, " Key status: .... ", 0x20);
        while(1){
                keyb_code = kb_getch();
                vi_put_word(73, 5, keyb_code, 0x4f);
                vi_put_word(73, 6, keyb_status, 0x4f);
                if((keyb_code & 0x00ff) == 1) sem_set(0);
        }
}




Файл semaphor.c содержит исходные тексты процедур сброса семафора, установки семафора и ожидания семафора.

В массиве semaphore[5] определено пять семафоров. Разумеется, что когда вы будете экспериментировать с программой, вы можете изменить количество доступных семафоров.

Листинг 8. Процедуры для работы с семафорами.

Файл semaphor.c
-----------------------------------------------------------

#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

// Массив из пяти семафоров

word semaphore[5];

// Процедура сброса семафора.
// Параметр sem - номер сбрасываемого семафора

void sem_clear(int sem) {
        asm cli
        semaphore[sem] = 0;
        asm sti
}

// Процедура установки семафора
// Параметр sem - номер устанавливаемого семафора

void sem_set(int sem) {
        asm cli
        semaphore[sem] = 1;
        asm sti
}

// Ожидание установки семафора
// Параметр sem - номер ожидаемого семафора

void sem_wait(int sem) {
        while(1) {
                asm cli
                if(semaphore[sem]) break; // проверяем семафор

                asm sti // ожидаем установки семафора
                asm nop
                asm nop
        }
        asm sti
}




Файл timer.c содержит обработчик аппаратного прерывания таймера, который периодически выдаёт звуковой сигнал и инициирует работу диспетчера задач. Диспетчер задач циклически перебирает селекторы TSS задач, участвующих в процессе разделения времени, возвращая селектор той задачи, которая должна стать активной. В самом конце обработки аппаратного прерывания таймера происходит переключение именно на эту задачу.

Листинг 9. Процедуры для работы с таймером и 
                диспетчер задач.

Файл timer.c
-----------------------------------------------------------


#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

// -------------------------------------------
//      Модуль обслуживания таймера
// -------------------------------------------

#define EOI 0x20
#define MASTER8259A 0x20

extern void beep(void);
extern void flipflop_task(void);
void Timer_int(void);
word dispatcher(void);

word    timer_cnt;

// ------------------------------------------
// Обработчик аппаратного прерывания таймера
// ------------------------------------------

void Timer_int(void) {

        asm pop bp

// Периодически выдаём звуковой сигнал

        timer_cnt += 1;
        if((timer_cnt & 0xf) == 0xf) {
                beep();
        }

// Выдаём в контроллер команду конца
// прерывания

        asm mov al,EOI
        asm out MASTER8259A,al

// Переключаемся на следующую задачу,
// селектор TSS которой получаем от
// диспетчера задач dispatcher()

        jump_to_task(dispatcher());
        asm iret
}

// --------------------------------------
// Диспетчер задач
// --------------------------------------

// Массив селекторов, указывающих на TSS
// задач, участвующих в параллельной работе,
// т.е. диспетчеризуемых задач

word task_list[] = {
        MAIN_TASK_SELECTOR,
        FLIP_TASK_SELECTOR,
        KEYBIN_TASK_SELECTOR,
        TASK_2_SELECTOR
};

word current_task = 0; // текущая задача
word max_task = 3;     // количество задач - 1

// Используем простейший алгоритм диспетчеризации -
// выполняем последовательное переключение на все
// задачи, селекторы TSS которых находятся
// в массиве task_list[].

word dispatcher(void) {

        if(current_task < max_task) current_task++;
        else current_task = 0;
        return(task_list[current_task]);
}




Для сокращения объёма и без того сложной программы мы не стали делать функционально полную обработку исключений, ограничившись простым аварийным завершением работы программы с выдачей номера исключения.

Исходные тексты обработчиков исключений находятся в файле except.c.

Листинг 10. Обработка исключений.

Файл except.c
-----------------------------------------------------------

#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

void prg_abort(int err);

// Номер текущей строки для вывода на экран

extern unsigned int y;

// Обработчики исключений

void  exception_0(void) { prg_abort(0); }
void  exception_1(void) { prg_abort(1); }
void  exception_2(void) { prg_abort(2); }
void  exception_3(void) { prg_abort(3); }
void  exception_4(void) { prg_abort(4); }
void  exception_5(void) { prg_abort(5); }
void  exception_6(void) { prg_abort(6); }
void  exception_7(void) { prg_abort(7); }
void  exception_8(void) { prg_abort(8); }
void  exception_9(void) { prg_abort(9); }
void  exception_A(void) { prg_abort(0xA); }
void  exception_B(void) { prg_abort(0xB); }
void  exception_C(void) { prg_abort(0xC); }
void  exception_D(void) { prg_abort(0xD); }
void  exception_E(void) { prg_abort(0xE); }
void  exception_F(void) { prg_abort(0xF); }
void  exception_10(void) { prg_abort(0x10); }
void  exception_11(void) { prg_abort(0x11); }
void  exception_12(void) { prg_abort(0x12); }
void  exception_13(void) { prg_abort(0x13); }
void  exception_14(void) { prg_abort(0x14); }
void  exception_15(void) { prg_abort(0x15); }
void  exception_16(void) { prg_abort(0x16); }
void  exception_17(void) { prg_abort(0x17); }
void  exception_18(void) { prg_abort(0x18); }
void  exception_19(void) { prg_abort(0x19); }
void  exception_1A(void) { prg_abort(0x1A); }
void  exception_1B(void) { prg_abort(0x1B); }
void  exception_1C(void) { prg_abort(0x1C); }
void  exception_1D(void) { prg_abort(0x1D); }
void  exception_1E(void) { prg_abort(0x1E); }
void  exception_1F(void) { prg_abort(0x1F); }

// ------------------------------
// Аварийный выход из программы
// ------------------------------

void prg_abort(int err) {

        vi_print(1,y++,"!!! ---> Произошло исключение", 0xc);

        real_mode(); // Возвращаемся в реальный режим

// В реальном режиме выводим сообщение об исключении

        gotoxy(1, ++y);
        cprintf(" Исключение %X, нажмите любую клавишу", err);
        getch();

        textcolor(WHITE);
        textbackground(BLACK);
        clrscr();
        exit(0);

}




В файле intproc.c расположены заглушки для тех аппаратных прерываний, обработка которых сводится к простой посылке кода конца прерывания в соответствующий контроллер прерывания.

Листинг 11. Заглушки для аппаратных прерываний.

Файл intproc.c
-----------------------------------------------------------


#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

// Заглушки для необрабатываемых
// аппаратных прерываний.

void iret0(void) {     // первый контроллер прерываний
        asm {
                push    ax
                mov     al,EOI
                out     MASTER8259A,al
                pop     ax
                pop bp
                iret
        }
}

void iret1(void) {     // второй контроллер прерываний
        asm {
                push    ax
                mov     al,EOI
                out     MASTER8259A,al
                out     SLAVE8259A,al
                pop     ax
                pop bp
                iret
        }
}




Файл keyb.c содержит простой интерфейс для вызова программного прерывания int 30h, обеспечивающего ввод с клавиатуры.

Листинг 12. Ввод символа с клавиатуры.

Файл keyb.c
-----------------------------------------------------------


#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

extern word key_code;

// Функция, ожидающая нажатия любой
// клавиши и возвращающая её скан-код

unsigned int kb_getch(void) {
        asm int 30h
        return(key_code);
}




Обработчик аппаратного прерывания клавиатуры мы взяли практически без изменений из программы, представленной в предыдущей главе. Исходные тексты находятся в файле keyboard.asm.

Листинг 13. Процедуры для работы с клавиатурой.

Файл keyboard.asm
-----------------------------------------------------------

IDEAL

MODEL SMALL
RADIX   16

P286
include "tos.inc"

; ------------------------------------------
; Модуль обслуживания клавиатуры
; ------------------------------------------

PUBLIC  _Keyb_int, _Int_30h_Entry, _key_code, _keyb_status
EXTRN   _beep:PROC
DATASEG

        _key_flag       db      0
        _key_code       dw      0
        ext_scan        db      0
        _keyb_status    dw      0

CODESEG

PROC    _Keyb_int        NEAR
        cli

        call    _beep

        push    ax
        mov     al, [ext_scan]
        cmp     al, 0
        jz      normal_scan1
        cmp     al, 0e1h
        jz      pause_key

        in      al, 60h
        cmp     al, 2ah
        jz      intkeyb_exit_1
        cmp     al, 0aah
        jz      intkeyb_exit_1

        mov     ah, [ext_scan]
        call    Keyb_PutQ

        mov     al, 0
        mov     [ext_scan], al
        jmp     intkeyb_exit

pause_key:

        in      al, 60h
        cmp     al, 0c5h
        jz      pause_key1
        cmp     al, 45h
        jz      pause_key1

        jmp     intkeyb_exit

pause_key1:
        mov     ah, [ext_scan]
        call    Keyb_PutQ

        mov     al, 0
        mov     [ext_scan], al
        jmp     intkeyb_exit


normal_scan1:
        in      al, 60h
        cmp     al, 0feh
        jz      intkeyb_exit
        cmp     al, 0e1h
        jz      ext_key
        cmp     al, 0e0h
        jnz     normal_scan

ext_key:
        mov     [ext_scan], al
        jmp     intkeyb_exit


intkeyb_exit_1:
        mov     al, 0
        mov     [ext_scan], al
        jmp     intkeyb_exit

normal_scan:
        mov     ah, 0
        call    Keyb_PutQ

intkeyb_exit:
        in      al, 61h
        mov     ah, al
        or      al, 80h
        out     61h, al
        xchg    ah, al
        out     61h, al
        mov     al,EOI
        out     MASTER8259A,al

        pop     ax
        sti
        iret
        jmp     _Keyb_int
ENDP    _Keyb_int


PROC    Keyb_PutQ       NEAR

        push    ax

        cmp     ax, 002ah       ; L_SHIFT down
        jnz     @@kb1
        mov     ax, [_keyb_status]
        or      ax, L_SHIFT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb1:
        cmp     ax, 00aah       ; L_SHIFT up
        jnz     @@kb2
        mov     ax, [_keyb_status]
        and     ax, NL_SHIFT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb2:
        cmp     ax, 0036h       ; R_SHIFT down
        jnz     @@kb3
        mov     ax, [_keyb_status]
        or      ax, R_SHIFT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb3:
        cmp     ax, 00b6h       ; R_SHIFT up
        jnz     @@kb4
        mov     ax, [_keyb_status]
        and     ax, NR_SHIFT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb4:
        cmp     ax, 001dh       ; L_CTRL down
        jnz     @@kb5
        mov     ax, [_keyb_status]
        or      ax, L_CTRL
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb5:
        cmp     ax, 009dh       ; L_CTRL up
        jnz     @@kb6
        mov     ax, [_keyb_status]
        and     ax, NL_CTRL
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb6:
        cmp     ax, 0e01dh      ; R_CTRL down
        jnz     @@kb7
        mov     ax, [_keyb_status]
        or      ax, R_CTRL
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb7:
        cmp     ax, 0e09dh      ; R_CTRL up
        jnz     @@kb8
        mov     ax, [_keyb_status]
        and     ax, NR_CTRL
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb8:
        cmp     ax, 0038h       ; L_ALT down
        jnz     @@kb9
        mov     ax, [_keyb_status]
        or      ax, L_ALT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb9:
        cmp     ax, 00b8h       ; L_ALT up
        jnz     @@kb10
        mov     ax, [_keyb_status]
        and     ax, NL_ALT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb10:
        cmp     ax, 0e038h      ; R_ALT down
        jnz     @@kb11
        mov     ax, [_keyb_status]
        or      ax, R_ALT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb11:
        cmp     ax, 0e0b8h      ; R_ALT up
        jnz     @@kb12
        mov     ax, [_keyb_status]
        and     ax, NR_ALT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb12:
        cmp     ax, 003ah       ; CAPS_LOCK up
        jnz     @@kb13
        mov     ax, [_keyb_status]
        xor     ax, CAPS_LOCK
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb13:
        cmp     ax, 00bah       ; CAPS_LOCK down
        jnz     @@kb14
        jmp     keyb_putq_exit
@@kb14:
        cmp     ax, 0046h       ; SCR_LOCK up
        jnz     @@kb15
        mov     ax, [_keyb_status]
        xor     ax, SCR_LOCK
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb15:
        cmp     ax, 00c6h       ; SCR_LOCK down
        jnz     @@kb16
        jmp     keyb_putq_exit
@@kb16:
        cmp     ax, 0045h       ; NUM_LOCK up
        jnz     @@kb17
        mov     ax, [_keyb_status]
        xor     ax, NUM_LOCK
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb17:
        cmp     ax, 00c5h       ; NUM_LOCK down
        jnz     @@kb18
        jmp     keyb_putq_exit
@@kb18:
        cmp     ax, 0e052h      ; INSERT up
        jnz     @@kb19
        mov     ax, [_keyb_status]
        xor     ax, INSERT
        mov     [_keyb_status], ax
        jmp     keyb_putq_exit
@@kb19:
        cmp     ax, 0e0d2h      ; INSERT down
        jnz     @@kb20
        jmp     keyb_putq_exit
@@kb20:

        test    ax, 0080h
        jnz     keyb_putq_exit

        mov     [_key_code], ax

        mov     al, 0ffh
        mov     [_key_flag], al
keyb_putq_exit:
        pop     ax
        ret
ENDP    Keyb_PutQ

; Обработчик программного прерывания
; для ввода с клавиатуры. По своим функциям
; напоминает прерывание INT 16 реального
; режима.


PROC    _Int_30h_Entry   NEAR
        push   ax dx

; Ожидаем прерывание от клавиатуры

keyb_int_wait:
        sti
        nop
        nop
        cli

; Проверяем флаг, который устанавливается
; обработчиком аппаратного прерывания клавиатуры

        mov     al, [_key_flag]
        cmp     al, 0
        jz      keyb_int_wait

; Сбрасываем флаг после прихода прерывания

        mov     al, 0
        mov     [_key_flag], al
        sti
        pop     dx ax
        iret
ENDP   _Int_30h_Entry

END




Файл screen.c содержит процедуры, необходимые для вывода информации на экран дисплея. Работа этих процедур основана на непосредственной записи данных в видеопамять.

Листинг 14. Процедуры для работы с видеоадаптером.

Файл screen.c
-----------------------------------------------------------

#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include "tos.h"

void vi_putch(unsigned int x, unsigned int y ,char c, char attr);

char hex_tabl[] = "0123456789ABCDEF";

// Вывод байта на экран, координаты (x,y),
// выводится шестнадцатеричное представление
// байта chr с экранными атрибутами attr.

void vi_put_byte(unsigned int x,
                unsigned int y, unsigned char chr, char attr) {
        unsigned char temp;

        temp = hex_tabl[(chr & 0xf0) >> 4];
        vi_putch(x, y, temp, attr);

        temp = hex_tabl[chr & 0xf];
        vi_putch(x+1, y, temp, attr);
}
// Вывод слова на экран, координаты (x,y),
// выводится шестнадцатеричное представление
// слова chr с экранными атрибутами attr.

void vi_put_word(unsigned int x,
        unsigned int y, word chr, char attr) {

        vi_put_byte(x, y, (chr & 0xff00) >> 8, attr);
        vi_put_byte(x+2, y, chr & 0xff, attr);

}

// Вывод символа c на экран, координаты - (x,y),
// атрибут выводимого символа - attr

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(VID_MEM_SELECTOR, offset);
        *vid_ptr++=c; *vid_ptr=attr;
}

// Вывод строки s на экран, координаты - (x,y),
// атрибут выводимой строки - 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,
                " Protected mode monitor *TINY/OS*, "
                "v.1.2 for CPU 80286  ¦ © Frolov A.V., 1992 ", 0x30);

}




Последний файл - tossyst.asm - содержит уже знакомые вам процедуры для входа в защищённый режим и возврата обратно в реальный режим. Обратите внимание на процедуры _load_task_register и _jump_to_task, выполняющие загрузку регистра задачи TR и переключение на другую задачу соответственно.

Листинг 15. Процедуры для инициализации, перехода в
                защищённый режим и возврата в реальный режим,
                для загрузки регистра TR и переключения задач.

Файл tossyst.asm
-----------------------------------------------------------

IDEAL
MODEL SMALL
RADIX   16
P286

        DATASEG

        include "tos.inc"

        PUBLIC  _beep

; Область памяти для инициализации IDTR

        idtr                    idtr_struc <,,,0>

; Область памяти для инициализации GDTR

        gdt_ptr         dw  (8*15)-1  ; размер GDT, 15 элементов
        gdt_ptr2                dw  ?
        gdt_ptr4                dw  ?

; Область памяти для записи селектора задачи,
; на которую будет происходить переключение

        new_task                dw  00h
        new_select       dw  00h

; Область памяти для хранения регистров,
; используется для возврата в реальный режим

        real_ss         dw      ?
        real_sp         dw      ?
        real_es         dw      ?

        protect_sel     dw      ?

        init_tss                dw      ?

CODESEG

        PUBLIC  _real_mode,_protected_mode,_jump_to_task
        PUBLIC  _load_task_register, _load_idtr, _enable_interrupt

; -------------------------------------------------------------------
; Процедура для переключения в защищённый режим.
; Прототип для вызова:
;  void protected_mode(unsigned long gdt_ptr, unsigned int gdt_size,
;                unsigned int cseg, unsigned int dseg)
; -------------------------------------------------------------------

PROC _protected_mode NEAR
                push    bp
                mov     bp,sp

; Параметр gdt_ptr

                mov     ax,[bp+4]           ; мл. слово адреса GDT
                mov     dx,[bp+6]                   ; ст. слово адреса GDT

                mov     [gdt_ptr4], dx      ; запоминаем адрес GDT
                mov     [gdt_ptr2], ax

; Параметр gdt_size

                mov     ax,[bp+8]                   ; получаем размер GDT
                mov     [gdt_ptr], ax       ; и запоминаем его

; Параметры cseg и dseg

                mov     ax,[bp+10d]         ; получаем селектор сегмента кода
                mov     dx,[bp+12d]         ; получаем селектор сегмента данных
                mov     [cs:p_mode_select], ax      ; запоминаем для команды
                mov        [protect_sel], dx          ; перехода far jmp

; Подготовка к возврату в реальный режим

                push            ds                              ; готовим адрес возврата
                mov             ax,40h                  ; из защищённого режима
                mov             ds,ax
                mov             [WORD 67h],OFFSET shutdown_return
                mov             [WORD 69h],cs
                pop             ds

; Запрещаем и маскируем все прерывания

                cli
                in              al, INT_MASK_PORT
                and             al, 0ffh
                out             INT_MASK_PORT, al

; Записываем код возврата в CMOS-память

                mov             al,8f
                out             CMOS_PORT,al
                jmp             delay1
delay1:
                mov             al,5
                out             CMOS_PORT+1,al

                call    enable_a20              ; открываем линию A20

                mov             [real_ss],ss    ; запоминаем регистры SS и ES
                mov             [real_es],es

; Перепрограммируем контроллер прерываний
; для работы в защищённом режиме

                mov             dx,MASTER8259A
                mov             ah,20
                call            set_int_ctrlr
                mov             dx,SLAVE8259A
                mov             ah,28
                call            set_int_ctrlr

; Загружаем регистры IDTR и GDTR

                lidt            [FWORD idtr]
                lgdt       [QWORD gdt_ptr]

                mov             ax, 0001h       ; переключаем процессор
                lmsw            ax              ; в защищённый режим

;               jmp     far flush
                db      0eah
                dw      OFFSET flush
p_mode_select   dw      ?

LABEL   flush   FAR

                mov      dx, [protect_sel]
                mov         ss, dx
                mov         ds, dx
                mov         es, dx

; Обнуляем содержимое регистра LDTR

                mov             ax, 0
                lldt            ax

                pop         bp
                ret
ENDP _protected_mode

; ----------------------------------------------------
; Возврат в реальный режим.
; Прототип для вызова
;   void real_mode();
; ----------------------------------------------------

PROC _real_mode   NEAR

; Сброс процессора

                cli
                mov             [real_sp], sp
                mov             al, SHUT_DOWN
                out             STATUS_PORT, al

rmode_wait:
                hlt
                jmp             rmode_wait

LABEL   shutdown_return FAR

; Вернулись в реальный режим

                mov             ax, DGROUP
                mov             ds, ax

assume  ds:DGROUP

                mov     ss,[real_ss]
                mov     sp,[real_sp]

                in      al, INT_MASK_PORT
                and     al, 0
                out     INT_MASK_PORT, al

                call    disable_a20

                mov     ax, DGROUP
                mov     ds, ax
                mov     ss, ax
                mov     es, ax

                mov     ax,000dh
                out     CMOS_PORT,al
                sti

                ret
ENDP _real_mode

; -------------------------------------------------------
; Загрузка регистра TR.
; Прототип для вызова:
;   void load_task_register(unsigned int tss_selector);
; -------------------------------------------------------

PROC _load_task_register  NEAR
                push    bp
                mov     bp,sp
                ltr       [bp+4] ; селектор для текущей задачи
                pop     bp
                ret
ENDP _load_task_register

; -------------------------------------------------------
; Переключение на задачу.
; Прототип для вызова:
;   void jump_to_task(unsigned int tss_selector);
; -------------------------------------------------------

PROC _jump_to_task   NEAR
                push    bp
                mov     bp,sp
                mov     ax,[bp+4]        ; получаем селектор
                                                        ; новой задачи
                mov     [new_select],ax  ; запоминаем его

                jmp     [DWORD new_task] ; переключаемся на
                                                        ; новую задачу
                pop     bp
                ret
ENDP _jump_to_task

; ------------------------------
; Открываем линию A20
; ------------------------------

PROC    enable_a20      NEAR
        push    ax
        mov     al, A20_PORT
        out     STATUS_PORT, al
        mov     al, A20_ON
        out     KBD_PORT_A, al
        pop     ax
        ret
ENDP    enable_a20

; ------------------------------
; Закрываем линию A20
; ------------------------------

PROC    disable_a20     NEAR
        push    ax
        mov     al, A20_PORT
        out     STATUS_PORT, al
        mov     al ,A20_OFF
        out     KBD_PORT_A, al
        pop     ax
        ret
ENDP    disable_a20

; -----------------------------------------------------------
; Готовим структуру для загрузки регистра IDTR
; Прототип для вызова функции:
; void load_idtr(unsigned long idt_ptr, word idt_size);
; -----------------------------------------------------------

PROC _load_idtr NEAR
                push    bp

                mov    bp,sp
                mov    ax,[bp+4] ; мл. слово адреса IDT
                mov    dx,[bp+6] ; ст. слово адреса IDT
                mov       bx, OFFSET idtr

; Запоминаем адрес IDTR в структуре

                mov         [(idtr_struc bx).idt_low], ax
                mov         [(idtr_struc bx).idt_hi], dl

; Получаем предел IDT и запоминаем его в структуре

                mov             ax, [bp+8]
                mov        [(idtr_struc bx).idt_len], ax

                pop         bp
                ret
ENDP _load_idtr

; ----------------------------------
; Установка контроллера прерываний
; ----------------------------------

PROC    set_int_ctrlr   NEAR

        mov     al, 11
        out     dx, al
        jmp     SHORT $+2
        mov     al, ah
        inc     dx
        out     dx, al
        jmp     SHORT $+2
        mov     al, 4
        out     dx, al
        jmp     SHORT $+2
        mov     al, 1
        out     dx, al
        jmp     SHORT $+2
        mov     al, 0ffh
        out     dx, al
        dec     dx
        ret
ENDP    set_int_ctrlr

; --------------------------
; Выдача звукового сигнала
; --------------------------

PROC    _beep   NEAR

        push    ax bx cx

        in      al,KBD_PORT_B
        push    ax
        mov     cx,80

beep0:

        push    cx
        and     al,11111100b
        out     KBD_PORT_B,al
        mov     cx,60

idle1:

        loop    idle1
        or      al,00000010b
        out     KBD_PORT_B,al
        mov     cx,60

idle2:

        loop    idle2
        pop     cx
        loop    beep0

        pop     ax
        out     KBD_PORT_B,al

        pop     cx bx ax
        ret

ENDP    _beep

; -------------------------------
; Задержка выполнения программы
; -------------------------------

PROC    _pause          NEAR

        push    cx
        mov     cx,10

ploop0:

        push    cx
        xor     cx,cx

ploop1:

        loop    ploop1
        pop     cx
        loop    ploop0

        pop     cx
        ret

ENDP    _pause

; -----------------------
; Размаскирование прерываний
; -----------------------

PROC    _enable_interrupt NEAR

                in              al, INT_MASK_PORT
                and             al, 0fch
                out             INT_MASK_PORT, al

                sti
                ret
ENDP    _enable_interrupt

        end
[Назад] [Содеожание] [Дальше]


Создание интернет-магазинов: http://www.shop2you.ru/ © Александр Фролов, Григорий Фролов, 1991-2016