Перейти к содержимому

Обращение прикладной программы к ядру операционной системы для выполнения какой либо операции

  • автор:

Операционные системы(теория)

Многозадачность(multitasking) — свойство операционной системы или среды выполнения обеспечивать возможность параллельной (или псевдопараллельной)) обработки нескольких задач. Истинная многозадачность операционной системы возможна только в распределённых вычислительных системах.

Есть несколько разных понятий, связанных с областью параллельных вычислений.

Конкурентность (concurrency)

Конкурентность (concurrency) — это наиболее общий термин, который говорит, что одновременно выполняется более одной задачи. Например, вы можете одновременно смотреть телевизор и комментить фоточки в фейсбуке. К сожалению, вменяемого русскоязычного термина я не знаю. Википедия говорит, что concurrent computing — это параллельные вычисления, но как тогда будет parallel computing по русски?

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

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

Параллельное исполнение

Параллельное исполнение (parallel computing) подразумевает наличие более одного вычислительного устройства (например, процессора), которые будут одновременно выполнять несколько задач.

Параллельное исполнение — это строгое подмножество конкурентного исполнения. Это значит, что на компьютере с одним процессором параллельное программирование — невозможно;)

Многопоточность

Многопоточность — это один из способов реализации конкурентного исполнения путем выделения абстракции "рабочего потока" (worker thread).

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

Асинхронное исполнение

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

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

CPU-bound и IO-Bound операции

Еще один важный момент, с точки зрения разработчика — разница между CPU-bound и IO-bound операциями. CPU-Bound операции нагружают вычислительные мощности текущего устройства, а IO-Bound позволяют выполнить задачу вне текущей железки.

Разница важна тем, что число одновременных операций зависит от того, к какой категории они относятся. Вполне нормально запустить параллельно сотни IO-Bound операций, и надеяться, что хватит ресурсов обработать все результаты. Запускать же параллельно слишком большое число CPU-bound операций (больше, чем число вычислительных устройств) бессмысленно.

Процессы и потоки

Существует 2 типа многозадачности:

  • Процессная многозадачность (основанная на процессах — одновременно выполняющихся программах). Здесь программа — наименьший элемент управляемого кода, которым может управлять планировщик операционной системы. Более известна большинству пользователей (работа в текстовом редакторе и прослушивание музыки).
  • Поточная многозадачность (основанная на потоках). Наименьший элемент управляемого кода — поток (одна программа может выполнять 2 и более задачи одновременно).

Процесс — экземпляр программы во время выполнения, независимый объект, которому выделены системные ресурсы (например, процессорное время и память). Каждый процесс выполняется в отдельном адресном пространстве: один процесс не может получить доступ к переменным и структурам данных другого. Если процесс хочет получить доступ к чужим ресурсам, необходимо использовать межпроцессное взаимодействие. Это могут быть конвейеры, файлы, каналы связи между компьютерами и многое другое.

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

В Linux (в ядре) понятие «threads» отсутствует. С точки зрения ядра все потоки — это полноценные, отдельные, процессы (просто с общим адресным пространством)

Поток — определенный способ выполнения процесса. Когда один поток изменяет ресурс процесса, это изменение сразу же становится видно другим потокам этого процесса. Программный поток (thread): в русскоязычной литературе часто употребляют термин «нить» (в программистском жаргоне — «нитка»).

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

Если родительский процесс по какой-то причине завершится раньше дочернего, последний становится сиротой (orphaned process). "Сироты" автоматически "усыновляются" программой init, выполняющейся в процессе с номером 1, которая и принимает сигнал об их завершении.

Если же потомок уже завершил работу, а предок не готов принять от системы сигнал об этом событии, то потомок не исчезает полностью, а превращается в зомби (zombie); в поле Stat такие процессы помечаются буквой Z. Зомби не занимает процессорного времени, но строка в таблице процессов остается, и соответствующие структуры ядра не освобождаются. После завершения родительского процесса "осиротевший" зомби на короткое время также становится потомком init, после чего уже "окончательно умирает".

Асинхронность

  • Асинхронный буквально означает “не синхронный”. Например, отправка email асинхронная, потому что отправитель не ожидает получить ответ сразу же. В программировании “асинхронным” называют код, в котором компоненты посылают друг другу сообщения, не ожидая немедленного ответа.
  • Неблокирующий — термин, чаще всего касающийся ввода-вывода. Он означает, что при вызове “неблокирующего” системного API управление сразу же будет возвращено программе, и она продолжит использовать свой квант процессорного времени. Обычные, простые в использовании системные вызовы блокирующие: они усыпляют вызывающий поток до тех пор, пока данные для ответа не будут готовы.
  • Событийный означает, что компонент программы обрабатывает очередь событий с помощью цикла, а тем временем кто-либо добавляет события в очередь, формируя входные данные компонента, и забирает у него выходные данные.

Синхронные операции — операции, при которых мы получаем результат в результате блокирования потока выполнения. Для простых вычислительных операций (сложение/умножение чисел) — это единственный вариант их совершения, для операций ввода/вывода — один из, при этом мы говорим, к примеру, «попытайся прочитать из файла что-нибудь за 100мс», и если для чтения ничего нет — поток выполнения будет заблокирован на эти 100мс.

В некоторых случаях это допустимо (например, если мы делаем простое консольное приложение, либо какую-либо утилиту, цель которой — отработать и всё), но в некоторых — нет. К примеру, если мы так застрянем в потоке, в котором обрабатывается UI — наше приложение зависнет. За примерами далеко ходить не нужно — если javascript на сайте сделает while(true); , то перестанут вызываться какие-либо другие обработчики событий страницы и её придётся закрыть. Те же дела, если начать что-нибудь вычислять под Android’ом в обработчиках UI-событий (код которых вызывается в UI-потоке), это приведёт к появлению окна «приложение не отвечает, закрыть?» (подобные окна вызываются по watchdog-таймеру, который сбрасывается, когда выполнение возвращается обратно к системе UI).

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

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

  • неблокирующий режим ввода-вывода
  • мультиплексирование с помощью системного API, такого как select либо epoll

Event loop

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

Race condition

Состояние гонки (race condition), также конкуренция — ошибка проектирования многопоточной системы или приложения, при которой работа системы или приложения зависит от того, в каком порядке выполняются части кода. Своё название ошибка получила от похожей ошибки проектирования электронных схем (см. Гонки сигналов).

Термин состояние гонки относится к инженерному жаргону и появился вследствие неаккуратного дословного перевода английского эквивалента. В более строгой академической среде принято использовать термин неопределённость параллелизма.

Состояние гонки — «плавающая» ошибка (гейзенбаг), проявляющаяся в случайные моменты времени и «пропадающая» при попытке её локализовать.

Вытесняющая и кооперативная многозадачность

Совместная или кооперативная многозадачность

Тип многозадачности, при котором следующая задача выполняется только после того, как текущая задача явно объявит себя готовой отдать процессорное время другим задачам. Как частный случай такое объявление подразумевается при попытке захвата уже занятого объекта мьютекс (ядро Linux), а также при ожидании поступления следующего сообщения от подсистемы пользовательского интерфейса (Windows версий до 3.x включительно, а также 16-битные приложения в Windows 9x).

Кооперативную многозадачность можно назвать многозадачностью «второй ступени», поскольку она использует более передовые методы, чем простое переключение задач, реализованное многими известными программами (например, DOS Shell из MS-DOS 5.0). При простом переключении активная программа получает все процессорное время, а фоновые приложения полностью замораживаются. При кооперативной многозадачности приложение может захватить фактически столько процессорного времени, сколько оно считает нужным. Все приложения делят процессорное время, периодически передавая управление следующей задаче.

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

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

Вытесняющая, или приоритетная, многозадачность (режим реального времени)

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

  • возможность полной реализации многозадачного ввода-вывода в ядре ОС, когда ожидание завершения ввода-вывода одной программой позволяет процессору тем временем исполнять другую программу;
  • cильное повышение надежности системы в целом, в сочетании с использованием защиты памяти — идеал в виде «ни одна программа пользовательского режима не может нарушить работу ОС в целом» становится достижимым хотя бы теоретически, вне вытесняющей многозадачности он не достижим даже в теории.
  • возможность полного использования многопроцессорных и многоядерных систем.
  • необходимость особой дисциплины при написании кода, особые требования к его реентерабельности, к защите всех разделяемых и глобальных данных объектами типа критических секций и мьютексов.

Системный вызов

Системный вызов(system call) — обращение прикладной программы к ядру операционной системы для выполнения какой-либо операции.

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

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

PhantomEx: журнал разработки

Необходимость в реализации внутри системы доступа к операциям ввода/вывода для пользовательских приложений, и одновременная невозможность выполнения привилегированных команд из пользовательского режима поднимает вопрос — а как же производится, например файловый ввод/вывод в пользовательских программах больших ОС? Для этого применяются так называемые системные вызовы.

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

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

1.Программное прерывание, как способ выхода в Ring 0

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

Выберем для системных вызовов номер прерывания из свободных номеров в пределах от 0x20 до 0xFF. Скажем, пусть это будет 0x50. Для этого прерывания в модуле interrupts.s создадим специальный обработчик

Листинг 111. Обработчик прерывания INT 50h (interrupts.s)

push $0 /* Помещаем в стек фиктивный код ошибки */
push $80 /* и номер прерывания (для обработчика на C) */

/* Проталкиваем в стек все РОН */
pusha

/* Сохраняем текущий селектор сегмента данных */
push %ds

/* Настраиваемся на сегмент данных ядра */
mov $0x10, %ax
mov %ax, %ds

/* Вызываем обработчик на C */
call isr_handler

/* Восстанавливаем селектор сегмента данных */
pop %ds

/* Выполняем действия, аналогичные команде popa */
/* за исключением восстановления регистра EAX */
/* для сохранения значения, возвращенного системным вызовом */
pop %edi
pop %esi
pop %ebp
add $4, %esp
pop %ebx
pop %edx
pop %ecx

add $12, %esp /* Очищаем стек */

Создаем прототип функции isr80() в модуле работы с таблицами дескриптором, и регистрируем в IDT обработчик прерывания, создав для него дескриптор шлюза ловушки

Листинг 112. Прототип обработчика прерывания INT 50h (descriptor_tables.h)

Листинг 113. Регистрируем шлюз ловушки в IDT (descriptor_tables.c)

memset(&idt_entries, 0, sizeof(idt_entry_t)*256);

/* Перепрограммируем контролер прерываний */
outb(0x20, 0x11);
outb(0xA0, 0x11);
outb(0x21, 0x20);
outb(0xA1, 0x28);
outb(0x21, 0x04);
outb(0xA1, 0x02);
outb(0x21, 0x01);
outb(0xA1, 0x01);
outb(0x21, 0x0);
outb(0xA1, 0x0);

/* Устанавливаем обработчики на прерывания */
idt_set_gate(0, (u32int)isr0, 0x08, 0x8E);
.
.
.
idt_set_gate(7, (u32int)isr7, 0x08, 0x8E);

idt_set_gate(8, (u32int)isr8, 0x08, 0x8E);
.
.

.
idt_set_gate(15, (u32int)isr15, 0x08, 0x8E);

idt_set_gate(16, (u32int)isr16, 0x08, 0x8E);
.
.
.
idt_set_gate(31, (u32int)isr31, 0x08, 0x8E);

idt_set_gate(32, (u32int)irq0, 0x08, 0x8E);
.
.
.
idt_set_gate(47, (u32int)irq15, 0x08, 0x8E);

/* Шлюз ловушки для прерывания INT 50h */
idt_set_gate(0x50, (u32int)isr80, 0x08, 0xEF);

добавленный код выделен полужирным шрифтом. Для того чтобы прерывание вызывалось из 3-го кольца защиты, дескриптор должен иметь DPL = 3, тип шлюза ловушки имеет значение 0xF, таким образом мы получаем значение байта доступа дескриптора 0xEF — шлюз ловушки с DPL = 3 (подробнее о формате дескриптора IDT написано вот тут). Селектор сегмента кода, в котором выполняется обработчик этого прерывания — 0x8 — это селектор кода ядра, то есть данный шлюз обеспечит нам переход из CPL = 3 в CPL = 0, при вызове обработчика прерывания INT 50h.

2. Организация системного вызова

За основу возьмем механизм реализации системных вызовов в ядре Linux. Там для обращения к ядру используется прерывание INT 80h, передача параметров происходит через регистры общего назначения: EAX — номер функции в таблице системных вызовов, EBX — 1-й параметр, ECX — 2-й параметр, EDX — 3-й параметр и так далее. Возвращаемое из системного вызова значение передается через регистр EAX.

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

Всё хозяйство, связанное с системными вызовами соберем в отдельном модуле. Для примера реализуем два системных вызова, выполняющих синхронизируемый ядром ОС доступ к портам ввода-вывода.

Листинг 114. Модуль организации системных вызовов (syscalls.h)

#include «common.h»
#include «isr.h»
#include «text_framebuffer.h»
#include «io_disp.h» /* Диспетчер ввода-вывода */

#define NUM_CALLS 2 /* Число системных функции в таблице */

extern u32int syscall_entry_call(void* entry_point); / * Передача управления
системной функции */

void syscall_handler(registers_t regs); /* Обработчик прерывания */

#include «common.h»
#include «sync.h»

#define PORTS_NUM 0x10000 /* Число портов ввода-вывода */

/* Инициализация диспетчера */
void init_io_dispatcher(void);

/* Синхронизированное чтение из порта */
u8int in_byte(u16int port);

/* Синхронизированная запись в порт */
void out_byte(u16int port, u8int value);

/* Выделяем память под массив мьютексов портов и освобождаем их все */
port_mutex = (mutex_t*) kmalloc(sizeof(mutex_t)*PORTS_NUM);

for (i = 0; i < PORTS_NUM; i++)
<
mutex_release(&port_mutex[i]);
>
>

/*——————————————————————
* Синхронизированное чтение байта из порта
*—————————————————————-*/
u8int in_byte(u16int port)
<
u8int value = 0;
/* Захватываем мьютекс данного порта */
mutex_get(&port_mutex[port], true);
/* Читаем этот порт */
value = inb(port);
/* Отдаем мьютекс */
mutex_release(&port_mutex[port]);
/* Возвращаем прочитанное значение */
return value;
>

/*——————————————————————
* Синхронизированная запись в порт
*—————————————————————-*/
void out_byte(u16int port, u8int value)
<
/* Захватываем мьютекс порта */
mutex_get(&port_mutex[port], true);
/* Выводим значение в порт */
outb(port, value);
/* Освобождаем мьютекс */
mutex_release(&port_mutex[port]);
>

void init_syscalls(void)
<
/* Регистрируем обработчик прерывания */
register_interrupt_handler(0x50, &syscall_handler);
>

syscall_entry_call:

push %edx /* Проталкиваем в стек параметры */
push %ecx /* в обратном порядке (конвенция C) */
push %ebx

mov 16(%esp), %edx /* Сохраняем точку входа в EDX */

call *%edx /* Вызываем системную функцию */

add $12, %esp /* Освобождаем стек после вызова */

mov $0, %eax /* Номер функции записываем в EAX */
mov $0x60, %ebx /* Номер порта — в EBX */

int $0x50 /* Выполняем программное прерывание INT 50h */

После этого прочтенный байт можно было бы взять из регистра EAX. Однако на C нам бы хотелось иметь нормальный прототип для данного системного вызова, поэтому добавим в файл syscalls.h некоторые макроопределения для прототипов и реализации системных вызовов

Листинг 118. Макроопределения для системных вызовов (syscalls.h)

#define DEFN_SYSCALL1(func, num, P1)\
\
int syscall_##func(P1 p1)\
< int ret = 0;\
asm volatile («int $0x50»:»=a»(ret):»a»(num),»b»(p1));\
return ret;\
>

/*—- Два параметра ———————————————*/
#define DECL_SYSCALL2(func, p1, p2) int syscall_##func(p1, p2)

#define DEFN_SYSCALL2(func, num, P1, P2)\
\
int syscall_##func(P1 p1, P2 p2)\
< int ret = 0;\
asm volatile («int $0x50»:»=a»(ret):»a»(num),»b»(p1),»c»(p2));\
return ret;\
>

/*—- Три параметра ———————————————*/
#define DECL_SYSCALL3(func, p1, p2, p3) int syscall_##func(p1, p2, p3)

#define DEFN_SYSCALL3(func, num, P1, P2, P3)\
\
int syscall_##func(P1 p1, P2 p2, P3 p3)\
< int ret = 0;\
asm volatile («int $0x50»:»=a»(ret):»a»(num),»b»(p1),»c»(p2), «d»(p3));\
return ret;\
>

vs04 = (vscreen_t*) get_vscreen();

while (1)
<
vs04->cur_x = 0;
vs04->cur_y = start_y + 2;

vprint_text(vs04, «I’m user thread #4: «);

/* Читаем скан-код последней нажатой клавиши */
u8int keyb = (u8int) syscall_in_byte(0x60);

vprint_text(vs04, «Last key scan code: «);

init_esp = initial_esp;
.
.
.
/* Инициализируем дистпетчер памяти */
init_memory_manager(init_esp);

init_timer(BASE_FREQ);
asm volatile («sti»);

/* Инициализируем планировщик */
init_task_manager();
/* Инициализируем системные вызовы */
init_syscalls();

process_t* proc = get_current_proc();

thread01 = thread_create(proc,
&task01,
0x4000,
true,
false);

thread02 = thread_create(proc,
&task02,
0x4000,
true,
false);

/* Инициализируем диспетчер ввода-вывода */
init_io_dispatcher();

2. Системные вызовы. (Лекция 1)

Системный вызов (system call) – обращение прикладной программы к ядру ОС для выполнения какой-либо операции (обеспечивает доступ со стороны приложений к возможностям ОС).

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

Однако в UNIX и Windows модель вызовов отличается.

UNIX напрямую вызывает системную функцию (1,2). Вызов упаковывается, управление передается системе (3, 4). Ядро определяет параметры вызова и делает внутренний вызов (5). Результат возвращается (6, 7).

В Windows приложение не может вызвать функции системы (native API). Вызов (1,2) поступает подсистеме окружения (3). Если необходимо вызвать функцию ядра, модуль Ntdll.dll определяет порядок передачи управления ядру (4). Ядро делает внутренний вызов и возвращает результат.

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

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

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

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

3. Аппаратные особенности выполнения программ. (Лекция 1)

Центральный процессор – главная часть аппаратного обеспечения компьютера.

PC (Program counter) – счетчик команд

PSW (Processor Status Word) – слово состояния процессора (регистр или набор регистров)

SP (Stack Pointer) – указатель стека

Типы команд ЦПУ:

— Обработка данных и переходы

— Процессор ↔ устройство ввода-вывода

Кэширование ОЗУ (caching) – использование ОЗУ малой емкости с малым временем доступа для ускорения работы с основным ОЗУ, имеющим большое время доступа.

Проблемы использования ОЗУ:

— переключение контекста процессов (заполнение кэша, регистры управления памятью)

Распределение памяти – управление физической памятью и виртуальной памятью процессов.

Устройства ввода/вывода (Input/Output devices) обычно состоят из контроллера и самого устройства (группы устройств).

Контроллер (controller) непосредственно реализует сложные алгоритмы управления устройствами, предоставляя аппаратный интерфейс для ЦПУ и других контроллеров.

Драйвер (driver) – специал-ая программа, управляющая устройствами с помощью контроллера и скрывающая специфику устр-ва.

Методы работы с устройствами ввода/вывода:

— программируемый ввод/вывод (активное ожидание, ожидание готовности);

— использование прерываний (interrupts);

— прямой доступ к памяти (DMA – Direct Memory Access).

Системный вызов это кратко

Систе́мный вы́зов (англ. system call ) в программировании и вычислительной технике — обращение прикладной программы к ядру операционной системы для выполнения какой-либо операции.

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

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

Ссылки

Wikimedia Foundation . 2010 .

Полезное

Смотреть что такое «Системный вызов» в других словарях:

МИРО-СИСТЕМНЫЙ АНАЛИЗ — текст И. Валлерстайна , опубликованный в 1987. Согласно Валлерстайну, миро системный анализ это не теория о социальном мире или его части. Это протест против способов, которыми было структурировано социальное научное исследование при его… … Социология: Энциклопедия

санкционированный вызов — Вызов системы, программы или данных, разрешенный данному пользователю. Как правило, реализуется путем ввода и проверки пароля. [Домарев В.В. Безопасность информационных технологий. Системный подход.] Тематики защита информации EN authorized call … Справочник технического переводчика

Интерфейс системный — Интерфейс (от англ. interface поверхность раздела, перегородка) совокупность средств и методов взаимодействия между элементами системы. В зависимости от контекста, понятие применимо как к отдельному элементу (интерфейс элемента), так и к… … Википедия

GNU Assembler — (GAS) Тип ассемблер Разработчик Фонд свободного ПО Написана на C Операционная система кроссплатформенное ПО Аппаратная платформа кроссплатформенное ПО Последняя версия 2.20.1 (3 ма … Википедия

Библиотека потоков POSIX — (англ. Native POSIX Thread Library, англ. NPTL) набор программного кода, позволяющего ядру операционной системы Linux достаточно эффективно выполнять программы, использующие потоки POSIX. В настоящее время интегрирована в библиотеку… … Википедия

SIGSYS — Описание: Неправильный аргумент системного вызова По умолчанию: завершение процесса коды SA SIGINFO (не имеет специфических кодов) В POSIX системах, SIGSYS сигнал, предназначенный для посылки программе, при попытке передать… … Википедия

Fork — У этого термина существуют и другие значения, см. Форк (значения). В Unix системах, fork() системный вызов, создающий новый процесс( потомок), который является почти точной копией процесса( родителя), выполняющего этот вызов. Между… … Википедия

fork — У этого термина существуют и другие значения, см. Форк (значения). В Unix системах, fork() системный вызов, создающий новый процесс (потомок), который является практически полной копией процесса родителя, выполняющего этот вызов. Между… … Википедия

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

Что такое системный вызов в операционной системе?

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

Системный вызов предлагает услуги операционной системы пользовательским программам через API (интерфейс прикладного программирования). Системные вызовы являются единственными точками входа в систему ядра.

Из этого руководства по операционной системе вы узнаете:

Пример системного вызова

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

В интерактивной системе этот тип выполнения программы требует некоторых системных вызовов ОС.

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

Как работает системный вызов?

Вот шаги для системного вызова:

Как вы можете видеть на приведенной выше диаграмме.

Шаг 1) Процессы, выполняемые в пользовательском режиме до тех пор, пока системный вызов не прервет его.

Шаг 2) После этого системный вызов выполняется в режиме ядра в приоритетном порядке.

Шаг 3) По завершении выполнения системного вызова управление возвращается в режим пользователя.,

Зачем вам системные вызовы в ОС?

Ниже приведены ситуации, которые требуют системных вызовов в ОС:

  • Чтение и запись из файлов требуют системных вызовов.
  • Если файловая система хочет создать или удалить файлы, требуются системные вызовы.
  • Системные вызовы используются для создания и управления новыми процессами.
  • Сетевые подключения требуют системных вызовов для отправки и получения пакетов.
  • Доступ к аппаратным устройствам, таким как сканер, принтер, требуется системный вызов.

Типы системных вызовов

Вот пять типов системных вызовов, используемых в ОС:

  • Контроль процесса
  • Управление файлами
  • Управление устройством
  • Информационное обслуживание
  • связи

Контроль процесса

Эти системные вызовы выполняют задачу создания процесса, завершения процесса и т. Д.

  • Конец и Прервать
  • Загрузить и выполнить
  • Создать процесс и завершить процесс
  • Ожидание и подписанное событие
  • Выделить и освободить память

Управление файлами

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

  • Создать файл
  • Удалить файл
  • Открыть и закрыть файл
  • Читать, писать и перемещать
  • Получить и установить атрибуты файла

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

Управление устройствами выполняет работу с устройствами, такими как чтение из буферов устройств, запись в буферы устройств и т. Д.

  • Запрос и релиз устройства
  • Логически подключать / отключать устройства
  • Получить и установить атрибуты устройства

Информационное обслуживание

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

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

Связь:

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

Правила передачи параметров для системного вызова

Вот общие общие правила для передачи параметров в системный вызов:

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

Важные системные вызовы, используемые в ОС

Подождите()

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

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

вилка ()

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

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

убийство():

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

Выход():

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

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

Системные вызовы

В любой операционной системе поддерживается механизм, который позволяет пользовательским программам обращаться к услугам ядра ОС . В операционных системах наиболее известной советской вычислительной машины БЭСМ-6 соответствующие средства «общения» с ядром назывались экстракодами, в операционных системах IBM они назывались системными макрокомандами и т.д. В ОС Unix такие средства называют системными вызовами .

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

Основное отличие состоит в том, что при системном вызове задача переходит в привилегированный режим или режим ядра ( kernel mode ). Поэтому системные вызовы иногда еще называют программными прерываниями , в отличие от аппаратных прерываний , которые чаще называют просто прерываниями .

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

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

Прерывания

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

Исключительные ситуации

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

Файлы

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

Главная задача файловой системы (file system) – скрыть особенности ввода-вывода и дать программисту простую абстрактную модель файлов, независимых от устройств. Для чтения, создания, удаления, записи, открытия и закрытия файлов также имеется обширная категория системных вызовов (создание, удаление, открытие, закрытие, чтение и т.д.). Пользователям хорошо знакомы такие связанные с организацией файловой системы понятия, как каталог, текущий каталог, корневой каталог, путь. Для манипулирования этими объектами в операционной системе имеются системные вызовы . Файловая система ОС описана в лекциях 11–12.

Процессы, нити

Концепция процесса в ОС одна из наиболее фундаментальных. Процессы подробно рассмотрены в лекциях 2–7. Там же описаны нити, или легковесные процессы.

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

Реализация системных вызовов должна удовлетворять следующим требованиям:

— обеспечивать переключение в привилегированный режим;

— обладать высокой скоростью вызова процедур ОС;

— обеспечивать по возможности единообразное обращение к системным вызовам для всех аппаратных платформ, на которых работает ОС;

— допускать легкое расширение набора системных вызовов;

— обеспечивать контроль со стороны ОС за корректным использованием системных вызовов.

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

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

В большинстве ОС системные вызовы обслуживаются по централизованной схеме, основанной на существовании диспетчера системных вызовов (рис. 4.14, б). При любом системном вызове приложение выполняет программное прерывание с определенным и единственным номером вектора. Например, ОС Linux использует для системных вызовов команду INT 80h, а ОС Windows NT (при работе на платформе Pentium) — INT 2Eh. Перед выполнением программного прерывания приложение тем или иным способом передает операционной системе номер системного вызова, который является индексом в таблице адресов процедур ОС, реализующих системные вызовы (таблица sysent на рис. 4.14). Способ передачи зависит от реализации, например номер можно поместить в определенный регистр общего назначения процессора или передать через стек (в этом случае после прерывания и перехода в привилегированный режим их нужно будет скопировать в системный стек из пользовательского, это действие в некоторых процессорах автоматизировано). Также некоторым способом передаются аргументы системного вызова, они могут как помещаться в регистры общего назначения, так и передаваться через стек или массив, находящийся в оперативной памяти. Массив удобен при большом объеме данных, передаваемых в качестве аргументов, при этом в регистре общего назначения указывается адрес этого массива.

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

Рис. 4.14. Децентрализованная и централизованная схемы обработки системных вызовов

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

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

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

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

Асинхронный системный вызов не приводит к переводу процесса в режим ожидания после выполнения некоторых начальных системных действий, например запуска операции вывода-вывода, управление возвращается прикладному процессу (рис. 4.15, 6).

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

Рис. 4.15. Синхронные и асинхронные системные вызовы

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

Реализация системных вызовов должна удовлетворять следующим требованиям:

— обеспечивать переключение в привилегированный режим;

— обладать высокой скоростью вызова процедур ОС;

— обеспечивать по возможности единообразное обращение к системным вызовам для всех аппаратных платформ, на которых работает ОС;

— допускать легкое расширение набора системных вызовов;

— обеспечивать контроль со стороны ОС за корректным использованием системных вызовов.

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

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

В большинстве ОС системные вызовы обслуживаются по централизованной схеме, основанной на существовании диспетчера системных вызовов (рис. 4.14, б). При любом системном вызове приложение выполняет программное прерывание с определенным и единственным номером вектора. Например, ОС Linux использует для системных вызовов команду INT 80h, а ОС Windows NT (при работе на платформе Pentium) — INT 2Eh. Перед выполнением программного прерывания приложение тем или иным способом передает операционной системе номер системного вызова, который является индексом в таблице адресов процедур ОС, реализующих системные вызовы (таблица sysent на рис. 4.14). Способ передачи зависит от реализации, например номер можно поместить в определенный регистр общего назначения процессора или передать через стек (в этом случае после прерывания и перехода в привилегированный режим их нужно будет скопировать в системный стек из пользовательского, это действие в некоторых процессорах автоматизировано). Также некоторым способом передаются аргументы системного вызова, они могут как помещаться в регистры общего назначения, так и передаваться через стек или массив, находящийся в оперативной памяти. Массив удобен при большом объеме данных, передаваемых в качестве аргументов, при этом в регистре общего назначения указывается адрес этого массива.

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

Рис. 4.14. Децентрализованная и централизованная схемы обработки системных вызовов

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

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

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

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

Асинхронный системный вызов не приводит к переводу процесса в режим ожидания после выполнения некоторых начальных системных действий, например запуска операции вывода-вывода, управление возвращается прикладному процессу (рис. 4.15, 6).

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *