Перейти на главную   
  helloworld.ru - документация и книги по программированию  
helloworld.ru - документация и книги по программированию
    главная     хостинг    
Поиск по сайту:  
Смотрите также
Языки программирования
C#
MS Visual C++
Borland C++
C++ Builder
Visual Basic
Quick Basic
Turbo Pascal
Delphi
JavaScript
Java
PHP
Perl
Assembler
AutoLisp
Fortran
Python
1C

Интернет-технологии
HTML
VRML
HTTP
CGI
FTP
Proxy
DNS
протоколы TCP/IP
Apache

Web-дизайн
HTML
Дизайн
VRML
PhotoShop
Cookie
CGI
SSI
CSS
ASP
PHP
Perl

Программирование игр
DirectDraw
DirectSound
Direct3D
OpenGL
3D-графика
Графика под DOS

Алгоритмы
Численные методы
Обработка данных

Сис. программирование
Драйверы

Базы данных
MySQL
SQL

Другое

Хостинг


Друзья
demaker.ru
Реклама

Лучший хостинг. Аренда серверов




helloworld.ru

Глава 17. Программирование в защищенном режиме DOS

             Микропроцессор 80286 дает новый способ адресации  к  памяти:
        защищенный режим  виртуальной адресации или просто защищенный ре-
        жим. Этот новый режим адресации дает три основных преимущества:

             * Адресация к памяти объемом до 16 мегабайт.

             * Логическое адресное пространство, превышающее пространство
               физических адресов.

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

             С помощью Borland Pascal вы легко можете писать работающие в
        защищенном режиме прикладные программы DOS без необходимости при-
        менения дополнительного  "расширителя"  DOS.  Вы обнаружите,  что
        многие программы реального режима прекрасно работают в защищенном
        режиме. Данная глава поможет вам модифицировать те программы, ко-
        торые этого не делают,  и прояснит некоторые основные моменты за-
        щищенного режима и его отличия от реального режима.


Что такое защищенный режим?

Процессор 80286 и более поздние процессоры поддерживают два режима операций: защищенный режим и реальный режим. Реальный ре- жим совместим с работой процессора 8086 и позволяет прикладной программе адресоваться к памяти объемом до одного мегабайта. За- щищенный режим расширяет диапазон адресации до 16 мегабайт. Ос- новное отличие между реальным и защищенным режимом заключается в способе преобразования процессором логических адресов в физичес- кие. Логические адреса - это адреса, используемые в прикладной программе. Как в реальном, также и в защищенном режиме логический адрес - это 32-разрядное значение, состоящее из 16-битового се- лектора (адреса сегмента) и 16-битового смещения. Физические ад- реса - это адреса, которые процессор использует для обмена данны- ми с компонентами системной памяти. В реальном режиме физический адрес представляет собой 20-битовое значение, а в защищенном ре- жиме - 24-битовое. Когда процессор обращается к памяти (для выборки инструкции или записи переменной), он генерирует из логического адреса физи- ческий адрес. В реальном режиме генерация физического адреса сос- тоит из сдвига селектора (адреса сегмента) на 4 бита влево (это означает умножение на 16) и прибавления смещения. Полученный в результате 20-разрядный адрес используется затем для доступа к памяти. 16Мб----------------- ¦ ¦ --------- ¦ ¦ ¦Смещение+- ¦ ¦ L--------- ¦ ¦ ¦ ¦ +----------------+ L--+----->----------¦+ сегмент 64К -->+----------------+- ¦ ¦ ¦ ¦ ¦ Пространство ¦ --------- ------- ¦ ¦ адресов ¦ ¦Селектор+-+ x 16 +------ ¦ ¦ L--------- L------- ¦ ¦ 0L----------------- Рис. 17.1 Генерация физического адреса в реальном режиме. Чтобы получить физический адрес в защищенном режиме, селек- торная часть логического адреса используется в качестве индекса таблицы дескрипторов. Запись в таблице дескрипторов содержит 24-битовый базовый адрес, к которому затем для образования физи- ческого адреса прибавляется смещение логического адреса. 16Мб----------------- ¦ ¦ --------- ¦ ¦ ¦Смещение+- ¦ ¦ L--------- ¦ ¦ ¦ ¦ +----------------+ Таблица дескрипторов L--+----->----------¦+ сегмент 64К ------- -->+----------------+- +------+ ¦ ¦ ¦ +------+ ¦ ¦ Пространство ¦ +------+ ¦ ¦ адресов ¦ -->+------+---- ¦ ¦ ¦ +------+ ¦ ¦ ¦ +------+ 0L----------------- ¦ +------+ ¦ +------+ ¦ +------+ ¦ +------+ ¦ +------+ ¦ +------+ ¦ +------+ ¦ +------+ --------- ¦ +------+ ¦Селектор+-- L------- L--------- Рис. 17.2 Генерация физического адреса в защищенном режиме. Каждая запись в таблице дескрипторов называется дескриптором и определяет сегмент в памяти. Запись таблицы дескрипторов зани- мает 8 байт, а записанная в дескрипторе информация включает в се- бя базовый адрес, предельное значение и флаги полномочий доступа к сегменту. Записи предельного значения сегмента и полномочий доступа в дескрипторе определяют размер и тип сегмента. Сегменты могут иметь размер от 1 до 65536 байт и могут быть сегментами кода или сегментами данных. Сегменты кода могут содержать выполняемые ма- шинные инструкции и доступные только по чтению данные. Сегменты данных могут содержать данные, доступные по чтению и записи. За- писывать данные в сегменты кода или выполнять инструкции в сег- ментах данных невозможно. Любая попытка сделать это или попытка доступа к данным вне границ сегмента вызывает общий сбой по на- рушению защиты (сокращенно сбой GP). Поэтому режим и называется защищенным. По данному адресу в реальном режиме прикладная программа мо- жет определить физический адрес. В защищенном режиме это обычно не так, поскольку селекторная часть логического адреса является индексом в таблице дескрипторов, и сам селектор не имеет прямого отношения к вычислению физического адреса. Это дает то преиму- щество, что управление виртуальной памятью можно реализовать, не влияя на прикладную программу. Например, путем простого обновле- ния поля базового адреса дескриптора сегмента, операционная сис- тема может перемещать сегмент в физической памяти без влияния на использующую сегмент прикладную программу. Прикладная программа ссылается только на селектор сегмента, и на селектор не влияют изменения в дескрипторе. Прикладная программа редко имеет дело с дескрипторами. При необходимости дескрипторы создаются и уничтожаются операционной системой и администратором памяти, а прикладная программа знает о соответствующих селекторах. Селекторы аналогичны описателям фай- лов - с точки зрения прикладной программы это то, что обслужива- ется операционной системой, но в операционной системе они работа- ют как индексы содержащих дополнительную информацию таблиц.

Расширения Borland защищенного режима DOS

Расширения защищенного режима Borland Pascal реализованы че- рез два компонента: DPMI-сервер (файл DPMI16BI.OVL) и администра- тор этапа выполнения (файл RTM.EXE).

DPMI-сервер

Интерфейс защищенного режима DOS (DPMI) - это отраслевой стандарт, позволяющий программам DOS аппаратно-независимым путем получить доступ к развитым средствам персональных компьютеров, реализованных на процессорах 80286, 80386 и 80486. Определены функции DPMI для обслуживания таблиц дескрипторов, переключения режима, распределения расширенной памяти, выделения памяти DOS, управления подсистемой прерываний и взаимодействия с программами реального режима. Расширения защищенного режима Borland Pascal основаны на спецификации DPMI 0.9. Хотя спецификация DPMI не поддерживает вы- зовы DOS из прикладных программ защищенного режима, DPMI-сервер Borland и серверы многих других фирм, включая улучшенный режим Windows 3.x, поддерживают прерывание INT 21H и другие стандартные прерывания DOS и BIOS, используемые обычно в приложениях DOS за- щищенного режима.

Администратор этапа выполнения

Администратор этапа выполнения (RTM.EXE) является надстрой- кой DPMI-сервера и обеспечивать для прикладных программ защищен- ного режима несколько служебных функций. Администратор этапа вы- полнения содержит загрузчик защищенного режима и администратор памяти защищенного режима и позволяет под DPMI сосуществовать нескольким клиентам защищенного режима. Приложения защищенного режима Borland используют те же фор- маты выполняемых файлов, что и Windows 3.x и OS/2 1.x. Программ- ный загрузчик администратора этапа выполнения может загружать как выполняемые файлы (.EXE), так и динамически компонуемые библиоте- ки (.DLL). Администратор памяти защищенного режима позволяет прикладным программам защищенного режима распределять блоки динамической па- мяти. Администратор памяти поддерживает фиксированные, перемещае- мые и выгружаемые блоки, а также обслуживает код и сегменты дан- ных прикладной программы. Используя уникальные для защищенного режима средства, администратор памяти функционирует также в ка- честве администратора оверлеев, автоматически загружая и выгружая сегменты кода (по этой причине прикладной программе защищенного режима не требуется модуль Overlay). Прикладные программы могут получить доступ к программам за- щищенного режима через модуль WinAPI. Модуль WinAPI, описанный в следующем разделе, реализует подмножество функций API (прикладно- го программного интерфейса) Windows, обеспечивая управление па- мятью, обслуживание программных модулей, управление ресурсами, загрузку динамически компонуемых библиотек и доступ к селекторам на нижнем уровне. Поскольку администратор этапа выполнения API является подмножеством API Windows, вы можете написать совмести- мые на уровне двоичного кода динамически компонуемые библиотеки, которые можно использовать и в защищенном режиме DOS, и в Windows.

Разработка прикладных программ DOS защищенного режима

Написание прикладной программы защищенного режима не предс- тавляет собой сложной задачи. Вам не нужно беспокоиться о селек- торах и адресах памяти. Операционная система с расширениями Borland все делает за вас. Фактически, большинство ваших программ реального режима может прекрасно работать в защищенном режиме. В следующих разделах описывается некоторая разница между реальным и защищенным режимом, о которых вы должны знать при разработке прикладной программы защищенного режима.

Надежное программирование в защищенном режиме

Существует несколько приемов, используемых обычно в програм- мах реального режима, которые в программах защищенного режима бу- дут приводить к общему нарушению защиты (сбой GP). Borland Pascal при сбое GP выводит ошибку этапа выполнения 216. Сбой GP происхо- дит, когда вы пытаетесь получить доступ к памяти, к которой ваша прикладная программа обращаться не может. Операционная система останавливает прикладную программу, но сбоя системы не происхо- дит. Хотя сбои GP и прекращают работу вашей программы, система "защищена" от сбоя. К сбою GP приводит следующее: * загрузка в сегментные регистры недопустимых значений; * обращение к памяти вне границы сегмента; * запись в сегмент кода; * разыменование указателей nil. Примечание: Сбои по нарушению защиты предохраняют вашу систему от плохой практики программирования.

Загрузка в сегментные регистры недопустимых значений

Когда процессор работает в защищенном режиме, сегментные ре- гистры (CS, DS, ES и SS) могут содержать только селекторы. Пос- кольку селекторы являются индексами в таблице дескрипторов, они не имеют физического отношения к памяти, на которую ссылается. Если вы пытаетесь загрузить в сегментный регистр произвольное значение, то возможно получите сбой GP, поскольку это значение может не представлять допустимого дескриптора.

Функция Ptr и массивы Mem

При разыменовании указателей компилятор генерирует код для загрузки сегментного регистра. Если вы строите указатели с по- мощью стандартной функции Ptr, то нужно обеспечить, чтобы сег- ментная часть указателя была допустимым селектором. Аналогично, при работе с массивами Mem, MemW и MemL вы вместо физических ад- ресов должны использоваться селекторы. Например, при доступе к рабочей области ROM BIOS (сегмент $0040) или к областям видеопа- мяти (сегменты $A000, $B000 и $B800) следует использовать вместо абсолютных значений переменные SegXXXX. (Переменные SegXXXX опи- сываются ниже.)

Абсолютные переменные

В защищенном режиме вы не можете задавать абсолютный адрес переменной. Любой исходных код, где сегмент и смещение задаются в операторе absolute, нужно переписать. Например, вам может потре- боваться построить указатель, используя переменные SegXXXX.

Операции с сегментами

Добавление или вычитание значений из селекторной части ука- зателя обычно не допускается. Например, добавление к селекторной части указателя $1000 в реальном режиме увеличивает указатель на 64К, но в защищенном режиме результирующий указатель будет недо- пустимым. Вместо этого для выделения и управления блоками памяти следует использовать функцию GlobalXXXX модуля WinAPI. В Borland Pascal существует способ выполнения арифметических операций с селекторами с помощью переменной SelectorInc (см. ни- же).

Использование сегментных регистров в качестве временных переменных

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

Доступ к памяти вне границ сегмента

В реальном режиме каждый сегмент имеет размер 64К. В защи- щенном режиме дескриптор сегмента содержит поле, специфицирующее предельный размер сегмента, и если вы пытаетесь обратиться к дан- ным вне границ сегмента, по получите сбой GP. При загрузке прик- ладной программы администратор этапа выполнения устанавливает со- ответствующие предельные значения для сегментов кода, данных и стека. Кроме того, блок памяти, распределяемый с помощью функции GlobalAlloc модуля WinAPI, имеет предельное значение сегмента, соответствующее размеру блока памяти.

Запись в сегмент кода

В реальном режиме можно записывать переменные в сегмент ко- да, поскольку реальные режим не определяет, что может и что не может существовать в сегменте. В защищенном режиме это не так. Селектор защищенного режима имеет флаг чтения/записи или доступа только по чтению, а селекторы кода всегда отмечены как доступные только по чтению. Если вы пытаетесь записывать в селектор сегмен- та кода, происходит сбой GP. Однако вы можете использовать псев- доним и написать самомодифицирующийся код (см. ниже).

Разыменование указателей nil

При преобразовании прикладной программы реального режима в защищенный режим, в программе, которая уже годы работала без оши- бок, возможно внезапное появление определенных ошибок. Например, вы можете случайно разыменовывать указатель nil, или обнаружите, что ваша программа содержит "потерянные" указатели, которые разы- меновываются после их освобождения. В реальном режиме такие ошиб- ки не обязательно проявляются, но в защищенном режиме они обычно приводят к сбою GP. Согласно своему названию, защищенный режим значительно лучше предохраняет вас от ошибок, связанных с указа- телями.

Сегменты кода и данных

Аналогично программе Borland Pascal реального режима, прог- рамма защищенного режима содержит несколько сегментов кода, сег- мент данных и сегмент стека. При загрузке программы защищенного режима администратор этапа выполнения автоматически выделяет се- лекторы для сегментов кода, данных и стека. Для сегментов кода с помощью директивы компилятора $C можно управлять отдельными ат- рибутами. В частности, сегменты кода можно сделать перемещаемыми или фиксированными в физической памяти, они могут загружаться предварительно или по запросу, а также могут быть выгружаемыми или постоянными. Примечание: Подробнее о директиве компилятора $C расс- казывается в Главе 21 данного руководства и в Главе 2 ("Ди- рективы компилятора") "Справочного руководства программис- та". Атрибуты сегмента кода позволяют вам обозначать сегмент как статический (перемещаемый, предварительно загружаемый, постоян- ный) или динамический (перемещаемый, загружаемый по запросу, выг- ружаемый). Таким образом, в защищенном режиме вам не нужно ис- пользовать модуль Overlay и директиву компилятора $O, и в версии модуля System для защищенного режима переменные OvrXXXXXX отсутс- твуют.

Управление динамически распределяемой памятью

Администратор динамически распределяемой области памяти Borland Pascal защищенного режима довольно существенно отличается от администратора динамически распределяемой памяти Borland Pascal реального режима. В частности, переменные HeapOrg, HeapEnd, HeapPtr и FreeList в версии модуля System для защищенно- го режима не определены. Администратор этапа выполнения динами- чески распределяемой области памяти Borland Pascal защищенного режима (который идентичен администратору этапа выполнения динами- чески распределяемой области памяти Borland Pascal для Windows) для выполнения основных операций по выделению и освобождению па- мяти использует администратор этапа выполнения, а для оптимизации распределения небольших блоков памяти включает в себя подсистему вторичного распределения сегмента. Подробнее об администраторе динамически распределяемой области памяти этапа выполнения расс- казывается в Главе 21.

Предопределенные селекторы

В модуле System для обычно используемых адресов реального режима предусмотрено несколько предопределенных селекторов. Они именуются по физическому сегменту, которому данные селекторы присвоены, и используются для совместимости между реальным и за- щищенным режимом DOS. Предопределенные селекторы Таблица 17.1 -------------------T-------------------------------------------- ¦ Селектор ¦ Описание ¦ +------------------+--------------------------------------------+ ¦ Seg0040 ¦ Используется для доступа к области данных¦ ¦ ¦ BIOS $40 в младших адресах. ¦ +------------------+--------------------------------------------+ ¦ SegA000 ¦ Используется для доступа к графической па-¦ ¦ ¦ мяти EGA и VGA по адресу сегмента $A000. ¦ +------------------+--------------------------------------------+ ¦ SegB000 ¦ Используется для доступа к видеопамяти мо-¦ ¦ ¦ нохромного адаптера по адресу сегмента¦ ¦ ¦ $A000. ¦ +------------------+--------------------------------------------+ ¦ SegB800 ¦ Используется для доступа к видеопамяти¦ ¦ ¦ цветного графического адаптера по адресу¦ ¦ ¦ сегмента $A000. ¦ L------------------+--------------------------------------------- В реальном режиме переменные SegXXXX всегда содержат значе- ния $0040, $A000, $B000 и $B800 соответственно. В защищенном ре- жиме код запуска библиотеки исполняющей системы создает четыре селектора, ссылающихся на конкретные области памяти реального ре- жима. При ссылке на эти области памяти вам следует использовать переменные SegXXXX. Например, если у вас был код следующего вида: CtrMode := Mem[$40: $49]; то вместо него следует записать: CtrMode := Mem[Seg0040: $49]; Используя переменные SegXXXX, вы можете гарантировать, что ваша программа без изменений будет работать в реальном и защищен- ном режимах.

Переменная SelectorInc

Переменная SelectorInc модуля System содержит значение, ко- торое должно прибавляться к селектору или вычитаться из него для получения следующего или предыдущего селектора в таблице дескрип- торов. SelectorInc полезно использовать при работе с большими блоками памяти (превышающими 64К) и при доступе к псевдонимам сегментов. Для выделения блоков, превышающих 64К (такие блоки называют также большими блоками памяти), можно использовать функции GlobalAlloc и GlobalAllocPrt в модуле WinAPI. Большие блоки неп- рерывны в физической памяти, но из-за 16-разрядной архитектуры процессора прикладная программа не может получить к ним доступ целиком. Для большого блока памяти администратор памяти выделяет несколько непрерывных (следующих подряд) селекторов, каждый из которых (кроме последнего) ссылается на часть большого блока па- мяти размером 64К. Например, чтобы выделить блока памяти размером в 220К, администратор памяти создает четыре селектора, при этом первые три селектора ссылаются на блоки по 64К, а последний се- лектор - на блок размером 28К. Прибавляя SelectorInc к селектору, принадлежащему большому блоку, вы можете получить селектор для следующего сегмента, а вычитая SelectorInc - для предыдущего. При распределении большого блока функция GlobalAlloc всегда возвращает описатель первого сегмента, а GlobalAllocPtr - указа- тель на первый сегмент. Приведенная ниже функция GetPtr воспринимает указатель боль- шого блока (возвращаемый функцией GlobalAllocPtr) и 32-разрядное смещение и возвращает указатель на заданное внутри блока смеще- ние. function GetPtr(P: Pointer; Offset: Longint): Pointer; type Long = record Lo, Hi: Word; end; begin GetPtr := Ptr( Long(P).Hi + Long(Offset).Hi * SelectorInc, Long(P).Lo + Long(Offset).Lo); end; Заметим, что старшее слово параметра Offset используется для определения того, сколько раз нужно увеличить селекторную часть P для получения корректного сегмента. Например, если Offset равно $24000, то селекторная часть P будет увеличена на 2 * SelectorInc, а смещение P - на $4000. Следующая функция LoadFile загружает в блок памяти весь файл и возвращает указатель на блок. Если файл превышает 64К, то выде- ляется большой блок памяти. function LoadFile(const FileName: string): Pointer; var Buffer: Pointer; Size, Offset, Count: Longint; F: file; begin Buffer := nil; Assign(F, FileName); Reset(F, 1); Size := FileSize(F); Buffer := GlobalAllocPtr(gmem_Moveable, Size); if Buffer <> nil then begin Offset := 0; while Offset < Size do begin Count := Size - Offset; if Count > $8000 then Count := $8000; BlockRead(F, GetPtr(Buffer, Offset)^, Count); Inc(Offset, Count); end; end; LoadFile := Buffer; end; Переменная SelectorInc определена также в версии модуля System для реального режима. В реальном режиме она всегда содер- жит значение $1000, которое при сложении его с сегментной частью указателя реального режима увеличивает указатель на 64К. Другим образом вы можете использовать переменную SelectorInс только в программах DOS защищенного режима. Используйте перемен- ную SelectorInc для доступа к псевдонимам сегментов, выделяемых администратором этапа выполнения при загрузке прикладной програм- мы. Для каждого сегмента кода прикладной программы администратор этапа выполнения создает селектор-псевдоним, ссылающийся на тот же сегмент, но имеющий полномочия селектора данных. Для сегментов стека и данных селекторы-псевдонимы не создаются. Чтобы получить доступ к селектору-псевдониму для конкретного сегмента, добавьте к селектору сегмента SelectorInc. Предположим, например, что P - это переменная типа Pointer, а Foo - процедура или функция. Тогда присваивание вида: P := Addr(Foo) приводит к тому, что P будет указывать на выполняемую доступную только по чтению точку входа Foo, а после оператора: P := Ptr(Seg(Foo) + SelectorInc, Ofs(Foo)); P будет ссылаться на тот же адрес, но с полномочиями на чте- ние/запись.

Модуль WinAPI

Модуль WinAPI дает вам непосредственный доступ к расширениям Borland защищенного режима DOS. Чтобы облегчить написание перено- симых прикладных программ и совместимых на уровне двоичного кода DLL, разработан интерфейс WinAPI, являющийся подмножеством интер- фейса API Windows. Модуль WinAPI позволяет вам использовать функции управления памятью, управления ресурсами, модулями, селекторами и многие другие функции API. Ниже приведено их краткое описание. Полное описание констант, типов, процедур и функций модуля WinAPI вы мо- жете найти в "Справочном руководстве программиста". При работе под Windows подпрограммы API, поддерживаемые с помощью модуля WinAPI, находятся в динамически компонуемых библи- отеках KERNEL.DLL и USER.DLL. В защищенном режиме DOS эти DLL не требуются, так как администратор этапа выполнения защищенного ре- жима содержит реализацию подпрограмм KERNEL и USER, автоматичес- ки перенаправляя их вызовы администратору.

Управление памятью

При разработке программ, работающих с динамической памятью, обычно используются стандартные процедуры New, Dispose, GetMem и FreeMem. Однако получить доступ к администратору памяти защищен- ного режима Borland вы можете с помощью функций GlobalXXXX в мо- дуле WinAPI. Заметим, что функции GlobalXXXXPtr комбинируют в одной подп- рограмме общие последовательности вызовов функций, такие как GlobalAlloc, за которыми следуют вызовы GlobalLock, GlobalUnlock или GlobalFree.

Подпрограммы управления памятью API

Таблица 17.2 ----------------------T----------------------------------------- ¦ Функция ¦ Описание ¦ +---------------------+-----------------------------------------+ ¦ GetFreeSpace ¦ Определяет объем свободной памяти в ди-¦ ¦ ¦ намически распределяемой области. ¦ +---------------------+-----------------------------------------+ ¦ GlobalAlloc ¦ Выделяет блок памяти в динамически расп-¦ ¦ ¦ ределяемой области. ¦ +---------------------+-----------------------------------------+ ¦ GlobalAllocPtr ¦ Выделяет и блокирует блок памяти (с по-¦ ¦ ¦ мощью вызовов GlobalAlloc и GlobalLock).¦ ¦ ¦ ¦ +---------------------+-----------------------------------------+ ¦ GlobalCompact ¦ Переупорядочивает память, распределен-¦ ¦ ¦ ную в динамической области, так что ос-¦ ¦ ¦ вобождается заданный объем памяти. ¦ +---------------------+-----------------------------------------+ ¦ GlobalDiscard ¦ Выгружает заданный объект памяти. ¦ +---------------------+-----------------------------------------+ ¦ GlobalDosAlloc ¦ Распределяет память, к которой можно по-¦ ¦ ¦ лучить доступ в реальном режиме DOS. Эта¦ ¦ ¦ память будет существовать в первом мега-¦ ¦ ¦ байте линейного адресного пространства. ¦ +---------------------+-----------------------------------------+ ¦ GlobalDosFree ¦ Освобождает память, выделенную ранее с¦ ¦ ¦ помощью GlobalDosAlloc. ¦ +---------------------+-----------------------------------------+ ¦ GlobalFlags ¦ Получает информацию о блоке памяти. ¦ +---------------------+-----------------------------------------+ ¦ GlobalFree ¦ Освобождает разблокированный блок памяти¦ ¦ ¦ и делает его описатель недействительным.¦ +---------------------+-----------------------------------------+ ¦ GlobalFreePtr ¦ Разблокирует и освобождает блок памяти¦ ¦ ¦ с помощью GlobalUnlock и GlobalFree. ¦ +---------------------+-----------------------------------------+ ¦ GlobalHandle ¦ Получает описатель объекта в памяти по¦ ¦ ¦ заданному адресу сегмента. ¦ +---------------------+-----------------------------------------+ ¦ GlobalLock ¦ Увеличивает счетчик ссылки блока памяти¦ ¦ ¦ и возвращает указатель на него. ¦ +---------------------+-----------------------------------------+ ¦ GlobalLockPtr ¦ То же, что и GlobalLock, но вместо опи-¦ ¦ ¦ сателя воспринимает указатель. ¦ +---------------------+-----------------------------------------+ ¦ GlobalLRUNewest ¦ Перемещает объект в памяти на новую не-¦ ¦ ¦ давно используемую позицию, минимизируя,¦ ¦ ¦ таким образом, вероятность выгрузки¦ ¦ ¦ объекта. ¦ +---------------------+-----------------------------------------+ ¦ GlobalLRUOldest ¦ Перемещает объект в памяти на самую¦ ¦ ¦ "старую" недавно используемую позицию,¦ ¦ ¦ максимизирую вероятность выгрузки объ-¦ ¦ ¦ екта. ¦ +---------------------+-----------------------------------------+ ¦ GlobalNorify ¦ Вызывает адрес экземпляра процедуры уве-¦ ¦ ¦ домления, передавая описатель блока, ко-¦ ¦ ¦ торый нужно выгрузить. ¦ +---------------------+-----------------------------------------+ ¦ GlobalPageLock ¦ Увеличивает значение счетчика блокиров-¦ ¦ ¦ ки для памяти, связанной с данным селек-¦ ¦ ¦ тором. ¦ +---------------------+-----------------------------------------+ ¦ GlobalPageUnlock ¦ Уменьшает значение счетчика блокировки¦ ¦ ¦ для памяти, связанной с данным селекто-¦ ¦ ¦ ром. ¦ +---------------------+-----------------------------------------+ ¦ GlobalPtrHandle ¦ По заданному указателю на блок памяти¦ ¦ ¦ возвращает описатель этого блока. ¦ +---------------------+-----------------------------------------+ ¦ GlobalReAlloc ¦ Перераспределяет блок памяти. ¦ +---------------------+-----------------------------------------+ ¦ GlobalReAllocPtr ¦ Разблокирует, перераспределяет и блоки-¦ ¦ ¦ рует блок памяти (используя функции¦ ¦ ¦ GlobalUnlock, GlobalReAlloc и¦ ¦ ¦ GlobalLock). ¦ +---------------------+-----------------------------------------+ ¦ GlobalSize ¦ Определяет текущий размер блока памяти. ¦ +---------------------+-----------------------------------------+ ¦ GlobalUnfix ¦ Разблокирует блок памяти, блокированный¦ ¦ ¦ ранее с помощью GlobalLock. ¦ +---------------------+-----------------------------------------+ ¦ GlobalUnockPtr ¦ То же, что и GlobalUnlock, но вместо¦ ¦ ¦ описателя воспринимает указатель. ¦ +---------------------+-----------------------------------------+ ¦ LockSegment ¦ Блокирует заданный выгружаемый сегмент. ¦ +---------------------+-----------------------------------------+ ¦ UnlockSegment ¦ Разблокирует сегмент. ¦ L---------------------+------------------------------------------ Функция GlobalAlloc используется для распределения блоков памяти. Для их освобождения применяется функция GlobalFree. Адми- нистратор памяти поддерживает три типа блоков памяти: фиксирован- ный, перемещаемый и выгружаемый. Фиксированный блок остается в одних и тех же адресах физической памяти. Перемещаемый блок может перемещаться в физической памяти и освобождать место для других запросов на выделение памяти, а выгружаемые блоки могут выгру- жаться из памяти, освобождая место для других блоков. С помощью передаваемых GlobalAlloc флагов вы можете выбрать один из этих трех типов: * gmem_Fixed (фиксированный) * gmem_Moveable (перемещаемый) * gmem_Moveable + gmem_Discardable (выгружаемый) Прикладная программа обычно выделяет только перемещаемые блоки памяти, которые представляются типом THandle в модуле WinAPI. Описатель памяти - это значение размером в слово, которое идентифицирует блок памяти аналогично тому, как описатель файла - это значение размером в слово, идентифицирующее открытый файл. Перед тем как вы сможете получить доступ к памяти, его нужно заблокировать с помощью функции GlobalAlloc, а когда вы закончите к нему обращаться, его нужно разблокировать с помощью функции GlobalUnlock. GlobalLock возвращает полный 32-разрядный указатель на первый байт блока. Смещение указателя всегда равно 0. В защи- щенном режиме DOS селектор указателя - это тоже самое, что описа- тель блока, но в Windows это не всегда так. Правильная последовательность вызовов для выделения, блоки- ровки, разблокировки или освобождения блока показана в приведен- ном ниже примере. В данном примере H - это переменная типа THandle, а P - указатель: H := GlobalAlloc(gmem_Moveable, 8192); { выделение блока } if H <> then { если память выделена } begin P := GlobalLock(H); { блокировка блока } . . { доступ к блоку через P } . GlobalUnlock(H); { разблокировать блок } GlobalFree(H); { освободить блок } end; Блокировка и разблокировка блока при каждом обращении к нему достаточно утомительна и ведет к ошибкам, и реально она необходи- ма только для выгружаемых блоков и в прикладных программах Windows, работающих в реальном режиме. Во всех других ситуациях лучшим решением является блокировка блока сразу после его выделе- ния и сохранение этого состояния до освобождения блока. С этой целью модуль WinAPI включает в себя семейство подпрограмм-"оболо- чек" GlobalXXXXPtr. Особый интерес представляет функция GlobalAllocPtr, которая выделяет и блокирует блок памяти, и функ- ция GlobalFreePtr, разблокирующая и освобождающая блок памяти. С помощью этих подпрограмм приведенный выше пример можно упростить: H := GlobalAlloc(gmem_Moveable, 8192); { выделение блока } if H <> then { если память выделена } begin . . { доступ к блоку } . GlobalFreePtr(P); { освободить блок } end; Вызвав функцию GlobalReAlloc, вы можете изменить размер или атрибуты блока памяти, сохранив его содержимое. Функция GlobalReAlloc возвращает новый описатель блока, который может от- личаться от передаваемого функции описателя, если старый размер или новый размер блок превышает 64К. Заметим, что в тех случаях, когда старый размер блока и новый его размер меньше 64К, GlobalReAlloc всегда может изменить размер блока, не изменяя его описателя. Функция GlobalReAlloc можно также использоваться для измене- ния атрибутов блока. Это можно сделать, задав наряду с gmem_Moveable или gmem_Discardable флаг gmem_Modify. Функция GlobalReAlloc выполняет те же действия, что и GlobalReAlloc, но обе они вместо описателей использует указатели. Имеется также ряд других, менее часто используемых GlobalXXXX. Все они подробно описаны в Главе 1 ("Справочник по библиотеке") "Справочного руководства программиста".

Управление модулем

Администратор этапа выполнения поддерживает следующие подп- рограммы обслуживания модулей: Подпрограммы API обслуживания модулей Таблица 17.3 ----------------------------T----------------------------------- ¦ Подпрограмма ¦ Описание ¦ +---------------------------+-----------------------------------+ ¦ FreeLibrary ¦ Делает недействительным загружен-¦ ¦ ¦ ный модуль библиотеки, и освобож-¦ ¦ ¦ дает соответствующую память, если¦ ¦ ¦ ссылок на модуль больше нет. ¦ +---------------------------+-----------------------------------+ ¦ GetModuleFileName ¦ Дает полный маршрут и имя выполня-¦ ¦ ¦ емого файла, задающий, откуда заг-¦ ¦ ¦ ружен модуль. ¦ +---------------------------+-----------------------------------+ ¦ GetModuleHandle ¦ Определяет описатель заданного мо-¦ ¦ ¦ дуля. ¦ +---------------------------+-----------------------------------+ ¦ GetModuleUsage ¦ Определяет счетчик ссылок на мо-¦ ¦ ¦ дуль. ¦ +---------------------------+-----------------------------------+ ¦ GetProcAddress ¦ Определяет адрес экспортируемой¦ ¦ ¦ библиотечной функции. ¦ +---------------------------+-----------------------------------+ ¦ LoadLibrary ¦ Загружает указанный библиотечный¦ ¦ ¦ модуль. ¦ L---------------------------+------------------------------------ Некоторые из этих подпрограмм воспринимают в качестве пара- метра описатель модуля. Описатель модуля самой прикладной прог- раммы хранится в переменной HInstance, описанной в модуле System.

Управление ресурсами

Администратор этапа выполнения поддерживает следующие подп- рограммы управления ресурсами: Функции API управления ресурсами Таблица 17.4 -----------------------T---------------------------------------- ¦ Функция ¦ Описание ¦ +----------------------+----------------------------------------+ ¦ AccessResource ¦ Открывает заданный выполняемый файл и¦ ¦ ¦ перемещает указатель файла на начало¦ ¦ ¦ заданного ресурса. ¦ +----------------------+----------------------------------------+ ¦ FindResource ¦ Определяет адрес ресурса в заданном¦ ¦ ¦ файле ресурса. ¦ +----------------------+----------------------------------------+ ¦ FreeResource ¦ Уменьшает счетчик ссылок для загружен-¦ ¦ ¦ ного ресурса. Когда значение этого¦ ¦ ¦ счетчика становится равным нулю, то ис-¦ ¦ ¦ пользуемая ресурсом память освобождает-¦ ¦ ¦ ся. ¦ +----------------------+----------------------------------------+ ¦ LoadResource ¦ Загружает заданный ресурс в память. ¦ +----------------------+----------------------------------------+ ¦ LoadString ¦ Загружает заданную строку ресурса. ¦ +----------------------+----------------------------------------+ ¦ LockResource ¦ Блокирует заданный ресурс в памяти и¦ ¦ ¦ увеличивает его счетчик ссылок. ¦ +----------------------+----------------------------------------+ ¦ SizeOfResource ¦ Возвращает размер (в байтах) заданного¦ ¦ ¦ ресурса. ¦ +----------------------+----------------------------------------+ ¦ UnlockResource ¦ Разблокирует заданный ресурс и уменьша-¦ ¦ ¦ ет на 1 счетчик ссылок на ресурс. ¦ L----------------------+----------------------------------------- Ресурсы могут компоноваться с прикладной программой с по- мощью директив компилятора {$R имя_файла}. Указанные файлы должны быть файлами ресурсов Windows (.RES). Обычно с прикладными прог- раммами защищенного режима DOS компонуются только строковые ре- сурсы и ресурсы, определенные пользователем. Другие типы ресурсов Windows к прикладной программе DOS обычно неприменимы. Примечание: Ресурсы Turbo Vision не следуют тем же соглашениям, что ресурсы Windows, и к ним нельзя обращаться с помощью подпрограмм API. Некоторые подпрограммы API управления ресурсами требуют ука- зания описателя экземпляра, которым обычно является указатель эк- земпляра прикладной программы (который содержится в переменной HInstance модуля System).

Управление селектором

Прикладной программе обычно не требуется манипулировать се- лекторами, но в отдельных ситуациях полезно использовать следую- щие подпрограммы обслуживания селектора: Подпрограммы API управления селектором Таблица 17.5 ------------------------T--------------------------------------- ¦ Функция ¦ Описание ¦ +-----------------------+---------------------------------------+ ¦ AllocDStoCSAlias ¦ Отображает селектор сегмента данных на¦ ¦ ¦ селектор сегмента кода. ¦ +-----------------------+---------------------------------------+ ¦ AllocSelector ¦ Выделяет новый селектор. ¦ +-----------------------+---------------------------------------+ ¦ ChangeSelector ¦ Генерирует селектор кода, соответству-¦ ¦ ¦ щий заданному селектору данных, или¦ ¦ ¦ генерирует заданный селектор, соот-¦ ¦ ¦ ветствующий селектору кода. ¦ +-----------------------+---------------------------------------+ ¦ FreeSelector ¦ Освобождает селектор, первоначально¦ ¦ ¦ выделенный функциями AllocDStoCSAlias¦ ¦ ¦ или AllocSelector. ¦ +-----------------------+---------------------------------------+ ¦ GetSelectorBase ¦ Дает базовый адрес селектора. ¦ +-----------------------+---------------------------------------+ ¦ GetSelectorLimit ¦ Возвращает предельное значение для за-¦ ¦ ¦ данного селектора. ¦ +-----------------------+---------------------------------------+ ¦ PrestoChangoSelector¦ Генерирует селектор кода, соответству-¦ ¦ ¦ ющий заданному селектору данных, либо¦ ¦ ¦ генерирует селектор данных, соответс-¦ ¦ ¦ твующий селектору кода. ¦ +-----------------------+---------------------------------------+ ¦ SetSelectorBase ¦ Устанавливает базовый адрес селектора.¦ +-----------------------+---------------------------------------+ ¦ SetSelectorLomit ¦ Устанавливает предельное значение се-¦ ¦ ¦ лектора. ¦ L-----------------------+----------------------------------------

Другие подпрограммы API

Администратор этапа выполнения поддерживает следующие допол- нительные подпрограммы API: Прочие подпрограммы API Таблица 17.6 --------------------T------------------------------------------- ¦ Функция ¦ Описание ¦ +-------------------+-------------------------------------------+ ¦ DOS3Call ¦ Вызывает функцию прерывания DOS 21h; вызы-¦ ¦ ¦ вается только из подпрограмм ассемблера. ¦ +-------------------+-------------------------------------------+ ¦ FatalExit ¦ Передает отладчику текущее состояние опе-¦ ¦ ¦ рационной среды защищенного режима и вы-¦ ¦ ¦ выводит подсказку для ввода инструкций о¦ ¦ ¦ продолжении работы. ¦ +-------------------+-------------------------------------------+ ¦ GetDOSEnviroment¦ Определяет текущую строку операционной¦ ¦ ¦ среды задачи. ¦ +-------------------+-------------------------------------------+ ¦ GetVersion ¦ Дает текущую версию операционной среды¦ ¦ ¦ Windows или операционной системы DOS. ¦ +-------------------+-------------------------------------------+ ¦ GetWinFlags ¦ Дает используемые Windows флаги конфигура-¦ ¦ ¦ ции памяти. ¦ +-------------------+-------------------------------------------+ ¦ MessageBox ¦ Создает, выводит на экран и обслуживает¦ ¦ ¦ окно сообщений. ¦ L-------------------+-------------------------------------------- Совместно используемая DLL, чтобы определить, выполняется ли она в защищенном режиме DOS или под Windows, может использовать функцию GetWinFlags, например: if GetWinFlags and wf_DPMI <> 0 then Message('Работа в защищенном режиме DOS') else Message('Работа в среде Windows');

Прямой доступ к DPMI-серверу

Прямой доступ к DPMI-серверу вы можете получить через преры- вание $31, которое непосредственно вызывает DPMI-сервер в обход администратора этапа выполнения. Однако это опасный прием. DPMI не поддерживает очистку ресурсов, таких как векторы прерываний памяти; корректно с этими проблемами работает администратор этапа выполнения. Вы должны глубоко понимать концепции защищенного ре- жима и знать о существенном риске, с которым связано использова- ние данного метода доступа защищенного режима.

Компиляция прикладной программы защищенного режима

В большинстве случаев для получения прикладной программы за- щищенного режима вам не нужно делать ничего особенного. Просто скомпилируйте свою программу, задав в качестве целевой работы за- щищенный режим одним из следующих способов: * В IDE выберите команду Compile¦Target и в диалоговом окне Target Platform (Целевая платформа) выберите Protected-mode Application. * При использовании компилятора, работающего в режиме ко- мандной строки, укажите для выбора в качестве целевой платформы защищенного режима параметр /CP.

Выполнение программы защищенного режима DOS

Когда вы выполняете программу DOS защищенного режима, нужно обеспечить наличие в текущем каталоге или по маршруту DOS файлов DPMI16BI.OVL (сервер DPMI), RTM.EXE (администратор этапа выполне- ния) и всех DLL, с которыми работает ваша программа. Примечание: Лицензионное соглашение позволяет вам распространять файлы DPMI16BI.OVL и RTM.EXE вместе с вашей программой. В выполняемом файле .EXE защищенного режима DOS используется тот же формат файла, что и в Windows 3.x и OS/2 1.x. Этот формат файла является надмножеством обычного формата .EXE DOS и состоит из обычного образа файла .EXE, называемого фиктивным модулем, за которым следует расширенный заголовок и код, данные и ресурсы за- щищенного режима. Ниже показана последовательность событий при выполнении программы защищенного режима DOS. 1. DOS загружает фиктивный модуль реального режима и переда- ет ему управление. 2. Если средства DPMI отсутствуют, то фиктивный модуль заг- ружает DPMI-сервер из файла DPMI16BI.OVL. Некоторые новые администраторы памяти поддерживают средства DPMI (как, например, это делается в окне DOS улучшенного режима Windows 3.х). В таких конфигурациях фиктивный модуль не загружает DPMI-сервер, но использует уже имеющийся. 3. Далее, если администратор этапа выполнения еще не загру- жен в память, фиктивный модуль загружает его из файла RTM.EXE. Если прикладная программа защищенного режима вы- полняет другую программу защищенного режима, обе исполь- зуют одну копию администратора этапа выполнения. 4. Если средства DPMI и администратор этапа выполнения при- сутствуют, фиктивный модуль переключается из реального в защищенный режим и передает управление расширенному заг- рузчику .EXE в администратора этапа выполнения. 5. Загрузчик сначала загружает используемую прикладной прог- раммой DLL (если она имеется), затем загружает сегменты кода и данных прикладной программы. Наконец, загрузчик передает управление на точку входа прикладной программы. При выполнении вашей прикладной программы защищенного режима DOS всегда возможно ситуация, когда уже присутствует DMPI-сервер, отличный от сервера Borland. Поскольку между серверами могут быть небольшие различия, особенно в плане обработки прерываний DOS, вы должны проверить программу и убедиться, что она работает со всеми возможными серверами, которые могут ей встретиться. Когда прикладная программа защищенного режима DOS выполняет- ся в окне DOS улучшенного режима Windows, вы можете управлять объемом расширенной памяти, которую выделяет администратор этапа выполнения, задав в файле .PIF прикладной программы предельное значение памяти XMS.

Управление объемом используемой RTM памяти

По умолчанию администратор этапа выполнения использует при загрузке всю доступную память. Затем по запросам он выделяет па- мять своим клиентам (через подпрограммы API администратора памя- ти). В защищенном режиме нет разницы между обычной памятью (ниже 1 мегабайта) и расширенной памятью (с адресами выше 1 мегабайта); для программ защищенного режима доступны оба типа памяти. Однако администратор этапа выполнение отдает предпочтение расширенной памяти. Только после того как вся расширенная память будет выде- лена, или когда прикладная программа специально запрашивает обычную память (например, с помощью функции GlobalDosAlloc), ад- министратор этапа выполнения выделяет обычную память. Причина, по которой администратор этапа выполнения предпочи- тает расширенную память, заключается в том, что прикладная прог- рамма может с помощью вызова подпрограммы Exec в модуле Dos по- рождать другие прикладные программы. Порожденные прикладные прог- раммы не обязательно являются программами защищенного режима; та- ким образом, им может потребоваться обычная память. Фактически, порожденные программы защищенного режима запускаются как програм- мы реального режима и переключаются в защищенный режим только после успешной загрузки фиктивным модулем средств DPMI и адми- нистратора этапа выполнения. Администратор этапа выполнения перед порождением прикладной программы пытается освободить максимальный объем обычной памяти (например, перенеся перемещаемые блоки в расширенную память). Од- нако попытки освобождения расширенной памяти не предпринимаются. Таким образом, если должны порождаться прикладные программы защи- щенного режима, не использующие администратор этапа выполнения, то необходим споcоб управления распределением памяти администра- тором этапа выполнения. Чтобы управлять тем, сколько памяти может использовать адми- нистратор этапа выполнения, в командной строке DOS добавьте к строке операционной среды DOS переменную среды RTM: SET RTM={параметр nnnn} Возможные параметры перечислены в следующей таблице. Значе- ние nnnn может быть десятичным или шестнадцатиричным числом в ви- де xAB54 или xab54. Параметры переменной операционной среды RTM, используемые для управления памятью Таблица 17.7 ---------------------T------------------------------------------ ¦ Параметр ¦ Описание ¦ +--------------------+------------------------------------------+ ¦ EXTLEAVE nnnn ¦ Всегда оставляет не менее nnnn килобайт¦ ¦ ¦ доступной расширенной памяти. По умолча-¦ ¦ ¦ нию это значение равно 640К. ¦ +--------------------+------------------------------------------+ ¦ EXTMAX nnnn ¦ Не выделяет более nnnn килобайт расширен-¦ ¦ ¦ ной памяти. По умолчанию используется¦ ¦ ¦ значение 4 гигабайта. В Windows использу-¦ ¦ ¦ емое по умолчанию значение равно половине¦ ¦ ¦ доступной памяти. ¦ +--------------------+------------------------------------------+ ¦ EXTMIN nnnn ¦ Если после применения EXTMAX или EXTLEAVE¦ ¦ ¦ доступно менее nnnn килобайт, то програм-¦ ¦ ¦ ма завершается с сообщением о нехватке¦ ¦ ¦ памяти (Out of memory). По умолчанию это¦ ¦ ¦ значение равно 0. ¦ +--------------------+------------------------------------------+ ¦ REALLEAVE nnnn ¦ Всегда оставляет не менее nnnn параграфов¦ ¦ ¦ доступной реальной памяти. По умолчанию¦ ¦ ¦ это значение равно 64К или 4096 парагра-¦ ¦ ¦ фов. ¦ +--------------------+------------------------------------------+ ¦ REALMAX nnnn ¦ Не выделяет более nnnn параграфов реаль-¦ ¦ ¦ ной памяти. По умолчанию это значение¦ ¦ ¦ равно 1 мегабайту или 65535 параграфов. ¦ +--------------------+------------------------------------------+ ¦ REALMIN nnnn ¦ Если после применения REALMAX и REALLEAVE¦ ¦ ¦ доступно менее nnnn параграфов, то прог-¦ ¦ ¦ рамма завершается с сообщением о нехватке¦ ¦ ¦ памяти (Out of memory). По умолчанию это¦ ¦ ¦ значение равно 0. ¦ L--------------------+------------------------------------------- Следующая команда DOS ограничивает RTM 2 мегабайтами расши- ренной памяти и обеспечивает, что нераспределенными останутся 128К реальной памяти. SET RTM=EXTMAX 2048 REALLEAVE 8192

[ Назад | Оглавление | Далее ]










helloworld.ru © 2001-2018
Все права защищены
Rambler's Top100 TopList