Мне - 45 лет

Сегодня (т.е 22.03.01) решил вести журнал истории.
 
22.03.01 В результате ошибки в программе было попорчены некоторые
файлы из каталога BC3.1 
Что же было ? Писал функцию для теста объема памяти.
ячейку памяти восстанавливал только в самом конце, 
остальные страницы были запорчены - 1 байт в самом начале страницы.
 
 
23.11 Пятница 18 мая 2001. Ууух!!! Долго я не писал сюда
нашел наконец ошибку! Да какую в место выражения
    _ESP=InitPmodeStack+sizeof(InitPmodeStack)-4; было
записано  sizeof(InitPmodeStack-4)!!! А это значит, что стек затирал
таблицу прерываний, структуры GTRL, IDTR , неудивительно что
все не работало!
 
 
01.37 день тот же. УРА!!!! УРА!!! УРА!!! У МЕНЯ ПОЛУЧОЛСЬ !!!
Программа находится _ВСЯ_ (!!) выше 1 мега, пока правда по абсолютному 
адресу 0xa00000 но это можно исправить, получая блок от HIMIM.SYS,
правда под борландом эта штуковина не пашет(все время пишет, что нет памяти)
Теперь надо разделять стек,данные и код, т.к.пока у меня модель SMALL,
где SS=DS
Также контроллировать 15H прерывания на перенос блока, чтобы соблюдались
границы
 
15 июня. очередная катастрофа, куча кросс-линкед фалов, (прокляты
 scandisk.exe !!! я одну фат "восстановил" по другой). а все из-за
проклятрого копирования буферов на диск ;(((
 
16 июня суббота. все пока нормально. разбирась с paging'om,
почему-то виснет при входе в V-режим. сделал обработчики
для int12_stack_fault.

#ifndef _PMODE__H
#define _PMODE__H
 
#include "mytypes.h"
 
DWORD       GetBase(WORD selector);
DWORD       SetInt13HandlerFlag(DWORD flag);
DWORD       ResetInt13HandlerFlag(DWORD flag);
int         SaveTextScreenBuffer();
void        RestoreTextScreenBuffer();
void        ShowTextScreenBuffer(int);
void        Terminate();
 
//установка свойства 13 обработчик прерываний
#define INT13HANDLER_VIRTUAL_INT_AUTO                   0x00000001ul
#define INT13HANDLER_VIRTUAL_IRET_AUTO                  0x00000002ul
#define INT13HANDLER_VIRTUAL_PUSHFD_AUTO                0x00000004ul
#define INT13HANDLER_VIRTUAL_POPFD_AUTO                 0x00000008ul
#define INT13HANDLER_VIRTUAL_PUSHF_AUTO                 0x00000010ul
#define INT13HANDLER_VIRTUAL_POPF_AUTO                  0x00000020ul
#define INT13HANDLER_VIRTUAL_CLI_AUTO                   0x00000040ul
#define INT13HANDLER_VIRTUAL_STI_AUTO                   0x00000080ul
#define INT13HANDLER_VIRTUAL_INT15_MOVE_BLOCK_AUTO      0x00000100ul
#define INT13HANDLER_SHOWDEBUG                          0x00001000ul
 
DWORD InputNumber(char * mes, WORD digitcount=4);
 
void MemoryDump();
BYTE wait_key(BYTE,DWORD=0);
void beep(DWORD,WORD);
void pause(DWORD);
 
//сегмент состояния задачи
class TSS
{
public:
    WORD    LinkCS, rs1;
    DWORD   ESP0;
    WORD    SS0, rs2;
    DWORD   ESP1;
    WORD    SS1, rs3;
    DWORD   ESP2;
    WORD    SS2, rs4;
 
    DWORD   CR3, EIP, EFLAGS,
        EAX, ECX, EDX, EBX,
        ESP, EBP, ESI, EDI;
 
    WORD    ES, rs5,
        CS, rs6,
        SS, rs7,
        DS, rs8,
        FS, rs9,
        GS, rs10,
        LDT, rs11,
        Trap, BinaryMapIO;
    WORD    LastByte;
    //конструктор по умолчанию
    TSS() : LastByte(0), Trap(0), BinaryMapIO(0), LDT(0), CR3(0),
        LinkCS(0),
        rs1(0),rs2(0),rs3(0),rs4(0),rs5(0),
        rs6(0),rs7(0),rs8(0),rs9(0), rs10(0),rs11(0) {}
 
};
 
class SELECTOR
{
public:
    enum
    {
        TEXT_BUFFER =       1*8,
        DATA        =       3*8,
        CODE        =       2*8,
        nnnnnnxxxxSTACK     =       4*8,
        MAIN_TASK       =   7*8,
        SUB_TASK        =   8*8,
        GLOBAL_MEMORY_RO=   9*8,
        GLOBAL_MEMORY_RW=   11*8,
        DOS_SELECTOR    =   12*8,
        TEMP_SELECTOR   =   13*8
    };
};
 
 
extern "C"
{
    void pmode();
    void realmode();
}
 
struct ALL_16BIT_REGISTER
{
    WORD AX,BX,CX,DX,
        SI, DI,ESP, BP;
    WORD DS, ES, FS, GS, SS, CS;
};
 
/*struct ALL_REG
{
    DWORD _EAX,_EBX,_ECX,_EDX,
        _ESI, _EDI,_ESP;
    WORD
        _DS, _ES, _FS, _GS,
        _SS, _SP,
        _CS;
};*/
 
 
/*
;----------------- Формат дескриптора в GDT (64 бита) --------------------
;'BBBBBBBB'GDXU LLLL'PПрS ТипA'BBBB BBBB'BBBBBBBB'BBBBBBBB'LLLLLLLL'LLLLLLLL'
;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB 32-битная база (абсолютный адрес) объекта
;LLLLLLLLLLLLLLLLLLLL 20-битный предел (размер) объекта
;G (Granularity) =0 максимальный предел 1Mb, =1 максимальный предел 4Gb
;D (Default size) =0 операнды в объекте 16-битные, =1 операнды 32-битные
;X не должен изменяться
;U (User) бит пользователя
;P (Present) =0 не присутствует в памяти, =1 присутствует в памяти
;Пр_ивелегии (DPL, Descriptor Privilege Level) уровень привелегий объекта
; =00, =01, =10, =11 от большего (=00) к меньшему (=11)
;S (System) =0 несистемный обьект, =1 системный обьект
;Тип (Type)  =000 данные, только читать(ROM)
;       =001 данные, можно читать и писать(RAM)
;       =010 стек ROM (на практике не применяются)
;       =011 cтек RAM
;       =100 код читать нельзя
;       =101 код читать можно
;       =110 подчиненный код, читать нельзя
;       =111 подчиненный код, читать можно
;Тип можно интерпретировать так:
; E - тип исполняемости (=1 код, =0 данные)
 
; |E=1|C|R| сегмент кода C
;R - бит разрешения считывания вводится для сегмента программ и разрешает
;при R=1 производить считывание его содержимого. При R=0 допускается только
;выборка его содержимого. Попытка считывания сегмента в этом случае вызовет
;прерывание типа 13.Отметим, что прерывание этого типа возникнет также при
;попытке записи в сегмент программ независимо от значение типа R
; Бит подчинения C определяет дополнительные правила обращения, которые
; обеспечивают защиту сегментов программ
 
; |E=0|ED|W|    сегмент данных
; W - бит разрешения записи. При W=1 разрешается, при W=0 запрещается запись
; в сегмент данных
; Бит направление расширения. При ED=0 расширение вверх, ED=1 расширение вниз
 
;A (Access) =0 обращения к сегменту не было,=1 обращение к сегменту было(автомат)
;-------------------------------------------------------------------------------
*/
 
    // возможные типы (Present) бит присутствия сегмента
    enum {
        PRESENT=1,  //присутствует в памяти
        NOT_PRESENT=0   //сегмент не присутствует
    };
 
 
    //возможные типы (Type) сегментов
    enum {
        DATA_READ_ONLY  =0, // данные, только читать(ROM)
        DATA_READ_WRITE =1, // данные, можно читать и писать(RAM)
//      STACK_READ_ONLY =2, //стек ROM (на практике не применяются)
        STACK_READ_WRITE=3, // cтек RAM
        CODE_PERFORM_ONLY=4,    //код читать нельзя, только выполнять
        CODE_PERFORM_READ=5,    //код читать можно
        CODE_SPECIAL_CANTREAD=6,// подчиненный код, читать нельзя
        CODE_SPECIAL_READOK=7   //подчиненный код, читать можно
    };
 
    // типы объектов (System)
    enum {
        SYSTEM_OBJECT=0,    //системный объект
        SEGMENT_OBJECT=1    //несистменый объект
    };
 
 
 
//класс Global Descriptor Table Register - класс глобальной дескрипторной
//таблицы
class GDTR
{
public:
    WORD Limit; //максимальная длина дескрипторной таблицы
    DWORD Base; //абсолютный 32-битный адрес дескрипторной таблицы
    void Load();
};
 
//класс Interrupt Descriptor Table Register - класс глобальной дескрипторной
//таблицы прерываниц
class IDTR
{
public:
    WORD Limit; //максимальная длина дескрипторной таблицы
    DWORD Base; //абсолютный 32-битный адрес дескрипторной таблицы
    void Load();
};
 
    // (DPL) Descriptor Privilege Level - уровень привелегий сегмента
    enum {
        HIGH_PRIVILEGE  =0, //высший уровень привелегии
        MEDIUM_PRIVILEGE=1,
        SMALL_PRIVILEGE =2,
        TINY_PRIVILEGE  =3  //низший уровень привелегий
    };
 
    // типы системных дескрипторов (SYSTEM_OBJECT)
    enum //DescriptorTypes
    {
        // 0 - не используется
        // 1 - доступен TSS 80286
        // 2 - таблица LDT
        // 3 - TSS 80286 занят
        // 4 - шлюз вызова 80286
        TASK_GATE_80286_i486    =5, //шлюз задачи 80286 и i486
        INTERRUPT_GATE_80286    =6, //шлюз прерывания 80286
        TRAPS_GATE_80286    =7, //шлюз ловушки 80286
        // 8 - не используется
        // 9 - доступен TSS i486
        // A - резерв
        // B - TSS i486 занят
        INTERRUPT_GATE_i486 =14,    //шлюз прерывания i486
        TRAPS_GATE_i486     =15 //шлюз ловушки i486
    };
 
//этот класс описывает дескриптор сегмента
class SEGMENT_DESCRIPTOR
{
protected:
    //возможные гранулярности сегментов
    enum { BYTE_GRANULARY=0, PAGE_GRANULARY=1 };
 
//private:
public:
    WORD limit0_15; //размер сегмента (биты 0-15)
    WORD base0_15;  //база сегмента (биты 0-15)
    BYTE base16_23; //база сегмента (биты 16-23)
    //байт прав доступа
//  union {
  //      BYTE AccessRight;
    BYTE
        Access:1,   // (Access) =0 обращения к сегменту не было, =1 было
        Type:3,     // (Type) тип объекта
        System:1,   // (System) =0 несистемный , =1 системный объект
        DPL:2,      // уровень привелегий сегмента
            // =00 =01 =10 =11 от большего (=00) к меньшему (==11)
        Present:1;  // P (Present) =0 не присутствует в памяти,
            //         =1 присутствует в памяти
//  }
//protected:
    BYTE limit16_19:4,  //размер сегмента (биты 16-19)
        User:1,     // User - бит пользователя, может иметь любое
        X:1,        //зарезервировано и должно быть равно нулю
        D:1,        //бит разрядности по умолчанию
                // D=0 - 16 разрядов
                // D=1 - 32 разряда
        G:1;        //бит гранулярности
    BYTE base24_31; //база
 
public:
 
    //конструктор по умолчанию
    SEGMENT_DESCRIPTOR()
    {
        Base(0);
        Limit(0);
        Type=DATA_READ_WRITE;
        DPL=HIGH_PRIVILEGE;
        Access=1;
        System=1;
        Present=1;
        D=0;
        User=0;
        X=0;
        G=0;
    }
 
    void set(DWORD base, DWORD limit, BYTE tp)
    {
        Base(base);
        Limit(limit);
        Type=tp;
    }
 
    //установка предела
    // limit - предел сегмента (0x00001..0xfffff)
    // granulary - тип дробности сегмента
    // если G=BYTE_GRANULARY - установлена байтовая гранулярность,
    // и предел сегмента в точности равен значению limit. При этом
    // предел сегмента не может быть более 1Мг
    // если G=PAGE_GRANULARY - установлена страничная гранулярность
    // фактический предел сегмент будет равен limit*4028 байт. В этом
    // случае можно установить предел сегмента в 4Гб
    void Limit(DWORD limit, BYTE granulary=BYTE_GRANULARY)
    {
        G=granulary;
        limit0_15=limit & 0xffff;
        limit16_19=limit>>16;
    }
 
    //возврашает базу
    DWORD GetBase()
    {
        return (DWORD(base24_31)<<24 ) + (DWORD(base16_23)<<16 )+
        base0_15;
    }
 
    //установка базы
    void Base(DWORD base)
    {
        base0_15=base & 0xffff;
        base16_23=(base>>16) & 0xff;
        base24_31=base>>24;
    }
 
    //установка типа сегмента
    void SetType(BYTE tp);
 
    //установка прав доступа сегмента
//  void SetAR(BYTE aces)
  //    {
      //        access=aces;
    //  }
 
//  //установка уровня привелегий сегмента
//  void SetDPL(BYTE dpl)
//  {
//      access.SetDPL(dpl);
//  }
 
    void SetG(BYTE n) { G=n;}
 
    void SetSystem(BYTE n) { System=n;}
    void SetD(BYTE n) { D=n;}
 
};
 
//класс описания дескриптора прерываний
class INTERRUPT_DESCRIPTOR
{
    WORD Offset0_15;    //смещение до обработчика прерываний биты (0.15)
    WORD Selector;      //селектор обработчика прерываний
    BYTE WordCounter:5, //счетчик слов
        res1:3;     //резерв
    BYTE Type:4,        //тип дескриптора
        res2:1,     //резерв
        DPL:2,      //уровень привелегий
        P:1;        //бит присутствия
    WORD Offset16_31;   //смещение (биты 16..31)
 
public:
    //заполняем по умолчанию
    INTERRUPT_DESCRIPTOR
        (
            WORD selector=0,
            DWORD offset=0,
            BYTE type=INTERRUPT_GATE_i486,
            BYTE dpl=HIGH_PRIVILEGE,
            BYTE present=PRESENT
        )
    {
        Selector=selector;
        Type=type;
        DPL=dpl;
        P=present;
        SetOffset(offset);
        WordCounter=0;
    }
    //установка смещения
    void SetOffset(DWORD offs)
    {
        Offset0_15=offs & 0xffff;
        Offset16_31=offs>>16;
    }
 
    DWORD GetOffset()
    {
        return Offset0_15 + (DWORD(Offset16_31)<<16);
    }
 
    BYTE GetDPL() {return DPL;}
    BYTE GetType() {return Type;}
    BYTE GetPresent() {return P;}
    WORD GetSelector() {return Selector;}
    BYTE GetWordCounter() {return WordCounter;}
 
    //установка селектора
    void SetSelector(WORD sel)
    {
        Selector=sel;
    }
 
    //установка уровня привелегий DPL
    void SetDPL(BYTE dpl)
    {
        DPL=dpl;
    }
 
    //установка типа дескриптора
    void SetType(BYTE tp) { Type=tp;}
};
 
#endif