WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Часть I. Введение в операционные системы Глава 1. История промышленных операционных систем 1. UNIX-подобные ОС: VAX/VMS, UNIX, BSD, Sun OS, HP-UX, Linux (Бах) 2. ОС на базе Mach: NeXT, DEC OSF/1,

Rhapsody, Mac OS X (СИТ) 3. ОС семейства Windows: 3.11, NT, 95 (Хелен Кастер) 4. BeOS (Книга Бытия) Глава 2. Встраиваемые ОС 1. Мобильные устройства: PalmOS, EPOC/Symbian, Windows CE 2. Промышленные системы: OS 9000, VxWorks 3. Системы реального времени: CMX, ITRON, eCos, RTEMS 4. QNX 5. Chorus OS 6. NewOS Глава 3. Принципы построения современных операционных систем 1. Переносимость 2. Многопроцессорность 3. Многозадачность 4. Синхронизация 5. Память 6. Шинные драйверы, прерывания 7. Файловая система 8. Микроядро и серверы 9. Защита Глава 4. Прикладное окружение операционных исстем 1. Системные API: Win32, POSIX 2. Вспомогательные объектные окружения: OpenSTEP, ActiveX 3. Коммуникационные окружения: RPC, CORBA, DCOM 4. Виртуальные машины: Java,.NET Глава 5. Системы граффического интерфейса 1. Персональные системы 2. Рабочие станции 3. Интерфейсы мобильных устройств 4. Automotive GUI промышленных устройств Глава 6. Сеть и защита 1. Модели защитиы: ACL 2. Протоколы коммуникаций и алгоритмы 3. Linux ipchains/iptables и BSD TCP/IP стэк Часть II. Проэктирование операционных систем Глава 7. Практические аспекты реализации ОС 1. Архитектуры 32- и 64-битных процессоров 2. 32- и 16-битные процессоры и микроконтроллеры 3. 8-битные микроконтроллеры 4. Бутстрэппинг Глава 8. Вспомогательные алгоритмы 1. Односвязные списки 2. Двухсвязные списки: общеобъектные структуры 3. Очереди: сообщения, семафоры, блокировки 4. Стэки 5. Кольца: приоритеты, периодические процессы 6. Хип: локальный внутрипроцессный менеджер памяти 7. Хэш: аллокация объектов, таблицы символов 8. Деревья: виртуальная память, самобалансировка 9. Таблицы: блочные и журнальные структуры Глава 9. Объекты ядра 1. Потоки 2. Семафоры 3. Хип 4. Сообщения 5. Порты 6. Виртуальные адрессные пространства 7. Процессы 8. Шинные драйверы и стэк прерываний 9. Прерывания и планировщик 10. Каналы, мейлбоксы и вспомогательные объекты Глава 10. Структурная организация операционной системы 1. Монолитные ядра 2. Микроядерная клиент/серверная архитектура 3. Микроядерная мультисистемная клиент/сервер архитектура 4. Монопроцессные встраиваемые микроядра Глава 11. Минимальный набор рабочей системы 1. Терминал: клавиатура и дисплей 2. Драйвер диска 3. Файловая система Часть III. Реализация операционных систем Глава 12. Переносимая 8-битная ОС для микроконтроллеров 1. Введение 2. Объекты и модель программирования 3. Бутстрэппинг на Motorola HC08 и Motorola M 4. Потоки 5. Планировщик 6. Прерывания 7. Мэнеджер памяти 8. Семафоры 9. Таймер 10. Главный процесс 11. Таймер 12. Особенности переключения потоков Глава 13. Переносимая универсальная 32-битная система 1. Введение 2. Объекты и модель программирования 3. Бутстрэппинг на i 4. PCI стэк 5. USB стэк 6. Драйвер диска 7. Драйвер PS/2 клавиатуры 8. Драйвер VGA консоли 9. Потоки 10. Семафоры 11. Менеджер виртуальной памяти 12. TCP/IP стэк 13. Встроенный отладчик 14. Мэнеджер ELF образов 15. Хип мэнеджер 16. Мэнеджер прерываний 17. Процесс init 18. Менеджер модулей 19. Порты 20. Менеджер файловых систем: boot, root, dev и pipe 21. Утилиты: хэш, блокировки, очереди Приложения Приложения А. Исходные тескты для самообразования (в алфавитном порядке) 1. 3OSRU – Русская ос на стадии бутстрэппинга 2. Apple – исходные коды микроядра Darwin (Apple) 3. Apple-ISO9660 – CD-ROM с рабочей версией Darwin для Intel 4. ChorusOS – Микроядерная ОС от Sun 5. eCos1 – Встраиваемая ОС от Red Hat (разрабатывалась Cygnus) 6. EPOC7 – ОС для мобильных телефонов от Symbian 7. EUROS – Евпропейская ОС для микроконтроллеров 8. ITRON – Японский стандарт на страиваемые промышленные ОС 9. Linux – Linux сервер на OSF микроядре Mach (MkLinux для PowerPC) 10. Lites – Lites 4.4BSD сервер для Mach 11. Mach3 – Оригинальная версия Mach от Университета Кэгреги Мэлона 12. Morph – Спецификация ОС для PowerPC 13. NanoI – Как компилировать на gcc raw code 14. NewOS – New OS 15. OSTEP – Спецификация на объектную модель OpenStep от NeXT 16. Palm5 – ОС для органайзеров 17. QNX60 – CD-ROM с канадской микроядерной ОС реального времени 18. RTEMS – ОС реального времени для министерства обороны США 19. Tru64 – Спецификация на POSIX Thread для Tru64 UNIX (OSF Mach) 20. Yamit – Еще одна версия OSF ветки Mach Часть I. История промышленных операционных систем 1. UNIX UNIX имеет долгую и интересную историю. Начавшись как несерьезный и почти "игрушечный" проект молодых исследователей, UNIX стал многомиллионной индустрией, включив в свою орбиту университеты, многонациональные корпорации, правительства и международные организации стандартизации.

UNIX зародился в лаборатории Bell Labs фирмы AT&T более 20 лет назад. В то время Bell Labs занималась разработкой многопользовательской системы разделения времени MULTICS (Multiplexed Information and Computing Service) совместно с MIT и General Electric, но эта система потерпела неудачу, отчасти из за слишком амбициозных целей, не соответствовавших уровню компьютеров того времени, а отчасти и из-за того, что она разрабатывалась на языке PL/1, а компилятор PL/1 задерживался и вообще плохо работал после своего запоздалого появления.

Поэтому Bell Labs вообще отказалась от участия в проекте MULTICS, что дало возможность одному из ее исследователей, Кену Томпсону, заняться поиском работы в направлении улучшения операционной среды Bell Labs. Томпсон, а также сотрудник Bell Labs Денис Ритчи и некоторые другие разрабатывали новую файловую систему, многие черты которой вели свое происхождение от MULTICS.

Для проверки новой файловой системы Томпсон написал ядро ОС и некоторые программы для компьютера GE-645, который работал под управлением мультипрограммной системы разделения времени GECOS. У Кена Томпсона была написанная им еще во времена работы над MULTICS игра "Space Travel" - "Космическое путешествие". Он запускал ее на компьютере GE-645, но она работала на нем не очень хорошо из-за невысокой эффективности разделения времени. Кроме этого, машинное время GE-645 стоило слишком дорого. В результате Томпсон и Ритчи решили перенести игру на стоящую в углу без дела машину PDP-7 фирмы DEC, имеющую 4096 18-битных слов, телетайп и хороший графический дисплей. Но у PDP-7 было неважное программное обеспечение, и, закончив перенос игры, Томпсон решил реализовать на PDP-7 ту файловую систему, над который он работал на GE-645. Из этой работы и возникла первая версия UNIX, хотя она и не имела в то время никакого названия. Но она уже включала характерную для UNIX файловую систему, основанную на индексных дескрипторах inode, имела подсистему управления процессами и памятью, а также позволяла двум пользователям работать в режиме разделения времени. Система была написана на ассемблере. Имя UNIX (Uniplex Information and Computing Services) было дано ей еще одним сотрудником Bell Labs, Брайаном Керниганом, который первоначально назвал ее UNICS, подчеркивая ее отличие от многопользовательской MULTICS. Вскоре UNICS начали называть UNIX.

Первыми пользователями UNIX'а стали сотрудники отдела патентов Bell Labs, которые нашли ее удобной средой для создания текстов.

Большое влияние на судьбу UNIX оказала перепись ее на языке высокого уровня С, разработанного Денисом Ритчи специально для этих целей. Это произошло в 1973 году, UNIX насчитывал к этому времени уже 25 инсталляций, и в Bell Labs была создана специальная группа поддержки UNIX.

Широкое распространение UNIX получил с 1974 года, после описания этой системы Томпсоном и Ритчи в компьютерном журнале CACM. UNIX получила широкое распространение в университетах, так как для них она поставлялась бесплатно вместе с исходными кодами на С. Широкое распространение эффективных C-компиляторов сделало UNIX уникальной для того времени ОС из за возможности переноса на различные компьютеры. Университеты внесли значительный вклад в улучшение UNIX и дальнейшую его популяризацию. Еще одним шагом на пути получения признания UNIX как стандартизованной среды стала разработка Денисом Ритчи библиотеки ввода-вывода stdio. Благодаря использованию этой библиотеки для компилятора С, программы для UNIX стали легко переносимыми.

Широкое распространение UNIX породило проблему несовместимости его многочисленных версий. Очевидно, что для пользователя весьма неприятен тот факт, что пакет, купленный для одной версии UNIX, отказывается работать на другой версии UNIX. Периодически делались и делаются попытки стандартизации UNIX, но они пока имели ограниченный успех. Процесс сближения различных версий UNIX и их расхождения носит циклический характер. Перед лицом новой угрозы со стороны какой-либо другой операционной системы различные производители UNIX-версий сближают свои продукты, но затем конкурентная борьба вынуждает их делать оригинальные улучшения и версии снова расходятся.

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

Наибольшее распространение получили две весьма несовместимые линии версий UNIX: линия AT&T - UNIX System V, и линия университета Berkeley - BSD. Многие фирмы на основе этих версий разработали и поддерживают свои версии UNIX:

SunOS и Solaris фирмы Sun Microsystems, UX фирмы Hewlett-Packard, XENIX фирмы Microsoft, AIX фирмы IBM, UnixWare фирмы Novell (проданный теперь компании SCO), и список этот можно еще долго продолжать.

Наибольшее влияние на унификацию версий UNIX оказали такие стандарты как SVID фирмы AT&T, POSIX, созданный под эгидой IEEE, и XPG4 консорциума X/Open. В этих стандартах сформулированы требования к интерфейсу между приложениями и ОС, что дает возможность приложениям успешно работать под управлением различных версий UNIX.

Независимо от версии, общими для UNIX чертами являются:

• многопользовательский режим со средствами защиты данных от несанкционированного доступа;

• реализация мультипрограммной обработки в режиме разделения времени, основанная на использовании алгоритмов вытесняющей многозадачности (preemptive multitasking);

• использование механизмов виртуальной памяти и свопинга для повышения уровня мультипрограммирования;

• унификация операций ввода-вывода на основе расширенного использования понятия "файл";

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

• переносимость системы за счет написания ее основной части на языке C;

• разнообразные средства взаимодействия процессов, в том числе и через сеть;

• кэширование диска для уменьшения среднего времени доступа к файлам.

UNIX System V Release 4 вобрала в себя лучшие черты линий UNIX System V и UNIX BSD. Версия UNIX System V Release 4 - это незаконченная коммерческая версия операционной системы, т.к. в ее кодах отсутствуют многие системные утилиты, необходимые для успешной эксплуатации ОС, например утилиты администрирования или менеджер графического интерфейса. Версия SVR является скорее стандартной реализацией кода ядра, вобравшая в себя наиболее популярные и эффективные решения из различных версий ядра UNIX, такие как виртуальная файловая система VFS, отображаемые в память файлы и т.п. Код SVR4 (частично доработанный) лег в основу многих современных коммерческих версий UNIX, таких как HP-UX, Solaris, AIX и т.д.

2. Mach Mach - яркий пример одного из немногих проектов, который вопреки своему большому влиянию на развитие индустрии, так мало знаком не только конечному потребителю, но и профессионалам, которые в силу узкой специализации так и не столкнулись со столь необычным детищем академической формализации профессоров университета Карнеги-Мэллона.

Система Mach имела в качестве предшественницы систему RIG - Rochester Intelligent Gateway, начало разработки которой пришлось на 1975 год. RIG была написана для 16-битового мини-компьютера компании DataGeneral под названием Elipce. Целью этой разработки была демонстрация возможностей структурирования операционной системы и представления ее в виде набора процессов, которые могут взаимодействовать между собой путем передачи сообщений, в том числе и по сети. Затем эта операционная система была улучшена путем добавления средств защиты и средств прозрачной работы в сети и получила название Accent (в 1981 году, в университете Карнеги-Меллона). В 1984 году она уже использовалась на 150 компьютерах PERQ - ранних графических станциях, но проиграла соревнование с UNIX'ом. Это обстоятельство побудило создать третье поколение ОС, использующей механизм обмена сообщениями. Этот проект и был назван Mach. В связи с тем, что Mach проектировалась как система, совместимая с UNIX, планировалась поддержка большого количества приложений для UNIX. Кроме совместимости с UNIX, в Mach были введены и другие усовершенствования, включая нити, улучшенные механизмы межпроцессного взаимодействия, поддержка многопроцессорных систем, улучшенная виртуальная память и др.

В это время агентство DARPA искало операционную систему для поддержки мультипроцессоров. Выбор был сделан в пользу университета Карнеги-Меллона, и работы над ОС Mach были продолжены. Было решено сделать эту систему совместимой с 4.2BSD путем комбинации Mach и 4.2BSD в виде единого ядра. Хотя этот подход привел к большому ядру, он гарантировал абсолютную совместимость. Первая версия Mach была реализована в 1986 году для VAX11/784, 4-х процессорной машины. Вскоре эта ОС была перенесена на IBM PC RT и Sun 3.

К 1987 году Mach выполнялась также на мультипроцессорах Encore и Sequent.

Хотя Mach и имела сетевые средства, ее скорее можно было отнести к ОС отдельной машины или мультипроцессора, а не к сетевой распределенной прозрачной системе.

OSF Вскоре была создана организация производителей компьютеров OSF (IBM, DEC, Hewlett Packard) для того, чтобы отобрать контроль над ОС UNIX у ее собственника AT&T. Они выбрали Mach 2.5 в качестве основы для их первой операционной системы OSF/1. Хотя Mach 2 и OSF/1 содержали большое количество кода Berkeley и AT&T, была надежда, что OSF, по крайней мере, сможет контролировать направление развития UNIX. В 1988 году ядро Mach 2. было большим и монолитным из-за того, что содержало большое количество кода Berkeley UNIX. А в 1989 году университет Карнеги-Меллона удалил весь код BSD UNIX из ядра и поместил его в пользовательское пространство. То, что осталось, было микроядром, состоящим из чистого кода Mach. Эта версия 3.0 и используется как основа последующих версий OSF.

Digital Equipment Corporation которая поставляла OSF/1 версию UNIX в 1990 году. В настоящие дни, так как DEC была приобретена Compaq, DEC OSF/1 UNIX сейчас носит название Tru64 UNIX и ориентирована на сервера HP. Домашняя страница Tru64 UNIX находится по адресу www.tru64unix.compaq.com. В 1996 году последством слияния OSF и X/Open консорциума появилась компания Open Group (www.opengroup.org), которая сейчас является основным стандартизатором UNIX.

NeXT В 1988 году Стив Джобс, один из основателей Aplle, ушел оттуда, для того чтобы удоволетворить свои амбции и, уединившись, создать легендарную ОС вместе с ексклюзивным аппаратным обеспечением. В результате деятельности новой компании NeXT, был создан аппаратно-программный комплекс с одноименным названием. Первые версии операционной системы NEXTSTEP, которая устанавливалась на компьютеры NeXT,были основаны на ранних версиях Mach 2.0, основанных на оригинальном коде от CMU. Позже, после выходом Mach 3, NeXT перешла на OSF версию ядра. Исходные файлы первых версий NEXTSTEP продавались за $10000. Для университетов представлялась 50%скидка.

NeXT Computer Inc.и Sun Microsystems Inc.в конце 1993 объединились для создания свободорго объектного API на основе объектной модели NEXTSTEP.Эта совмесная деятельность вылилась в спецификацию OpenStep,которая была опубликована NeXT в 1994 году. Следует отметить что нетривиальная OpenStep API представляла собой не только изящную среду программирования наподобие современных объектных тулкитов типа GTK+или Qt,но и определяла окружение для баз данных и других программных сервисов. Сейчас OpenStep API стараются поддерживать GNU в виде GNUStep, их сайт www.gnustep.org.

NeXT никогда не позиционировала свои компьютеры как "вещи для масс".

Последнии версии NEXTSTEP были портированы под i386 и носили название OPENSTEP [*Последняя версия OPENSTEP 4.2,не путать название со спецификацией объектного API OpenStep ].В 1997 году произошло слияние компания NeXT и Apple, а Стив Джобс перешел в "свою" новую фирму и позже вновь возглавил ее.

Apple Вместе с NeXT, после покупки, Aplle получила в распоряжение не увидевший свет проэкт Rhapsody OS который должен был стать основой будущей операционной системы Apple.Немного позже все узнают ее под именем Mac OS X - операционной системой далеко отодвинувшей границы показателей надежности,удобности и архитектурного совершенства. Новая Mac OS X унаследовала от Rhapsody OS не только микроядро Mach 3.0 редакции OSF, но и всю объектную модель на котой была построена OPENSTEP, основным инструментом, для программирования которой, служил компилятор gcc с поддержкой Objective C.

Mac OS X Хотелось бы отдельно поговорить об истории Mac OS X и ее корнях, которые ведут к NeXT.В начале 1997 года Apple Computers Inc.и NeXT Software Inc.анонсировали своё объединение. Было сказано,что Стив Джобс (руководитель NeXT) вернется,как консультант,в компанию которую он основал 20 лет назад.

После объявления открытой модели OpenStep, Sun не очень то активно принимала участвие в продвижении реализации. Таким образом, NeXT стала единственной компанией, кто поддерживал открытую спецификацию и реализацию OpenStep API. В духе кроссплатформенности OpenStep была перенесена на четыре платформы (М68000, Intel, Sparc, PA-RISC) и работала под управлением операционных систем Mach, Solaris и Windows NT.

В 1997 году под екстримальным давлением time to market, Rhapsody OS, первая общая операционная система Apple и NeXT была перенесена на PowerPC за месяца. По своей сути Rhapsody OS была расширенной версией OPENSTEP с поддержкой совместимости со старыми программами Mac OS (модуль Blue Box) и внешним видом ОС семейства Macintosh. В средине года демо-версия Rhapsody OS была представлена на World Wide Developers Conference 97.

Бета-весия OPENSTEP 4.2 для платформы Intel была представлена как "прелюдия к рапсодии", которая позволит разработчикам поближе узнать OpenStep API.После релиза OPENSTEP 4.2, Apple не сильно ее афишировала и продавала как среду для разработки под WebObjects, пока не выйдет Mac OS X.

Основное внимание Apple по-прежнему было сосредоточено на традиционных макинтошах.

Apple вновь заняла лидирующие позиции, когда выпустила ряд устпешный решений в виде iMac, iBook, AirPort, PowerBook G3,PowerMac G4 и др.уже под непосредсвенным руководством Стива Джобса - нового CEO Apple. Идея кроссплатформенности, пропитывающая Rhapsody OS,канула в лета. После выхода Rhapsody OS DR1 (Developer Release) в конце 1997 года Apple нуждалась в новой ветке операционных систем, систем которые должны были стать основой нового парка Apple.

Гиганты программного обеспечения, такие как Microsoft, Adobe, Quark не сильно спешили портировать свои приложения под нативный (Yellow Box) OpenStep API, так же не хотелось оставаться на исчерпавшим себя Blue Box - основой старых макинтошей.

В 1998 году на WWDC Mac OS X была главной темой. Новый Carbon API был технологией, которая позволила сделать плавный переход для всего программного обеспечения под Apple.Apple дала понять что она фокусируется исключительно на своей аппарной платформе и не собирается поддерживать отличные от нее. Это был удар по пользователям NeXT.

Mac OS X Server 1.0 стал новой основной целью Apple после Rhapsody.Компания не спешила его выпускать до появления новый технологий. Ими стали NetBoot и QuickTime Streaming Server.Только после этого появился удачный случай анонсировать новую ОС. Дебют Mac OS X Server 1.0 состоялся в начале года. Теперь команда разработчиков полностью занялась доводкой флагмана Mac OS X.

Mac OS X концептуально идентична Mac OS X Server, но некотрые ее части были полностью переписаны (ядро ОС Darwin, IOKit, Core Foundation, Quartz, Java2 и др.). В 1999 году на WWDC был представлен Mac OS X DP1 (Developer Preview).

Во втором DP2 была значительно улучшена стабильность, плюс, добавилось несколько нововведений, такие как загрузка с HFS+.Те кто видел, эти ранние версии,знают,что конечный вид должен был быть совершенно другим.

В 2000 году, наконец, на MacWorld Apple полностью представила свою Mac OS X стратегию. Новая Mac OS X уже имела незабываемый интерфейс Aqua,который сразу напомнил всем NeXT. Многие концепции NeXT GUI, которые казалось потеряны навсегда, обрели новую жизнь...

Цели проекта Mach ОС Mach значительно изменилась со времени ее первой реализации в виде RIG.

Цели проекта также изменились со временем. На текущий момент основные цели выглядят так:

• Обеспечение базовых функций для создания других операционных систем, например, UNIX или, возможно других.

• Поддержка больших разреженных адресных пространств.

• Обеспечение прозрачного доступа к сетевым ресурсам.

• Поддержка параллелизма как в системе, так и в приложениях.

• Обеспечение переносимости Mach на различные типы компьютеров.

Микроядро Mach было разработано в качестве основы, на базе которой можно эмулировать UNIX и другие ОС. Эта эмуляция осуществляется программным уровнем, который работает вне ядра, в пользовательском пространстве. Следует отметить, что несколько эмуляторов могут работать одновременно, так что можно выполнять программы 4.3BSD, System V и MS-DOS на одной машине в одно и то же время.

Ядро Mach, подобно другим микроядрам, обеспечивает управление процессами, управление памятью, коммуникации и функции ввода-вывода. Функции управления файлами, каталогами и другие традиционные для операционных систем функции выполняются в пользовательском пространстве. Идея построения ядра Mach состоит в обеспечении механизмов, необходимых для работы системы, но стратегия использования этих механизмов реализуется на уровне пользовательских процессов.

Ядро управляет пятью главными абстракциями:

• Процессы • Нити • Объекты памяти • Порты • Сообщения Кроме этого, ядро работает и с некоторыми другими абстракциями, или связанными с указанными, или менее важными.

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

Например, коммуникационный канал всегда принадлежит одному процессу.

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

Процесс, состоящий из одной нити, подобен традиционному (например, как в UNIX) процессу.

Концепцией, уникальной для Mach, является введение понятия объект памяти (memory object), представляющий собой структуру данных, которая может быть отображена в адресное пространство процесса. Объекты памяти занимают одну или несколько страниц и образуют основу для системы управления виртуальной памятью Mach. Когда процесс ссылается на объект памяти, который не представлен в физической памяти, это вызывает страничное прерывание. Как и в других ОС, ядро перехватывает страничное прерывание. Однако в отличие от других систем, ядро Mach для загрузки отсутствующей страницы посылает сообщение серверу пользовательского режима, а не самостоятельно выполняет эту операцию.

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

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

Процесс может предоставить другому процессу возможность посылать (или получать) сообщения в один из принадлежащих ему портов. Такая возможность реализуется в виде мандата (capability), который включает не только указатель на порт, но и список прав, которыми другой процесс обладает по отношению к данному порту (например, право выполнить операцию ПОСЛАТЬ - SEND). Все коммуникации в Mach используют этот механизм.

Сервер Mach BSD UNIX Как уже было сказано выше, разработчики системы Mach модифицировали Berkeley UNIX для работы в пользовательском пространстве в форме прикладной программы. Такая структура имеет несколько преимуществ по сравнению с монолитным ядром. Во-первых, система упрощается за счет разделения на часть, которая выполняет управление ресурсами (ядро), и часть, которая обрабатывает системные вызовы (UNIX-сервер), и ею становится легче управлять. Такое разделение напоминает разделение труда в операционной системе VM/ мейнфреймов IBM, где ядро эмулирует набор "голых" 370-х машин, на каждой из которых реализована однопользовательская операционная система.

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

В-третьих, как уже было упомянуто выше, несколько ОС могут работать одновременно. Например, на процессоре Intel 386 Mach может выполнять программу UNIX и программу MS-DOS одновременно. Аналогично возможно одновременное тестирование новой экспериментальной ОС и работа с основной ОС.

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

Микроядро Mach Ядро любой современной коммерческой версии UNIX представляет собой набор очень большого количества функций, с запутанными взаимосвязями и очень расплывчатыми границами между основными подсистемами. В результате любая модификация организованной таким образом системы дается тяжело и приводит к появлению в новых версиях большого количества ошибок. Кроме того, не во всех инсталляциях нужны все компоненты ядра, а при монолитном его построении удаление ненужных функций затруднено. Недостатки, присущие операционным системам с большим монолитным ядром (а это в первую очередь различные версии UNIX'а), породили интерес к системам, построенным на основе микроядра.

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

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

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

Во-вторых, микроядра лицензируются и используются как готовый программный продукт в качестве основы для построения коммерческой сетевой операционной системы. Сейчас имеется несколько коммерческих реализаций операционных систем на основе микроядра Mach (NextStep фирмы Next, UNIX BSD, OSF/1 v.1.3), а также проводится ряд работ по использованию этого ядра. Так как свойства микроядра в значительной степени определяют свойства ОС, построенной на его основе, то знание микроядра помогает в оценке характеристик использующей его ОС.

Управление процессами в Mach Процессы Процесс в Mach - это, в первую очередь, адресное пространство и набор нитей, которые выполняются в этом адресном пространстве. Таким образом, выполнение связано с нитями, а процессы являются пассивными объектами и служат для сбора всех ресурсов, использующихся группой взаимосвязанных нитей, в удобные контейнеры.

Кроме адресного пространства и нитей, процесс характеризуется используемыми им портами и некоторыми параметрами. Все порты, показанные на рисунке, имеют специальное назначение. Порт процесса используется для взаимодействия с ядром. Многие из функций ядра процесс может вызывать путем отправки сообщения на порт процесса, а не с помощью системного вызова. Этот механизм используется в Mach всюду для уменьшения количества системных вызовов до возможного минимума. Некоторые из системных вызовов будут далее обсуждены.

Вообще говоря, программист может даже не знать, выполняется ли сервис с помощью системного вызова или нет. Всем сервисам, вызываемым как с помощью системных вызовов, так и с помощью передачи сообщений, соответствуют эрзац процедуры (заглушки, или стабы) в библиотеке. Это именно те процедуры, которые описаны в руководствах и которые вызываются прикладными программами. Эти процедуры генерируются на основании описания сервиса с помощью компилятора MIG (Mach Interface Generator).

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

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

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

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

Параметры планирования, помимо нитей, определяются также для процессов. Эти параметры включают возможность определения того, на каких процессорах могут выполняться нити данного процесса. Это свойство наиболее полезно для многопроцессорных систем. Например, процесс может использовать это свойство для того, чтобы заставить выполняться нить на разных процессорах, или заставить все нити работать на одном процессоре, или реализовать какой-нибудь промежуточный вариант. Кроме того, каждый процесс имеет приоритет, который можно устанавливать. При создании нити ей присваивается этот приоритет. Также имеется возможность изменять приоритет всех существующих нитей.

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

Также полезно упомянуть, чем не обладает процесс Mach по сравнению с процессами UNIX'а. Процесс не содержит: идентификатор пользователя, групповой идентификатор, маску сигналов, корневой каталог, рабочий каталог, массив дескрипторов файлов. Вся эта информация содержится в параметрах процесса на уровне сервера пользовательского режима.

Примитивы управления процессами Mach предусматривает небольшое количество примитивов управления процессами. Большинство из них выполняется путем посылки сообщения ядру через порт процесса. Наиболее важные из этих вызовов: Create, Terminate, Suspend, Resume, Priority, Assign, Info, Threads. Первые два вызова предназначены для создания и уничтожения процессов. Вызов Create определяет прототип процесса, которым не обязательно является вызывающий процесс. Потомок является копией прототипа, за исключением случая наследования родительского адресного пространства, который определяется заданием параметра. Если адресное пространство не наследуется, то объекты (например, текст, инициализированные данные и стек) могут быть отображены в него позже.

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

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

Когда счетчик равен 0, то процесс может выполняться. Наличие счетчика позволяет избежать гонок.

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

Нити Активными объектами в Mach являются нити. Все нити процесса разделяют одно адресное пространство и имеют общие в пределах процесса ресурсы, показанные на рисунке 6.2. Кроме того, каждая нить имеет и свои особые ресурсы. Одним из таких ресурсов является порт нити, который является аналогом порта процесса и который используется нитью для того, чтобы вызывать специальные, ориентированные на нити, сервисы ядра, например, функцию завершения нити.

Так как порты являются общими ресурсами для всех нитей одного процесса, каждая нить имеет доступ к портам своих нитей-братьев, таким образом каждая нить может управлять другой нитью, если это необходимо. Нити Mach управляются ядром, то есть они являются тем, что иногда называют "тяжеловесными" нитями, в отличие от "легковесных" нитей (нитей, полностью выполняющихся в пользовательском пространстве). Создание и уничтожение нитей осуществляется ядром и включает обновление структур данных ядра. Нити ядра предоставляют базовые механизмы для управления множеством "активностей" в общем адресном пространстве. Что делать с этими механизмами - это дело пользователя.

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

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

Когда он положителен, нить должна ждать, пока другая нить не уменьшит его до нуля. Такой механизм позволяет нитям управлять поведением друг друга. Имеется некоторое множество примитивов, связанных с нитями. Базовый интерфейс ядра обеспечивает примерно 2 десятка примитивов для нитей. Многие из них связаны с планированием. На базе этих примитивов можно строить различные пакеты нитей.

Гораздо более скромные возможности предоставляет так называемый C-пакет нитей, поддерживаемый Mach (который был положен в основу пакета OSF). Этот пакет предназначен для того, чтобы дать возможность пользователям использовать нитевые примитивы ядра в простой и доступной форме. Он не предоставляет всю мощность, которую предлагает интерфейс ядра, однако он достаточен для реализации задач среднего уровня сложности. Этот пакет обладает свойством переносимости на широкий круг операционных систем и архитектур. С-пакет содержит 6 вызовов, предназначенных для непосредственного манипулирования нитями: Fork, Exit, Join, Detach, Yield, Self.

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

Когда нить завершает свою работу, она выполняет вызов Exit. Если родительская нить заинтересована фактом завершения данной нити и выполнила вызов Join, то родительская нить блокирует себя до тех пор, пока данная нить, порожденная ею, не завершится. Если эта нить уже завершилась, родительская нить немедленно продолжает свое выполнение. Эти три вызова является грубыми аналогами системных вызовов UNIX'а FORK, EXIT и WAITPID.

Четвертый вызов, Detach, в UNIX'е отсутствует. Он обеспечивает способ, с помощью которого какая-либо нить может объявить, что ее не следует ждать.

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

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

Синхронизация осуществляется с помощью мьютексов и переменных состояния.

Примитивами мьютексов являются вызовы Lock, Trylock и Unlock. Также есть примитивы для распределения и освобождения мьютексов.

Реализация С-нитей в Mach В Mach существует несколько реализаций С-нитей. Оригинальная реализация выполняет все нити в пользовательском пространстве внутри одного процесса.

Этот подход основан на разделении во времени всеми С-нитями одной нити ядра.

Этот подход может также использоваться в UNIX'е или любой другой системе, в которой нет поддержки нитей ядром. Такие нити работают как разные подпрограммы одной программы, что означает, что они планируются невытесняющим образом. Например, в случае типовой задачи "производитель покупатель" производитель должен заполнить буфер, а затем заблокироваться, чтобы дать шанс покупателю на выполнение.

Данная реализация имеет недостаток, присущий всем нитевым пакетам, работающим в пользовательском пространстве без поддержки ядра. Если одна нить выполняет блокирующий системный вызов, например, чтение с терминала, то блокируется весь процесс. Чтобы избежать этой ситуации, программист должен избегать использовать блокирующие системные вызовы. В BSD UNIX имеется системный вызов SELECT, который может быть использован для того, чтобы узнать, имеется ли символ в буфере терминала. Но в целом операция остается запутанной.

Вторая реализация использует одну Mach-нить для одной С-нити. Эти нити планируются с вытеснением. В многопроцессорных системах нити могут действительно работать параллельно на различных процессорах. Фактически возможно мультиплексирование m пользовательских нитей с n нитями ядра, хотя наиболее общим случаям является n=m.

В третьей реализации для каждого процесса выделяется одна нить ядра.

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

Недостатком этого метода является то, что порты, UNIX-файлы и другие ресурсы процесса не могут разделяться.

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

Планирование Планирование в Mach в значительной степени определяется тем, что она предназначена для работы на многопроцессорных системах. Так как система с одним процессором является частным случаем многопроцессорной системы, мы сконцентрируем свое внимание на планировании в многопроцессорных системах.

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

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

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

Планирование нитей в Mach основано на приоритетах. Приоритеты - это целые числа от 0 до 31, причем 0 соответствует наивысшему приоритету, а 31 - самому низшему. Каждой нити присваиваются три значения, влияющих на его приоритет.

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

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

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

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

Основной алгоритм планирования заключается в следующем. Когда нить блокируется, завершается или исчерпывает свой квант, процессор, на котором она выполнялась, прежде всего просматривает свою локальную очередь, на предмет того, есть ли в ней какие-либо нити. Для этого анализируется счетчик нитей, связанный с этой очередью. Если он не равен 0, процессор начинает искать наиболее приоритетную нить, начиная с очереди, указанной в переменной-ссылке.

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

Если готовая нить обнаружена, то она получает возможность выполняться в течение одного кванта. По завершении кванта, обе очереди - локальная и глобальная - просматриваются, чтобы узнать, нет ли еще нитей с таким же или более высоким приоритетом, с учетом того, что все нити из локальной очереди имеют более высокий приоритет, чем нити в глобальной очереди. Если подходящий кандидат найден, то происходит переключение нити. Если нет, то активная нить выполняется еще в течение одного кванта. Нить может быть также вытеснена. На многопроцессорной системе длина кванта может быть переменной, в зависимости от числа нитей, которые готовы к выполнению. Увеличение числа готовых нитей и уменьшение числа процессоров укорачивает квант. Такой алгоритм дает хорошее время ответа для коротких запросов, даже если система сильно загружена, и обеспечивает высокую эффективность (длинный квант) для мало загруженных систем.

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

В некоторых приложениях над решением одной проблемы работает большое количество нитей, поэтому для них важно иметь возможность управлять планированием в деталях. Mach предоставляет нитям дополнительное средство управления планированием (кроме процессорных наборов и приоритетов). Таким средством является системный вызов, который позволяет нити снижать свой приоритет до абсолютного минимума в течение указанного количества секунд. Это дает возможность выполняться другим нитям. После того как указанный интервал истечет, приоритету возвращается его прежнее значение.

Этот системный вызов имеет другое интересное свойство: он может назвать своего наследника, если захочет. Например, после отсылки сообщения другой нити посылающая нить освобождает процессор и требует, чтобы следующей выполнялась нить-получатель. Этот механизм, называемый планированием с передачами, минует все очереди. Если его использовать с умом, то можно повысить производительность. Ядро также использует этот механизм при некоторых обстоятельствах в качестве оптимизации.

Ядро Mach может быть сконфигурировано так, чтобы реализовывать так называемое аффинное планирование, но обычно такая опция не устанавливается.

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

Управление памятью в Mach Ядро Mach имеет мощную, тщательно разработанную и в высшей степени гибкую систему управления памятью, основанную на страничном механизме и обладающую многими редкими свойствами. В частности, в нем машинно зависимая часть кода отделена от машинно-независимой части чрезвычайно ясным и необычным способом. Это разделение делает управление памятью более мобильным, чем в других системах. Кроме того, система управления памятью тесно взаимодействует с коммуникационной системой.

Одной из основных особенностей системы управления памятью Mach является то, что ее код разбит на три части. Первая часть называется pmap, который работает в ядре и занимается работой с устройством отображения виртуальных адресов в физические (Memory Management Unit, MMU). Эта часть устанавливает значения регистров MMU и аппаратных страничных таблиц, а также перехватывает все страничные прерывания. Эта часть кода зависит от архитектуры MMU и должна быть переписана для каждой новой машины всякий раз, когда Mach на нее переносится. Вторая часть - это машинно-независимый код ядра, и он связан с обработкой страничных сбоев, управляет отображением областей памяти и заменой страниц.

Третья часть кода работает в пользовательском пространстве в качестве процесса, называемого "менеджер памяти" (memory manager) или иногда "внешний менеджер страниц" (external pager). Эта часть имеет дело с логическими аспектами (в отличие от физических) системы управления памятью, в основном, с управлением хранения образов памяти на диске. Например, менеджер памяти отслеживает информацию о том, какие виртуальные страницы используются, какие находятся в оперативной памяти и где они хранятся на диске, когда не находятся в оперативной памяти. Ядро и менеджер памяти взаимодействуют с помощью хорошо определенного протокола, что дает возможность для пользователей ядра Mach писать свои собственные менеджеры памяти. Такое разделение обязанностей позволяет реализовывать страничные системы специльного назначения. При этом ядро становится потенциально меньше и проще, так как значительная часть кода работает в пользовательском пространстве. С другой стороны, это и источник усложнения ядра, так как при этом оно должно защищать себя от ошибок или некорректной работы менеджера памяти. Кроме того, при наличии двух активных частей системы управления памятью возможно возникновение гонок между ними.

Виртуальная память Концептуально модель памяти в Mach выглядит для пользовательских процессов в виде большого линейного виртуального адресного пространства. Для большинства 32-х разрядных процессоров адресное пространство занимает диапазон от 0 до 232 - 1 (4 Гбайта). Адресное пространство поддерживается страничным механизмом.

Mach обеспечивает очень тонкое управление механизмом использования виртуальных страниц (для тех процессов, которые интересуются этим). Для начала скажем о том, что адресное пространство может использоваться разреженным способом. Например, процесс может иметь дюжину секций виртуального адресного пространства, каждая из которых находится на расстоянии сотен мегабайт от ближайшего соседа, с большими зазорами неиспользуемого адресного пространства между этими секциями.

Теоретически любое виртуальное адресное пространство может быть разреженным, так что способность использовать большое количество разбросанных секций не является в действительности свойством архитектуры виртуальной памяти. Другими словами, любая 32-х битная машина должна позволять процессу иметь 50 000 секций данных, разделенных промежутками по 100 Мбайт, в пределах от 0 до 4 Гбайт. Однако, во многих реализациях линейная страничная таблица от 0 до самой старшей используемой страницы хранится в памяти ядра. На машине с размером страницы в 1 Kб эта конфигурация требует миллиона элементов таблицы страниц, делая такую схему очень дорогой, если не невозможной. Даже при многоуровневой организации страничной таблицы такая разреженность в лучшем случае неприемлема. В ядре Mach при его разработке изначально ставилась задача полной поддержки разреженных адресных пространств.

Для того, чтобы определить, какие виртуальные адреса используются, а какие нет, Mach обеспечивает способ назначения и отмены секций виртуального адресного пространства, называемых областями (regions). В вызове для назначения области можно определить базовый адрес и размер, и область выделяется там, где это указано. В другом случае может быть задан только размер области, а система сама находит подходящий диапазон адресов и возвращает базовый адрес. Виртуальный адрес является действительным только в том случае, когда он попадает в назначенный диапазон. Попытка использовать адрес из промежутков между назначенными областями вызывает прерывание, которое может быть перехвачено самим процессом, если он этого пожелает.

Ключевым понятием, связанным с использованием виртуального адресного пространства, является объект памяти (memory object). Объект памяти может быть страницей или набором страниц, а также может быть файлом или другой, более специальной, структурой данных, например, записью базы данных. Объект памяти может быть отображен в неиспользуемую часть виртуального адресного пространства, формируя новую область. Когда файл отображен в виртуальное адресное пространство, то его можно читать или в него можно писать с помощью обычных машинных команд. Отображенные (mapped) файлы постранично вытесняются из памяти обычным образом. Когда процесс завершается, то его отображенные в память файлы автоматически возвращаются в файловую систему вместе со всеми изменениями, произошедшими с их содержанием в то время, когда они были отображены в память. Также возможно отменить отображение файла или другого объекта памяти, освобождая его адресное пространство и делая его доступным для последовательного его распределения или отображения.

Конечно, отображение файлов в память не единственный способ доступа к ним.

Их содержимое можно читать и обычным способом. Однако и в этом случае библиотечные функции могут отображать файлы в память помимо желания пользователя, а не использовать систему ввода-вывода. Такой способ позволяет страницам файлов использовать систему виртуальной памяти, а не специально выделенные буфера где-либо в системе.

Mach поддерживает некоторое количество вызовов для работы с виртуальным адресным пространством: Allocate, Deallocate, Map, Copy, Inherit, Read, Write. Они не являются истинными системными вызовами. Вместо этого все они используют запись сообщения в порт процесса для вызова соответствующих функций ядра.

Первый вызов, Allocate, делает область виртуальных адресов используемой.

Процесс может наследовать назначенное адресное пространство, а может и назначить дополнительное, но любая попытка обратиться к неназначенному адресу будет вызывать ошибку. Второй вызов, Deallocate, освобождает область (то есть удаляет ее из карты памяти), что дает возможность назначить ее заново или отобразить что-нибудь в нее, используя вызов Map.

Вызов Copy копирует объект памяти в новую область. Оригинальная область остается неизменной. Операция Copy выполняется оптимизированным способом с использованием разделяемых страниц, чтобы избежать физического копирования.

Вызов Inherit влияет на способ наследования областью свойств при создании нового процесса. Адресное пространство может быть сконфигурировано так, что некоторые области будут наследовать свойства, а некоторые нет. Это будет обсуждаться ниже.

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

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

Разделение памяти Разделение играет важную роль в Mach. Для разделения объектов нитями одного процесса никаких специальных механизмов не требуется: все они автоматически видят одно и то же адресное пространство. Если одна из них имеет доступ к части данных, то и все его имеют. Более интересной является возможность разделять двумя или более процессами одни и те же объекты памяти, или же просто разделять страницы памяти для этой цели. Иногда разделение полезно в системах с одним процессором. Например, в классической задаче производитель потребитель может быть желательным реализовать производителя и потребителя разными процессами, но иметь общий буфер, в который производитель мог бы писать, а потребитель - брать из него данные.

В многопроцессорных системах разделение объектов между процессами часто более важно, чем в однопроцессорных. Во многих случаях задача решается за счет работы взаимодействующих процессов, работающих параллельно на разных процессорах (в отличие от разделения во времени одного процессора). Этим процессам может понадобиться непрерывный доступ к буферам, таблицам или другим структурам данных, для того, чтобы выполнить свою работу. Существенно, чтобы ОС позволяла такой вид разделения. Ранние версии UNIX'а не предоставляли такой возможности, хотя потом она была добавлена.

Рассмотрим, например, систему, которая анализирует оцифрованные спутниковые изображения Земли в реальном масштабе времени, в том темпе, в каком они передаются со спутника. Такой анализ требует больших затрат времени, и одно и то же изображение может проверяться на возможность его использования в предсказании погоды, урожая или отслеживании загрязнения среды. Каждое полученное изображение сохраняется как файл.

Для проведения такого анализа можно использовать мультипроцессор. Так как метеорологические, сельскохозяйственные и экологические программы очень отличаются друг от друга и разрабатываются различными специалистами, то нет причин делать их нитями одного процесса. Вместо этого каждая программа является отдельным процессом, который отображает текущий снимок в свое адресное пространство. Заметим, что файл, содержащий снимок, может быть отображен в различные виртуальные адреса в каждом процессе. Хотя каждая страница только один раз присутствует в памяти, она может оказаться в картах страниц различных процессов в различных местах. С помощью такого способа все три процесса могут работать над одним и тем же файлом в одно и то же время.

Другой важной областью разделяемости является создание процессов. Как и в UNIX'е, в Mach основным способом создания нового процесса является копирование существующего процесса. В UNIX'е копия всегда является двойником процесса, выполнившего системный вызов FORK в то время как в Mach потомок может быть двойником другого процесса (прототипа).

Одним из способов создания процесса-потомка состоит в копировании всех необходимых страниц и отображения копий в адресное пространство потомка.

Хотя этот способ и работает, но он необоснованно дорог. Коды программы обычно используются в режиме только-для-чтения, так что их нельзя изменять, часть данных также может использоваться в этом режиме. Страницы с режимом только для-чтения нет необходимости копировать, так как отображение их в адресные пространства обоих процессов выполнит необходимую работу. Страницы, в которые можно писать, не всегда могут разделяться, так как семантика создания процесса (по крайней мере в UNIX) говорит, что хотя в момент создания родительский процесс и процесс-потомок идентичны, последовательные изменения в любом из них невидимы в другом адресном пространстве.

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

Для обеспечения гибкости Mach позволяет процессу назначить атрибут наследования каждой области в адресном пространстве. Различные области могут иметь различные значения атрибута. Предусмотрены три значения атрибута:

• Область не используется в процессе-потомке.

• Область разделяется между процессом-прототипом и потомком.

• Область в процессе-потомке является копией прототипа.

Если область имеет первое значение, то в процессе-потомке она отсутствует.

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

Второй вариант представляет собой истинное разделение памяти. Страницы области присутствуют как в адресном пространстве прототипа, так и потомка.

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

Третья возможность - копирование всех страниц области и отображение копий в адресное пространство потомка. FORK использует этот вариант. В действительности Mach не выполняет реального копирования страниц, а использует вместо этого стратегию, называемую копирование-при-записи (copy on-write). Она состоит в том, что все необходимые страницы помещаются в карту виртуальной памяти потомка, но помечаются при этом как предназначенные только для чтения, как это показано на рисунке 6.7. Пока потомок только читает из этих страниц, все работает замечательно.

Однако, если потомок пытается писать в одну из этих страниц, происходит прерывание по защите памяти. Затем операционная система делает копию этой страницы и отображает копию в адресное пространство потомка, заменяя ей защищенную от записи страницу. Новая страница помечается как доступная для чтения и записи. Например, потомок пытается произвести запись в страницу 7.

Это действие приводит к тому, что страница 7 копируется в страницу 8, а страница 8 отражается в адресное пространство вместо страницы 7. Страница помечается для чтения и записи, так что запись в нее не вызовет прерывание.

Механизм копирование-при-записи имеет несколько преимуществ по сравнению со способом прямого копирования всех страниц в момент создания нового процесса.

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

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

Внешние менеджеры памяти В начале нашего обсуждения средств управления памятью в Mach мы кратко упомянули о менеджерах памяти пользовательского режима. Теперь рассмотрим их более детально. Каждый объект памяти, который отображается в адресное пространство процесса, должен иметь внешний менеджер памяти, который им управляет. Объекты памяти различных классов управляются различными менеджерами памяти. Каждый из них может реализовывать свою собственную семантику, может решать, где хранить данные страниц, которые не находятся в физической памяти, и следовать своим собственным правилам при решении вопроса о том, что делать с объектами после того, как их отображение в память отменяется.

Для того, чтобы отобразить какой-либо объект в адресное пространство процесса, этот процесс посылает сообщение менеджеру памяти, запрашивая операцию отображения. Для того, чтобы выполнить эту работу, нужны три порта. Первый, порт объекта (object port), создается менеджером памяти и используется в дальнейшем ядром для информирования менеджера памяти о страничных отказах и других событиях, связанных с объектом. Второй порт, порт управления, создается самим ядром, так что менеджер памяти может реагировать на эти события (многие из них требуют проведения некоторых действий менеджером памяти). Использование различных портов связано с тем, что порты являются однонаправленными. В порт объекта пишет ядро, а читает менеджер памяти, а порт управления работает в обратном направлении.

Третьим является порт имени (name port), который используется как разновидность имени, с помощью которого идентифицируется объект. Например, нить может передать ядру виртуальный адрес и спросить, к какой области он относится. Ответом будет указатель на порт имени. Если адреса относятся к одной и той же области, то они будут идентифицироваться одним и тем же портом имени.

Когда менеджер памяти отображает объект, он обеспечивает создание порта объекта как одного из параметров. Затем ядро создает два других порта и посылает инициализирующее сообщение на порт объекта, несущее информацию о портах управления и имени. Затем менеджер памяти посылает ответ, сообщая ядру о том, какими являются атрибуты объекта, а также о том, нужно или нет хранить объект в кэше после того, как отображение будет отменено. Изначально все страницы объекта помечаются как запрещенные по чтению и записи, чтобы вызвать прерывание при первом использовании.

В этом месте менеджер памяти выполняет чтение порта объекта и блокирует себя.

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

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

Когда менеджер памяти узнает о страничном отказе, он проверяет, является ли обращение разрешенным. Если нет, то он посылает ядру сообщение об ошибке.

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

Ядро отображает страницу в адресное пространство вызвавшего обращение процесса. Теперь нить может быть разблокирована. Этот процесс повторяется до тех пор, пока все нужные страницы не загрузятся.

Чтобы быть уверенным в том, что существует необходимый запас свободных страничных кадров, нить страничного демона время от времени просыпается и проверяет состояние памяти. Если свободных страничных кадров физической памяти недостаточно, то она собирает информацию о старых "грязных" страницах и отсылает ее менеджеру памяти, ответственному за объект, которому принадлежат страницы. Ожидается, что менеджер памяти запишет эти страницы на диск и сообщит, когда эта операция будет завершена. Если страница относится к файлу, то менеджер сначала найдет смещение страницы в файле, а затем запишет ее туда. Используемый при этом алгоритм замены - это второй вопрос.

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

В дополнение к особым менеджерам памяти, которые отображают файлы и другие специальные объекты, имеется менеджер памяти "по умолчанию" (default) для "обычного" отображения страниц. Когда процесс просит выделить ему область виртуального адресного пространства с помощью вызова Allocate, то фактически происходит отображение объекта, управляемого менеджером памяти "по умолчанию". Этот менеджер поставляет заполненные нулями страницы, если это необходимо. Он использует временный файл для образования пространства на диске для свопинга страниц, а не специальную область на диске, как это делается в UNIX'е.

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

Список типов сообщений, которые ядро посылает менеджеру памяти:

• Init - Инициализировать новый отображенный в память объект • Data_request - Передать ядру определенную страницу для обработки страничного отказа • Data_write - Взять страницу из памяти и переписать ее • Data_unlock - Разблокирует страницу, так что ядро может ее использовать • Lock_completed - Завершено выполнение предшествующий запрос Lock_request • Terminate - Информирование о том, что данный объект больше не используется Когда объект отображается в память с использованием вызова Map, то ядро посылает сообщение Init соответствующему менеджеру памяти, чтобы позволить ему инициализировать себя. Это сообщение определяет порты, которые должны будут использоваться позже в диалоге с объектом. Запросы от ядра на получение страницы и поставку страницы осуществляются с помощью вызовов Data_request и Data_write соответственно. Эти сообщения управляют трафиком страниц в обоих направлениях, и поэтому являются наиболее важными вызовами.

Сообщение Data_unlock представляет собой запрос от ядра менеджеру памяти на разблокирование заблокированной страницы, так что ядро может использовать ее для другого процесса. Сообщение Lock_completed оповещает о завершении последовательности Lock_request, и будет рассмотрен ниже. Наконец, сообщение Terminate сообщает менеджеру памяти, что объект, имя которого указано в вызове, больше не используется и может быть удален из памяти. Существуют вызовы, определенные для менеджера памяти "по умолчанию".

Сообщения, передаваемые от внешнего менеджера памяти ядру:

• Set_attributes - Ответ на вызов Init • Data_provided - Ответ на вызов Data_request - здесь: запрошенная страница доставлена • Data_unavailable - Ответ на вызов - страницы нет в наличии • Lock_request - Запрашивает ядро для выполнения очистки, вытеснения или блокировки страниц • Destroy - Разрушить объект, который больше не нужен Первое сообщение, Set_attributes, является ответом на сообщение Init. Оно сообщает ядру, что менеджер готов обрабатывать вновь отображенный объект.

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

Сообщение Lock_request позволяет менеджеру памяти попросить ядро очистить некоторые страницы, то есть послать ему эти страницы, чтобы они могли быть записаны на диск. Это сообщение может быть использовано также и для того, чтобы изменить режим защиты страниц (чтение, запись, выполнение). Наконец, сообщение Destroy служит для уведомления ядра о том, что некоторый объект больше не нужен.

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

Распределенная разделяемая память в Mach Концепция внешних менеджеров памяти в Mach хорошо подходит для реализации распределенной страничной разделяемой памяти. В этом разделе будут кратко описаны некоторые из работ, выполненные в этой области. Основная идея состоит в том, чтобы получить единое, линейное виртуальное адресное пространство, которое разделяется между процессами, работающими на компьютерах, которые не имеют какой-либо физической разделяемой памяти. Когда нить ссылается на страницу, которой у нее нет, то происходит страничное прерывание. Требуемая страница отыскивается на одном из дисков сети, доставляется на ту машину, где произошел страничный сбой, и помещается в физическую память, так что нить может продолжать работать.

Так как Mach уже имеет менеджеры памяти для различных классов объектов, то естественно ввести новый объект памяти - разделяемую страницу. Разделяемые страницы управляются одним или более специальными менеджерами памяти.

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

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

Рассмотрим наиболее общий случай: одна разделяемая страница, централизованное управление и полная согласованность памяти. Все остальные страницы локальны для каждой отдельной машины. Для реализации этой модели нам понадобится один менеджер памяти, который обслуживает все машины системы. Назовем его сервером распределенной разделяемой памяти (Distributed Shared Memory, DSM). DSM-сервер обрабатывает ссылки на разделяемую страницу. Обычные менеджеры памяти управляют остальными страницами. До сих пор мы молчаливо подразумевали, что менеджер или менеджеры памяти, которые обслуживают данную машину, должны быть локальными для этой машины.

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

Разделяемая страница всегда доступна для чтения или записи. Если она доступна для чтения, то она может копироваться (реплицироваться) на различные машины.

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

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

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

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

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

Следует отметить, что менеджер памяти Mach является менджером памяти операционной системы FreeBSD.

Коммуникации в ядре Mach Основной целью, которую ставили перед собой разработчики средств коммуникации ядра Mach, являлась поддержка различных стилей коммуникаций в сочетании с надежностью и гибкостью. Коммуникационные средства ядра Mach могут поддерживать асинхронную передачу сообщений, RPC, потоки байт (streams), а также другие способы. Механизм взаимодействия процессов Mach базируется на соответствующих механизмах своих предшественников - RIG и Accent. Из-за своего эволюционного развития этот механизм приспособлен больше для локального использования, а не для распределенных систем.

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

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

Порт поддерживает взаимодействие подобно конвейерам (pipes) в UNIX. Порт, который может быть использован для отправки запроса от клиента серверу, не может использоваться для отправки ответа от сервера клиенту. Для этого нужен второй порт. У каждого порта может быть только один процесс, читающий из него сообщения, и несколько процессов, пишущих в порт.

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

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

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

Если при использовании порта возникает ошибка, то о ней сообщается путем посылки сообщений на другие порты, чьи права хранятся здесь. Нити могут быть заблокированы при чтении из порта, поэтому в структуру порта включен указатель на список заблокированных нитей. Также важна возможность нахождения прав на чтение из порта (он может быть только один), поэтому такая информация тоже хранится в структуре данных порта. Если порт представляет собой порт процесса, то следующее поле содержит указатель на процесс, к которому порт относится. Если это порт нити, то это поле содержит указатель на структуру данных ядра для нити, и так далее. Имеется также несколько дополнительных полей, не описанных здесь.

Когда нить создает порт, то в ответ она получает целое число, идентифицирующее порт, аналогичное дескриптору файла в UNIX. Это число используется в последовательных вызовах, с помощью которых посылаются сообщения порту или принимаются сообщения от него, для того, чтобы идентифицировать, какой порт нужно использовать. Порты хранятся для процессов, а не для нитей, так что если одна нить создает порт и получает в ответ идентификатор 3, то другая нить того же процесса никогда не получит этот идентификатор при создании порта. Фактически ядро не запоминает информацию о том, какая нить какой порт создала.

Нить может передать права доступа к порту другой нити другого процесса. Ясно, что нельзя проделать это просто помещением соответствующего целого числа в сообщение, так же как и UNIX-процесс не может передать дескриптор файла для стандартного устройства вывода путем записи 1 в конвейер. Используемый для этого механизм защищен ядром, мы обсудим его позже. В данный момент времени важно только знать, что это можно сделать.

Например, два процесса, А и В, имеют доступ к одному и тому же порту. Процесс А послал сообщение для данного порта, а процесс В прочитал это сообщение.

Заголовок и тело сообщения физически копируются из А в порт, а затем из порта в В.

Для удобства порты можно группировать в наборы портов. Порт может относится максимум к одному набору портов. Можно произвести операцию чтения из набора портов (но записать сообщение можно только в один порт). Например, сервер может использовать этот механизм для одновременного чтения из большого количества портов. Ядро возвращает одно сообщение от одного порта набора. В отношении того, какой порт будет выбран, не дается никаких обещаний. Если все порты пусты, то сервер блокируется. В этом случае сервер может поддерживать разные порты для каждого из многих поддерживаемых им объектов и получать сообщения для каждого из них без необходимости выделять нить для каждого объекта. В соответствии с текущей реализацией все сообщения для набора портов ставятся в общую очередь, так что на практике нет особой разницы между получением из порта и получением из набора портов.

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

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

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

Входы этой таблицы содержат указатели на порты и определяют разрешенные над ними действия, и называются мандатами. Назовем таблицу списком прав доступа (списком мандатов).

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

Вызывающая нить и все другие нити того же процесса имеют равные права доступа. Целое число, возвращаемое нити, чтобы идентифицировать права доступа, является обычно индексом в списке прав. Далее мы будем называть это целое число именем права доступа (именем мандата).

Все нити одного процесса имеют равные права по доступу к портам процесса.

Права определяются по отношению к трем возможным операциям: ПОЛУЧИТЬ, ПОСЛАТЬ и ПОСЛАТЬ-ОДИН-РАЗ. Право ПОЛУЧИТЬ дает возможность обладателю этого права прочитать сообщение из порта. Ранее упоминалось, что связи в Mach однонаправленные. Это означает, что в любой произвольный момент только один процесс может иметь право ПОЛУЧИТЬ для данного порта. Мандат с правом ПОЛУЧИТЬ можно передавать другому процессу, но это означает, что он будят изъят у исходного процесса. Таким образом, для каждого порта имеется только один потенциальный получатель.

Мандат с правом ПОСЛАТЬ позволяет его владельцу отсылать сообщения определенному порту. Таким правом могут обладать многие процессы. Эта ситуация является грубым аналогом банковской системы во многих странах:

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

Право ПОСЛАТЬ-ОДИН-РАЗ также позволяет отослать сообщение, но только однократно. После того, как сообщение отослано, ядро отбирает это право. Этот механизм используется для протоколов типа запрос-ответ. Например, клиент хочет, чтобы сервер выполнил какой-то его запрос, поэтому он создает порт для получения ответа. Затем он отсылает сообщение-запрос серверу, содержащее защищенный мандат для порта ответа с правом ПОСЛАТЬ-ОДИН-РАЗ. После того, как сервер отошлет ответ, мандат отзывается из его списка прав доступа, и мандат с таким именем может быть только вновь внесен в список прав в будущем.

Имена прав доступа имеют действие только внутри процесса. Два процесса могут иметь доступ к одному и тому же порту, но использовать для этого разные имена.

На рисунке 6.10 оба процесса имеют право посылать сообщения на порт Y, но для процесса А это мандат номер 3, а для процесса В - мандат 4.

Список прав доступа привязан к определенному процессу. Когда этот процесс завершается или уничтожается, его список удаляется. Порты, для которых он содержал право на операцию ПОЛУЧИТЬ, больше не могут использоваться, и они уничтожаются, даже если в них есть недоставленные сообщения.

Если различные нити процесса получают одни и те же права несколько раз, то в списке прав доступа делается только по одной записи. Для того, чтобы фиксировать данные о том, сколько раз присутствует каждое право, ядро использует счетчик ссылок для каждого порта. Когда права доступа удаляются, счетчик ссылок уменьшается. Право удаляется из списка, только когда он становится равным 0. Этот механизм важен, так как различные нити могут получать и отдавать права без уведомления друг друга.

Каждая запись в списке прав может представлять собой одно из четырех значений:

• Право для порта.

• Право для набора портов.

• Нулевая (пустая) запись.

• Код, показывающий, что порт, который был здесь записан, теперь не существует.

Первая возможность уже детально пояснена. Вторая позволяет нити читать из набора портов, даже не зная о том, что имя права относится к набору портов, а не к отдельному порту. Пустая запись отмечает неиспользуемую строку списка.

Наконец, четвертая возможность отмечает порты, которые уже не существуют, но для которых права ПОСЛАТЬ еще существуют. Например, когда порт удаляется из за того, что процесс, имеющий право ПОЛУЧИТЬ для него, завершен, ядро отслеживает все права ПОСЛАТЬ и помечает их как несуществующие. Попытка послать сообщение с нулевым и несуществующим правом приводит к ошибке с соответствующим кодом. Когда все права ПОСЛАТЬ для порта отменены, неважно по каким причинам, ядро может (опционально) отослать сообщение, уведомляющее получателя, что не осталось ни одного отправителя, и можно не ожидать сообщений.

Примитивы для управления портами Mach имеет свыше 20 вызовов для управления портами. Все они вызываются путем отправки сообщения на порт процесса. Наиболее важные из них:

• Allocate - Создать порт и включить его права в список прав • Destroy - Разрушить порт и удалить его права из списка • Deallocate - Удалить право из списка прав • Extract_right - Извлечь n-ое право другого процесса • Insert_right - Включить право в список другого процесса • Move_member - Переместить порт в набор портов • Set_qlimit - Установить максимальное количество сообщений, которые порт может хранить Первый вызов, Allocate, создает новый порт и вводит его право в список прав процесса, выполнившего этот вызов. Это право является правом ПОЛУЧИТЬ из этого порта. Имя права возвращается, так что порт можно использовать.

Следующие два вызова отменяют действие первого. Destroy удаляет право. Если это право ПОЛУЧИТЬ, то порт разрушается и все остальные права для него во всех процессах помечаются как недействительные. Deallocate уменьшает счетчик ссылок, связанный с правом. Если он равен нулю, то право удаляется, но порт остается существовать. Вызов Deallocate может использоваться только для удаления прав ПОСЛАТЬ и ПОСЛАТЬ_ОДИН_РАЗ или недействительных прав.

Вызов Extract_right позволяет нити выбрать право из списка прав другого процесса и вставить это право в свой собственный список. Конечно, вызывающая нить должна иметь доступ к порту процесса, управляющего другим процессом (например, своим потомком). Insert_right работает иначе. Он позволяет процессу взять одно из своих прав и добавить его в список прав другого процесса (например, своего потомка).

Вызов Move_member используется для управления набором портов. Он может добавить порт к набору портов или удалить порт. Наконец, вызов Set_qlimit определяет максимальное количество сообщений, которые порт может хранить.

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

Отправка и получение сообщений Конечной целью создания портов является возможность отправки в них сообщений. В этом разделе поясняется, как сообщения отправляются, как получаются и что они содержат. Mach поддерживает один системный вызов для отправки и получения сообщений. Этот вызов содержится внутри библиотечной процедуры, называемой mach_mes. Она имеет семь параметров и большое количество опций. Чтобы дать представление о ее сложности, нужно отметить, что существует 35 различных кодов возврата ошибочных ситуаций. Ниже дается упрощенный обзор некоторых возможностей этой процедуры. К счастью, она используется в функциях, генерируемых чаще компилятором заглушек (stub compiler), а не вручную.

Итак, вызов mach_mes используется и для отправки и для получения сообщений.

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

Типичный вызов функции mach_mes выглядит так:

mach_mes( &hdr, options, send_size, rcv_size, rcv_port, timeout, notify_port);

Первый параметр, hdr, является указателем на сообщение, которое нужно отослать или на место, куда нужно поместить приходящее сообщение, или на то и другое. Сообщение начинается с фиксированного заголовка, непосредственно за которым следует тело сообщения. Эта структура показана на рисунке 6.11.

Детали формата сообщения будут рассмотрены ниже, а сейчас необходимо отметить, что заголовок содержит имя права доступа для порта назначения. Эта информация нужна ядру, так как ядро из нее узнает о том, куда нужно отправить сообщение. Когда выполняется операция только ПОЛУЧИТЬ, заголовок не заполняется, так как он будет полностью переписан пришедшим сообщением.

Второй параметр, options, содержит бит, определяющий, что сообщение должно быть отправлено, и другой бит, который говорит о том, что оно должно быть получено. Если оба бита включены, то выполняется RPC. Еще один бит разрешает тайм-аут, величина которого указана в параметре timeout в миллисекундах. Если требуемая операция не может быть выполнена за время тайм-аута, то вызов возвращает код ошибки. Если часть ПОСЛАТЬ вызова RPC не выполняется за отведенное время (например, порт назначения заполнен в течение слишком большого времени), то часть ПОЛУЧИТЬ просто не выполняется.

Остальные биты поля options позволяет операции ПОСЛАТЬ, которая не может завершиться немедленно, вернуть управление, а сообщение о статусе завершения посылается на notify_port позже.

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

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

Поле Размер сообщения указывает общую длину заголовка и тела сообщения. Эта информация нужна как передающей, так и принимающей сторонам.

Далее идут имена двух мандатов доступа (то есть индексы в списке прав доступа передающей стороны). Первый относится к порту назначения, а второй - к порту ответа.

Последние два поля заголовка ядром не используются. Их могут использовать более высокие по иерархии слои программного обеспечения. По соглашению они используются для указания типа сообщения и кода функции или операции (например, для сервера нужно пояснить, это запрос на чтение или на запись). Это назначение может измениться в будущем.

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

Следует упомянуть о некоторых вопросах, связанных с приемом сообщений. Во первых, что делать, если поступившее сообщение имеет длину больше, чем длина буфера? Предусмотрено два варианта: удалить это сообщение или же вернуть вместе с кодом ошибки данный размер, чтобы позволить вызвавшей функцию mach_mes нити повторить передачу с буфером большего размера.

Если существует несколько нитей, блокированных на операции ПОЛУЧИТЬ из одного и того же порта, и сообщение поступает в порт, то системой выбирается одна из них для получения сообщения. Остальные остаются блокированными.

Форматы сообщений Как уже было сказано, тело сообщения может быть простым или сложным, в зависимости от значения управляющего бита заголовка. Структура сложного сообщения показана на рисунке 6.11. Тело сложного сообщения состоит из последовательности пар (дескриптор, поле данных). Каждый дескриптор несет информацию о том, что находится в поле данных, следующим непосредственно за дескриптором. Дескриптор может иметь два формата, различающихся только количеством бит в каждом его поле. Дескриптор определяет тип последующих данных, их длину, и количество однотипных данных (поле может содержать некоторое число данных одного типа). Возможны такие типы данны, как последовательность бит и байт, целое число различной длины, неструктурированное машинное слово, булевское значение, число с плавающей запятой, строка и мандат (право доступа). Имея такую информацию, система может попытаться выполнить преобразование данных между машинами, если они имеют различные внутренние представления данных. Это преобразование выполняется не ядром, а сервером сетевых сообщений (описан ниже).

Преобразование данных выполняется и для простых сообщений (также этим сервером).

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

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

Кроме того, некоторые значения характеристики дескриптора Тип поля данных указывают ядру на то, что нужно модифицировать право при копировании или передаче. Например, право ПОЛУЧИТЬ может трансформироваться в право ПОСЛАТЬ или ПОСЛАТЬ-ОДИН-РАЗ, так что получатель сможет посылать ответ через порт, к которому у отправителя есть только право ПОЛУЧИТЬ.

Действительно, нормальным способом установления взаимодействия между двумя процессами является создание одним из них порта, а затем отправка мандата ПОЛУЧИТЬ для этого порта другому процессу, превращая его в мандат ПОСЛАТЬ по дороге.

Например, процесса, А и В, имеющие мандат 3 и 1 соответственно. Все права являются правом только ПОЛУЧИТЬ. Нумерация начинается с 1, так как значение 0 обозначает нуль-порт. Одна из нитей процесса А отправляет сообщение процессу В, и в этом сообщении содержится мандат 3.

Когда сообщение прибывает, ядро проверяет заголовок и видит, что это сложное сообщение. Затем ядро начинает обрабатывать дескрипторы в теле сообщения, один за другим. В этом примере сообщение содержит только один дескриптор, описывающий мандат и инструкции ядру, что его нужно превратить в мандат ПОСЛАТЬ (или, может быть ПОСЛАТЬ-ОДИН-РАЗ). Ядро выделяет одну свободную запись в списке права доступа получателя, например, запись номер 2 в данном случае, и модифицирует сообщение таким образом. что слово, следующее за дескриптором, теперь содержит значение 2, а не 3. Когда приемник получает сообщение, то он видит, что оно содержит новое право, с именем (индексом) 2.

Он может использовать его немедленно, для отправки ответа.

Имеется еще один интересный тип данных, которые может передавать сообщение:

внешние данные (out-of-line). Эти данные не содержатся непосредственно в сообщении, а описаны как область виртуального адресного пространства отправителя. Тем самым в Mach обеспечивается возможность передачи в пределах машины большого количества данных без их физического копирования. Слово, следующее за дескриптором внешних данных, содержит адрес, а размер и количество полей дает 20-битный счетчик байтов. Все вместе это и определяет область виртуального адресного пространства. Для больших областей используется увеличенная форма дескриптора.

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

Хотя этот метод очень эффективен при копировании данных между процессами в пределах одной машины, он непригоден для использования в сети, так как страницы придется копировать, даже если они имеют режим только-для-чтения.

То есть возможность логического копирования без физического теряется. Метод копирование-при-записи требует, чтобы сообщение было выровнено по границе страницы и составляло целое число страниц. Частично использованные страницы также позволяют получателю видеть данные, которые ему не следует видеть.

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

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

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

Сервер сетевых сообщений имеет право ПОЛУЧИТЬ для этого порта. Нить сервера всегда прослушивает этот порт (и другие удаленные порты, которые вместе образуют набор портов). Этот порт показан как небольшой квадрат внутри ядра машины А.

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

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

Ответственность за разбивку сообщения на пакеты и инкапсуляцию их в формат соответствующего протокола несет транспортный модуль.

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

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

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

Эмуляция BSD UNIX в Mach В ядре Mach имеется различные серверы, которые работают над ним. Наверно, наиболее важным сервером является программа, которая содержит большое количество кодов BSD UNIX (например, весь код файловой системы). Этот сервер представляет собой основной эмулятор UNIX. Такая конструкция - отражение реальной истории Mach как модифицированной версии BSD UNIX.

Реализация механизма эмуляции UNIX в среде Mach состоит из двух частей, сервера UNIX и библиотеки эмуляции системных вызовов. Когда система стартует, сервер UNIX инструктирует ядро, чтобы оно перехватывало все прерывания системных вызовов и отображало вектора этих прерываний на адреса внутри библиотеки эмуляции процесса UNIX'а, по которым расположены обрабатывающие данные вызовы функции. Любой системный вызов, который делается UNIX процессом, приводит к кратковременной передаче управления ядру, а затем к немедленной передаче управления библиотеке эмуляции. Значения машинных регистров в момент передачи управления библиотеке становятся теми же, что и в момент прерывания. Такой метод иногда называют методом батута.

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

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

Сервер UNIX реализован в виде набора С-нитей. Хотя некоторые нити управляют таймерами, работают с сетью и другими устройствами ввода-вывода, большинство нитей обрабатывают системные вызовы BSD. Библиотека эмуляции взаимодействует с этими нитями с использованием обычного механизма межпроцессного взаимодействия Mach.

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

Существует один набор системных вызовов, выполняющихся по другому - это вызовы операций ввода-вывода с файлами. Они могли бы выполняться и по описанной схеме, но из-за соображений производительности был реализован другой подход. Когда файл открывается, то он отображается непосредственно в адресное пространство вызывающего процесса, так что библиотека эмуляции получает к нему доступ непосредственно, без необходимости делать вызов RPC сервера UNIX. Например, чтобы выполнить системный вызов READ, библиотека эмуляции определяет место расположения байтов в отображенном файле, которые нужно прочитать, определяет место расположения буфера и просто копирует байты в буфер с максимально возможной скоростью.

Во время цикла копирования может случиться страничный отказ, если некоторые страницы файла не находятся в памяти. Каждый отказ приводит к тому, что Mach посылает сообщение внешнему менеджеру памяти, управляющему отображением файла. Этот менеджер памяти представляет собой нить внутри UNIX-сервера, называемую пейджером i-узла (i-node pager). Менеджер читает с диска нужную страницу файла и отображает ее в адресное пространство прикладной программы.

Он также синхронизирует операции над файлами, которые открыты несколькими UNIX-процессами одновременно.

Хотя описанный метод выполнения программ UNIX и кажется запутанным, многочисленные измерения показали, что он работает лучше, чем традиционные монолитные реализации ядра. В дальнейшем работы над Mach будут фокусироваться на разделении сервера UNIX на несколько серверов с более специфическими функциями.

3. Windows NT Структура Windows NT.




© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.