Алексей Береснев администрирование gnu/Linux с нуля санкт-Петербург «бхв-петербург» 2007

Скачать 6.43 Mb.

Название	Алексей Береснев администрирование gnu/Linux с нуля санкт-Петербург «бхв-петербург» 2007
страница	8/48
Дата публикации	28.05.2015
Размер	6.43 Mb.
Тип	Документы

100-bal.ru > Информатика > Документы

1 ... 4 5 6 7 8 9 10 11 ... 48

Глава 6. Процессы

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

Процессы и задания

GNU/Linux – многопользовательская и многозадачная операционная система. Это значит, что одновременно в системе может выполняться множество программ, запущенных различными пользователями. Для обеспечения такой работы центральный процессор компьютера последовательно переключается на обработку программного кода различных приложений, системных и прочих программ, создавая впечатление, что все они выполняются одновременно. Ядро Linux спроектировано таким образом, что имеется гарантия выполнения центральным процессором кода каждой работающей в системе программы за некоторое конечное время. Естественно, чем больше загружена система, тем большим становится этот промежуток времени. Сильно загруженная система может с точки зрения пользователя потерять интерактивность, т.е. она может настолько медленно отвечать на запросы пользователя, что он будет уверен в том, что система не работает.

Программы представляют собой исполняемые файлы двух типов:
□ скомпилированные бинарные файлы, содержащие инструкции на машинном языке;

□ интерпретируемые сценарии (например, сценарии Bash и программы Perl).
Когда от пользователя поступает команда выполнить некоторую программу, операционная система вначале определяет с помощью "магических чисел" (magic numbers см. man file), к какому из этих двух типов относится данная программа. Если она относится к первому типу, то программа пополняет очередь других работающих программ, ожидающих своей очереди постановки на исполнение процессором. В противном случае сначала запускается программа – интерпретатор, предназначенный для исполнения данного вида сценариев (например, /bin/bash), который, в свою очередь, относится к программам первого типа.

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

В GNU/Linux одновременно выполняется множество процессов, причем многие из них запускаются автоматически без вмешательства пользователей. В силу этого факта следует выделить понятие задания (task или job). Задание – это команда, запущенная на исполнение пользователем с помощью оболочки. Запуск задания может приводить к созданию более чем одного процесса. Например, запуск сервера HTTP Apache приводит к параллельному запуску сразу нескольких экземпляров программы httpd.

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

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

Процессы ядра отделены от пользовательских процессов – они работают в пространстве ядра (kernel space). Приложения работают в пользовательском пространстве (user space) за исключением времени, когда в них производятся системные вызовы.

Команда time позволяет увидеть, сколько времени исполнялась программа реачьно (от запуска до окончания), сколько времени она обслуживалась ядром и сколько она работала в пользовательском пространстве (пример 6.1).
Пример 6.1. Команда time

В примере 6.1 программа time определила реальное время работы программы updatedb, время работы на стороне пользователя и на стороне ядра.

В GNU/Linux одновременно выполняется множество процессов. Процессор выделяет каждому процессу интервалы времени (time slices), в течение которых инструкции процесса выполняются процессором. Такой режим называется разделением времени. Используемая в Linux модель управления процессами относится к классу вытесняющей многозадачности (preemptive multitaskings). В рамках этой модели каждый процесс имеет свой уровень важности в системе или приоритета. Более приоритетные процессы могут вытеснять с исполнения на процессоре менее приоритетные процессы.

Если схематично описать внутреннюю структуру процесса, то в нем обычно можно выделить следующие составляющие части:
□ заголовок процесса, содержащий, в частности, специальные сигнатуры, показывающие формат процесса (например, формат ELF или COFF);

□ инструкции (по историческим причинам их именуют text);

□ данные (data);

□ куча (heap) – область памяти, предназначенная для выделения памяти динамическим переменным и т.п.;

□ стек (stack) – структура типа LIFO (Last Input – First Output), предназначенная для вызовов подпрограмм и хранения некоторых переменных.
Процессы могут обращаться к каким-либо файлам. С каждым файлом ассоциируется целое число, называемое дескриптором файла. Когда ядро создает процесс, с ним автоматически ассоциируются три потока ввода/вывода:
□ стандартный поток ввода (stdin) – дескриптор 0;

□ стандартный поток вывода (stdout) – дескриптор 1;

□ стандартный поток ошибок (stderr) – дескриптор 2.
Процессы создаются другими процессами с помощью системного вызова fork (). Между процессами устанавливаются отношения наследства. Процесс, который породил другие процессы, называется родительским (parent). А порожденные процессы называются дочерними (child). У каждого процесса есть один и только один родитель, но процесс может иметь несколько потомков. Это позволяет выстраивать иерархическую древовидную систему процессов.

Когда процесс-родитель завершает свою работу, он может завершить работу своих дочерних процессов. Если это не происходит, то "осиротевшие" процессы наследуются процессом с номером 1 – init.

Ядро Linux поддерживает специальную таблицу процессов, содержащую информацию о процессах в системе. Таблица процессов динамически увеличивается при росте количества процессов в системе (увеличение таблицы процессов ограничено). Каждый процесс имеет следующие идентификаторы:
□ PID (Process ID) – уникальный порядковый номер процесса в системе, предназначенный для идентификации процесса;

□ PPID (Parent Process ID) – PID родительского процесса, позволяющий выстроить иерархию процессов;

□ UID (User ID) – идентификатор пользователя, от имени которого выполняется процесс;

□ GID (Group ID) – идентификатор группы пользователей, от имени которой выполняется процесс.
Процесс запускается с терминала, поэтому процесс связывается с терминалом. Но, все же, есть процессы, не связанные с терминалами. Процессы принято подразделять на три категории, перечисленные далее.
□ Процессы ядра. Они выполняются в kernel space. Примером такого процесса в Linux является процесс упорядочивания процессов в очереди (scheduling). Процессы ядра располагаются в оперативной памяти и не имеют соответствующих им программ в виде исполняемых файлов. Соответствующий им код находится в файле ядра и модулях ядра.

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

□ Все остальные процессы называются прикладными. Они, как правило, порождаются в рамках сеанса работы пользователя.
Задания
• Получите страницу помощи, касающуюся стандартных потоков ввода /вывода.

• Какая команда позволяет узнать имя файла устройства того терминала, на котором вы вошли в сеанс?

Фоновый режим выполнения заданий

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

В GNU/Linux можно запускать команды в фоновом режиме. Это позволяет пользователю выполнять несколько программ одновременно.

Только одно задание может работать в интерактивном режиме (foreground), все остальные активные задания выполняются в фоновом режиме (background).

Для запуска команды в фоновом режиме в конце командной строки необходимо поставить символ & (амперсанд). При запуске фонового задания выводится его номер (пример 6.2).
Пример 6.2. Запуск задания а фоновом режиме

В примере 6.2 команда find запущена в фоновом режиме, т. к. в конце командной строки установлен символ &. Номер задания выводится в квадратных скобках, в этом примере – 1. Число, выводящееся после квадратных скобок,– PID процесса задания.

Для мониторинга состояний фоновых заданий предназначена команда jobs, которая позволяет просмотреть статус фоновых заданий. Она отображает номер задания, имя команды и статус задания (пример 6.З).
Пример 6.3. Команда jobs

В этом примере были запущены два задания на поиск и удаление файлов с подстрокой core в именах файлов, принадлежащих пользователям basile и anna. Заданиям назначены номера 1 и 2. Команда jobs показала, что задание 1 выполнено, а задание 2 выполняется.

Обозначения %% и %+ указывают последнее запущенное фоновое задание, а % – предпоследнее задание. Аналогично, информация о заданиях, выводимых командой jobs, отображает символы + и - для индикации последнего и предпоследнего заданий.

Команда fg % номерзадания переводит задание с номером номерзадания в интерактивный режим. Так, команда fg %i переводит задание с номером i в интерактивный режим.

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

Можно указывать задания по первым символам их команд, предваряя их % (пример 6.4).
Пример 6.4. Обращение к фоновым заданиям по именам команд

В примере 6.4 выполняющееся в фоновом режиме задание было переведено в интерактивный режим командой fg % fi, которая использовала идентификацию задания не по его номеру, а по двум первым буквам в имени команды.

Для завершения фонового задания используют команду kill %номерзадания (пример 6.5).
Пример 6.5. Снятие фонового задания с выполнения

В примере 6.5 задание с номером 2 было завершено командой kill.
Задания
• Найдите пустые файлы в домашнем каталоге в фоновом режиме.

• Запустите в фоновом режиме два задания: sleep 200 и sleep 2000, выведите информацию о состоянии заданий.

• Снимите с выполнения 2-е задание, выведите информацию о заданиях.

Жизненный цикл процесса

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

Предположим, что пользователь выполнил в оболочке команду ps -f, желая получить список процессов, запущенных на данном виртуальном терминале. В таком случае ps -f является дочерним процессом оболочки. Пример 6.6 демонстрирует, что команда ps -f является дочерним процессом оболочки: PPID команды ps -f 1751 соответствует PID оболочки.
Пример 6.6. Идентификаторы дочернего процесса

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

Когда пользователь ввел в командной строке команду ps -f, эта команда была проверена оболочкой bash, не является ли она встроенной. Так как эта команда не является встроенной, для ее выполнения оболочка произвела системный вызов fork ().

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

При создании процесса ядро назначает ему уникальный PID. Так и сейчас, для копии родительской оболочки – дочернего процесса bash, в нашем случае, система назначила PID 1870, a PPID новой оболочки соответствует PID породившей ее оболочки – 1751.

Итак, в настоящий момент в системе имеются два одинаковых процесса bash. Но требовалось получить процесс команды ps -f. Поэтому в дочернем процессе bash должен быть произведен системный вызов класса exec () (см. man 3 exec), который позволяет загрузить программу /bin/is и поместить прочитанный исполняемый код в адресное пространство дочернего процесса.

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

Как же отличить родительский и дочерний процессы bash для того, чтобы определить, в каком из них надо вызвать exec (), а в каком – wait ()? Их можно различить с помощью анализа значения, возвращаемого функцией fork (). Она возвращает PID дочернего процесса. Родительский процесс bash породил дочерний процесс, и, следовательно, fork () возвратил PID дочернего процесса. В порожденном процессе fork () возвращает о.

После вызова exec () дочерний процесс уже не является процессом bash – он выполняет инструкции команды ps. Родительский процесс ждет завершения дочернего процесса.

После того как команда ps -f завершает свою работу системным вызовом exit (), ее адресное пространство освобождается. Родительский процесс bash, который с помощью системного вызова wait () ожидал завершения работы дочернего процесса, продолжит после этого свою работу.

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

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

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

• Выполните команду exec Is -R/etc. Изучите ее поведение.

Мониторинг процессов

Основным инструментом для исследования процессов является команда ps. Она выводит состояние процессов на момент ее выполнения в системе. При вызове без аргументов она выводит список процессов, связанных с текущим терминалом (пример 6.7).
Пример 6.7. Команда ps

Столбец PID (см. пример 6.7) отображает идентификаторы процессов, tty – имена терминалов, time – суммарное процессорное время, затраченное процессом с момента его старта. Столбец CMD – командная строка, соответствующая данному процессу.

Подробную информацию можно получить с помощью опции -f (full format) – пример 6.8.
Пример 6.8. Подробный формат вывода командыps

Как видно из примера 6.8, в вывод добавляются дополнительные столбцы с информацией о UID владельца процесса, родителе процесса (PPID), столбец STIME показывает время запуска процесса, столбец с – уровень загрузки процессора в целочисленном выражении.

Еще более подробную информацию предоставляет опция -l (long format) – пример 6.9.
Пример 6.9. Длинный формат вывода команды ps

Столбец f показывает флаги процесса (см. man ps).
Столбец s – статус процесса, который может быть:

□ D – процесс приостановлен и не может быть прерван (например, ожидает окончания ввода/вывода);

□ R – процесс выполняется или находится в очереди;

□ S – процесс приостановлен;

□ T – процесс трассируется;

□ Z – процесс помечен, как defunct (zombie).
Столбец NI показывает величину nice number. Эта величина устанавливается пользователем и участвует в вычислении приоритета процесса планировщиком. Столбец SZ – количество памяти, занимаемое процессом, a WCHAN – это информация о системном вызове, произведенном процессом.

Исключительно полезна опция -e, позволяющая вывести список всех процессов в системе (аналог – опция -A). Чаще всего для получения списка всех процессов используют команду ps -ef, дающую подробную информацию о процессах.

Бывает необходимо вывести список каких-либо конкретных процессов, выбранных по заданному критерию. Далее приведены некоторые опции фильтрации ps:
□ -u – фильтрация по UID;

□ -t – фильтрация по терминалу;

□ -р – фильтрация по PID искомого процесса;

□ -c – фильтрация по командной строке.
Требуется, например, вывести список процессов, запущенных на втором виртуальном терминале (пример 6.10).
Пример 6.10. Фильтрация процессов по заданному терминалу

Вывести список процессов с заданной командной строкой можно, указав еле опции -с команды ps имя требуемой команды, например, ps -C bash. Имеется также команда pgrep, позволяющая получить PID процессов по заданной командной строке, например, pgrep bash.

Все приведенные выше команды соответствуют POSIX-формату, однако GNU-версия программы ps поддерживает также опции и в BSD-стиле. Наиболее популярной командой в таком формате является ps aux – она выводит список всех процессов в системе с указанием их владельцев. В примере 1 приведен: небольшой фрагмент из ее вывода.
Пример 6.11. Опции команды ps в BSD -стиле

Эта команда отобразила в виде процентов уровень загрузки процессора и памяти данным процессом. Столбец VSZ – объем используемой процессом виртуальной памяти, a RSS – физической памяти.

Опции POSIX, BSD и длинные опции GNU команды ps можно комбинировать (пример 6.12).
Пример 6.12. Комбинация опций команды ps в POSIX-и BSD-стилях

Пример 6.12 содержит фрагмент вывода команды ps -f u root. В этом примере для выбора процессов пользователя root была использована опция в BSD-стиле u, а POSIX-опция -f была задана для указания подробного формата вывода.

В процессах могут быть созданы последовательности параллельно исполняющихся инструкций, называемых потоками (threads) или облегченными процессами (LWP, Light Weight Process). Для получения информации о потоках необходимо использовать опцию -L (пример 6.13).
Пример 6.13. Получение информации о потоках

В примере 6.13 демонстрируется, что у процесса swriter.bin (Open Office) PID равен 28 91. В этом процессе имеется пять потоков со своими идентификаторами, выводимыми в столбце LWP.

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

Утилита top регулярно обновляет информацию о процессах. Для выхода из нее необходимо набрать q. Эта команда позволяет, не выходя из интерактивного просмотра процессов, посылать процессам сигналы с помощью нажатия к. Нажатие на i отключает вывод top неактивных процессов. В первой строке экрана вывода команды приводятся данные о средней загруженности системы (load averages) за последние 1, 5 и 15 минут.

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

Исключительно важным инструментом, позволяющим получить информацию о процессах в системе, является каталог /proc (пример 6.15). То, что в нем находится, не является в полном смысле файлами – это псевдофайловая система, порождаемая ядром. Она позволяет выводить информацию о процессах, получать и устанавливать параметры ядра на лету.
Пример 6.15. Файловая система /proc

Подкаталоги /proc с именами, состоящими из цифр, соответствуют PID процессов.

Определим, например, PID текущей оболочки и исследуем соответствующий ее процессу каталог (пример 6.16).
Пример 6.16. Файлы в /proc

Файл cmdline содержит в себе командную строку процесса, а файл status – подробную информацию о статусе процесса. Подкаталог fd предназначен для мониторинга файлов, открытых процессом. В нем содержатся символические ссылки на реально открытые файлы процессом. Имена этих символических ссылок соответствуют номерам файловых дескрипторов открытых файлов.

Исключительно важной является команда fuser, позволяющая определить, какие процессы открыли заданный файл. В примере 6.17, приведенном далее, пользователь смонтировал DVD в каталоге /mnt/dvd, перешел в этот каталог и получил информацию о процессе, использующем этот каталог.
Пример 6.17. Команда fuser

Команда fuser вывела PID процесса оболочки, т.к. для нее этот каталог является текущим. Этот факт команда fuser подтверждает, выводя букву с после PID процесса.

Команда fuser выводит следующие символы после PID процессов:
□ с – текущий каталог;

□ е – исполняемый файл в момент его работы;

□ f – открытый файл;

□ r – корневой каталог;

□ m – разделяемая библиотека, либо отображаемый в память файл.
Опция -m команды fuser позволяет указать, что имя файла является именем смонтированного блочного устройства (пример 6.18).
Пример 6.18. Опция -m команды fuser

Для просмотра списка процессов в виде дерева, отображающего отношения родительских и дочерних процессов, необходимо выполнить команду pstree (пример 6.19).
Пример 6.19. Команда pstree

В примере 6.19 приведен фрагмент иерархического списка процессов.
Заданий
• Получите информацию о процессах в обычном и подробном форматах.

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

• Получите список всех процессов, связанных с терминалами.

• Выведите PID процессов, связанных с каталогом /usr.

• Получите иерархический список процессов с помощью команды ps (не pstree).

Сигналы

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

Список сигналов, используемых в системе, можно получить с помощью команды kill -l, а их подробное описание доступно с помощью man 7 signal.

Наиболее часто используются сигналы, приведенные в списке далее:
□ 1 – HUP – разрыв связи с терминалом (Hang Up – положить трубку). Многие демоны используют этот сигнал, как команду перечитать их конфигурационный файл и продолжить работу с измененными настройками. Оболочка Bash реагирует на этот сигнал завершением сеанса;

□ 2 – INT – прерывание процесса. Генерируется при нажатии комбинации клавиш +;

□ 3 – QUIT – сброс процесса. Генерируется при нажатии комбинации клавиш +<\>;

□ 15 – TERM – сигнал для корректного завершения процесса. Этот сигнал команда kill посылает по умолчанию;

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

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

Если необходимо послать сигнал некоторым процессам, то сначала требуется узнать PID этих процессов, а затем с помощью команды kill послать им требуемый сигнал, номер которого указывается после тире. Если номер сигнала или его имя не задано после дефиса, то команда kill посылает целевым процессам сигнал 15 (term). Так, например, можно попытаться послать сигнал оболочке bash (пример 6.20).
Пример 6.20, Реакция процессов на сигналы

Пример 6.20 демонстрирует, что оболочка bash игнорирует сигнал 15 (term), сигнал 2 (INT) очищает командную строку, а получив сигнал 1 (HUP), оболочка завершает работу и выходит из сеанса.

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

Удобно пользоваться командами pkill и killall. Они действуют подобно команде kill, позволяя, как и kill, послать требуемый сигнал нескольким заданным процессам. В отличие от команды kill, для команд pkill и killall достаточно указать имя командной строки процесса.

Например, следующая команда приведет к немедленному аварийному останову всех копий демона httpd (пример 6.21).
Пример 6.21. Команда killall
# killall -9 httpd
В результате передачи сигнала 9 (KILL) всем процессам httpd они будут сняты с исполнения, т. к. перехватить такой сигнал невозможно.
Задания
• Запустите порожденную оболочку bash. Исследуйте, посылая родительской оболочке сигналы TERM, INT, QUIT и HUP, что при этом происходит.

• От имени обычного пользователя пошлите сигнал KILL любому процессу, запущенному от имени другого пользователя. Что произойдет?

• Запустите в фоновом режиме команду sleep 1000. Проверьте, на какие сигналы из следующих: TERM, INT, QUIT и HUP, реагирует эта команда.

Перехвати обработка сигналов в Bash

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

Введите команды, показанные в примере 6.22, для установки ловушки сигнала INT.
Пример 6.22. Перехват сигналов в оболочке Bash

Команда trap установила ловушку для сигнала INT – команду echo. Команда trap -p вывела список установленных обработчиков сигналов. Далее пользователь нажал комбинацию клавиш +, передающую сигнал INT оболочке. При этом сигнал был перехвачен обработчиком, выполнившим команду echo
Задания
• Запрограммируйте оболочку так, чтобы при получении ей сигнала TERM создавался файл pwd.txt, содержащий информацию о текущем каталоге.

• Запустите порожденную оболочку. Работает ли в ней созданный обработчик?

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

В GNU/Linux используется режим выполнения процессов с разделением времени. В каждый момент времени центральный процессор выполняет инструкции одного-единственного процесса, а все остальные процессы находятся в режиме ожидания. Все процессорное время разделено на части – time slices (другое название – TIC). Маловероятно, чтобы процесс находился на исполнении процессора в течение всего времени TIC. Он может быть снят с исполнения более "важным" для системы процессом. Поэтому говорят о приоритете процессов в GNU/Linux.

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

Работа по обслуживанию очереди процессов осуществляется планировщиком. Планировщик вычисляет для каждого процесса величину, которую можно увидеть в поле PRI листинга, выводимого командой ps -l (пример 6.23). Чем ниже величина PRI, тем выше приоритет процесса, следовательно, быстрее он выполняется, поэтому для избежания путаницы далее в тексте вместо слов "увеличение и уменьшение приоритета" будут использованы, соответственно, "улучшение и уменьшение приоритета". Величина pri постоянно изменяется, обеспечивая для процессов, которые давно не были на исполнении процессором, улучшение приоритета, и, наоборот, для процессов, которые были исполнены только что,– его ухудшение.
Пример 6.23. Приоритет процессов

На основании вычисленной величины приоритета PRI ядро определяет, какой процесс следующим попадет на исполнение. В примере. 6.23 заметна также величина NI – nice number. Это число, устанавливаемое пользователем, называется иначе относительным приоритетом.

С помощью nice number пользователь может влиять на вычисляемую планировщиком величину приоритета процесса. Чем ниже значение nice number, тем лучше будет приоритет процесса, и тем быстрее он будет работать. В GNU/Linux значение nice number задается в пределах от –20 до 19. По умолчанию nice number равно 0.

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

Значение nice number можно установить с помощью команды nice. После нее в качестве аргумента задается команда, которая должна быть исполнена с измененным приоритетом. По умолчанию команда nice увеличивает значение nice number на 10, ухудшая, таким образом, приоритет этого процесса. Если требуется указать иное значение увеличения nice number, то его следует указать после опции -n.

Запустим, например, Bash с ухудшенным приоритетом (пример 6.24).
Пример 6.24. Запуск процесса с измененным значением nice number

В примере 6.24 продемонстрировано, как с помощью команды nice -n 19 bash была запущена оболочка bash с ухудшенным приоритетом. В поле NI для этой оболочки команда ps -l выводит значение 19. Поле PRI этого же листинга показывает, что приоритет запущенной оболочки bash действительно ухудшен (78 у дочерней оболочки против 74 у родительской).

Для установки иного значения nice number для уже исполняющегося процесса следует использовать команду renice. Эта команда обычно доступ только для суперпользователя. Новое значение nice number указывается качестве аргумента команды renice. С помощью этой команды можно изменить nice number для конкретного процесса, заданного с помощью его PID после опции -р или же в качестве второго аргумента. Например, ц изменения nice number оболочки bash из предыдущего примера можно в полнить команду, показанную в примере 6.25.
Пример 6.25. Команда renice

Данная команда установила новое значение приоритета (поле NI) для оболочки, которая была исходно запущена с nice number 19. Заметно, что приоритет процесса (см. поле PRI) также изменился.

С помощью команды renice можно изменять приоритет всех процессов для заданного после опции -u пользователя (-g для группы пользователей) – пример 6.26.
Пример 6.25. Изменение приоритета процессов заданного пользователя
# renice 0 -u userl
Задания
• От имени обычного пользователя попытайтесь запустить оболочку bash со значением nice number, равным -l. Какое сообщение выводится?

• От имени суперпользователя запустите команду индексирования базы данных поиска в следующем виде: time nice -n 19 updatedb. А затем выполните такую же команду, в которой значение nice number для updatedb будет -5, Сравните полученные результаты.