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

Как мы уже упоминали ранее, некий процесс является исполняемой программой. Данная программа может собираться из кода языка программирования, причём некоторый исполняемый код, создаваемый после компиляции некоторой исходной программы, написанной на языке программирования верхнего уровня, таком как C++, либо некий код интерпретатора, написанный на LISP, JavaScript, Perl, интерпретируемом C (CINT) или в какой- то оболочке UNIX. Сама система UNIX создаёт некий процесс всякий раз, когда вы исполняете какую- либо внешнюю команду, причём такой процесс удаляется из этой системы по окончанию её исполнения. Мы применяем взаимозаменяемо термины программа и команда.

Создание процесса и его прекращение являются исключительными механизмами, применяемыми в системах Unix для исполнения внешних команд. В некоторой типичной системе с разделением времени, такой как UNIX, которые делают возможным множеству пользователей одновременно использовать некую вычислительную систему и исполнять множество процессов, причём от сотен до тысяч процессов создаётся и прекращается ежедневно. Помните, что собственно в компьютере исполняет процессы ЦПУ и что обычная система имеет только один ЦПУ. Основной вопрос заключается в том как система с единственным ЦПУ исполняет множество процессов одновременно? Даже для систем со множеством ЦПУ или со множеством ядер в ЦПУ, общее число процессов больше чем общее число ЦПУ или ядер. Как же некая система при общем числе процессов, превосходящем общее число ЦПУ или ядер ЦПУ исполняет такие процессы одновременно? Подробное обсуждение этой темы выходит за рамки данного учебного пособия, однако вкратце мы вернёмся к нему в Разделе 10.2 и позже в Разделе 10.5.1. Далее в этой главе мы обсудим просмотр статических и динамических состояний процессов, приоритетные (foreground) и фоновые (background) процессы, демоны, задания, атрибуты процессов и заданий, а также управление процессами и заданиями. Термины разделение времени (time sharing) и многозадачность (multitasking) мы будем применять как синонимы.

В типичной вычислительной системе, состоящей из единственного ЦПУ и работающего под управлением операционной системы с разделением по времени исполнения, одновременное исполнение множества процессов выполняется путём быстрого переключения ЦПУ от одного процесса к другому. То есть, один процесс исполняется на в течении непродолжительного периода времени, а затем данный ЦПУ передаётся другому процессу. Этот новый процесс исполняется некое непродолжительное время и затем данный ЦПУ передаётся вновь следующему процессу. То время, которое некий процесс находится "внутри" данного ЦПУ прежде чем он переключится "вовне" данного ЦПУ имеет название квантом или срезом времени. В обычной UNIX системе такой квант обычно очень короткий: одна секунда или меньше. В Solaris данный квант некоторого процесса зависит от приоритета процесса. Для процессов пользователя с разделением времени значение кванта составляет 40 миллисекунд. Для более приоритетных процессов такое значение кванта выше. Например, для потоков ядра с приоритетом 0 значение кванта равно 200 миллисекундам, а для потоков ядра с приоритетом 10 160 миллисекунд. Во FreeBSD такое значение кванта времени равно 0.1 секунды. Когда данный ЦПУ свободен/ простаивает (idle, т.е. не используется каким- либо процессом), либо когда определённый текущий процесс завершил свой квант, само ядро применяет некий алгоритм чтобы решить какой процесс получит применение ЦПУ следующим. Та техника, которая применяется для выбора подобного процесса, который получает в своё пользование имеющийся ЦПУ называется планированием ЦПУ (CPU scheduling). Тот код ядра, который исполняет данную задачу называется краткосрочным планировщиком ЦПУ (short-term CPU scheduler), либо планировщиком ЦПУ (CPU scheduler).

Конкретная процедура забора ЦПУ обратно у исполняющегося в настоящее время процесса и предоставление его определённому по расписанию новому процессу называется контекстным переключением (context switching). Данная задача исполняется другой частью ядра, имеющей название диспетчера (dispatcher). В системе со множеством ЦПУ или для ЦПУ со множеством ядер, таких как выпускаемых Intel, AMD и другими компаниями, если общее число процессов в данной системе превышает общее число ЦПУ в данной системе (или общее число ядер для системы с единственным ЦПУ), планирование ЦПУ и контекстное переключение всё ещё происходят. Таким образом, в некоторой системе со множеством пользователей исполняющих множество процессов имеющиеся планировщик и диспетчер работают в тандеме с тем чтобы вы чувствовали себя единственным использующим всю систему. Хотя некая сосредоточенность на обсуждении алгоритмов планирования ЦПУ выходит за рамки данной книги, мы представим некоторое упрощённое видение того как работают планировщики UNIX SV, FreeBSD и Solaris.

В некоторой системе с разделением по времени, каждому процессу назначается некое значение приоритета, причём следующим получает в своё распоряжение ЦПУ тот процесс, который имеет более высокий приоритет. Для назначения какого- то значения некоторому процессу могут применяться различные методы. Один простой метод основывается на том значении времени когда он вошёл в систему. В данной схеме обычно тому процессу, который вошёл в данную систему первым, назначается более высокий приоритет и предоставляется следующее использование имеющегося ЦПУ; получаемый результат называется алгоритмом планирования первый вошедший обслуживается первым (FCFS, first-come, first-serve). Другой схемой является назначение некоторой величины приоритета на основе используемого неким процессом времени ЦПУ. Таким образом, некие недавно появившиеся процессы или какие- то процессы, которые тратят основное время на выполнение операций ввода и/ или вывода (I/O), получают более высокий приоритет. Процессы, которые тратят большую часть своего времени выполняя ввод/ вывод называются процессами, связанными со вводом/ выводои. Неким примером связанного со вводом/ выводом процесса является текстовый редактор, например, vim. В алгоритме планирования карусельным образом (RR, round robin), имеющийся ЦПУ предоставляется каждому ЦПУ в определённой очереди процессов на единственный квант времени по порядку, один за другим. Такой алгоритм является естественным выбором для систем с разделением времени, в которых все пользователи хотят видеть продвижение своих процессов. Если вам интересны прочие алгоритмы планирования ЦПУ, мы рекомендуем вам прочесть некую книгу по принципам и концепциям операционных систем. Тот код операционной системы, который реализует необходимый алгоритм планирования ЦПУ называется планировщиком процессора (processor scheduler). Подобный планировщик для большинства операционных систем, включая UNIX, находится в самом ядре.

Алгоритм планирования UNIX System V является смесью всех упомянутых алгоритмов и даже более. Он применяет некую простую формулу для назначения некоторого значения приоритета каждому процессу в данной системе если ог готов к исполнению. Такое значение приоритета для каждого процесса в данной системе повторно вычисляется каждую секунду. Когда наступает время планирования, данный ЦПУ отдаётся тому процессу, который имеет наименьшее численное значение приоритета. Если множество процессов имеют одно и то же численное значение приоритета, окончательное решение принимается на основе FCFS. Той формулой, на основании которой производится вычисление значения приоритета является:

значение приоритета = пороговое значение приоритета + значение любезности + (недавнее использование ЦПУ / 2),
		   

где пороговое значение приоритета является неким целым обычно имеющим значение от 40 до 60, значение любезности (nice value) является положительное целое со значением по умолчанию 10, но может быть неким значением от -20 до 19 (20 в некоторых системах UNIX), а использование ЦПУ общее число тактов времени (1/60 или 1/50 секунды для более ранних систем, где 60 и 50 является частотой в линии электропитания в Герцах) в течении которых данный процесс применял этот ЦПУ. В современных системах UNIX временной такт намного ниже и не вычисляется на основе частоты линии электропитания. Имеющиеся часы программы обслуживания прерываний (ISR, interrupt service routine), обновляют использование ЦПУ для каждого процесса после каждого такта времени, что увеличивает общий счётчик тактов для того процесса, который в настоящее время использует данный ЦПУ. Такие часы ISR делят все насчитанные такты каждого процесса на два перед тем как повторно вычисляют приоритеты всех процессов применяя отображённую формулу. Такое деление на два известно как применение функции распада (decay function), так как оно экспоненциально уменьшает воздействие предыдущего использования ЦПУ. Таким образом, недавнее применение ЦПУ процессом оказывает большее воздействие на величину его приоритета, в его уходящее в историю использование имеет понижающееся влияние. Таким образом имеющееся значение использования ЦПУ увеличивается для тех процессов, которые используют ЦПУ и уменьшается для всех остальных.

Вы можете назначит более высокое любезное значение для своего процессора с помощью команды nice или renice, однако такое любезное значение не может быть установлено в отрицательную величину кем- то, не имеющим права суперпользователя. Более высокая величина любезного значения означает более высокую величину приоритета, следовательно, более низкий приоритет. Итак, когда вы увеличиваете величину хорошего значения для своего процесса, вы являетесь более любезным ко всем остальным процессам пользователей. Данная формула ясно указывает что чем выше значение недавнего использования ЦПУ некоторого процесса, тем выше его величина приоритета. Таким образом UNIX предпочитает те процессы, которые использовали меньше времени ЦПУ в недавнем прошлом. Текстовый редактор подобный vim получает более высокий приоритет нежели некий процесс, который вычисляет значение числа π (пи), так как vim проводит основное время в ожидании операций ввода/ вывода - то есть считывает с клавиатуры, выполняет чтение/ запись на диск и отображает данные файла или ввода с клавиатуры на основном экране. С другой стороны, тот процесс, который вычисляет π татит своё основное время на выполнение вычислений - то есть использует ЦПУ. Повторное вычисление всех значений приоритетов каждую секунду вызывает динамическое изменение приоритетов процессов (вверх и вниз). В Разделе 10.5 мы дальше исследуем имеющуюся концепцию планирования UNIX, в частности, по отношению к PC-BSD и Solaris.

Процесс UNIX может находиться в одном из множества состояний, перемещаясь из одного состояния в другое, в конце концов завершая своё выполнение, причём оно может быть как нормальным, так и нештатным, но в конечном счёте управление передаётся самой системе. Процесс завершается нормально, когда он оканчивает свою работу и выходит в систему надлежащим образом. Процесс завершается нештатно когда он выходит в свою систему из- за некоторого прерывания (exception, наличие ошибки) или из- за вмешательства (intervention) его владельца или суперпользователя. Владелец процесса может вмешаться при помощи команды или определённого нажатия клавиш для преывания данного процесса. Мы обсудим такие команды или конкретные нажатия клавиш позже в данной главе. Все первичные состояния, в которых некий процесс может находиться отображены в диаграмме состояний на Рисунке 10.1.

Состояние ожидания (waiting state) охватывает определённые состояния; мы применяем данный термин здесь чтобы сохранить простой показанную схему. Некоторые из относящихся к состоянию ожидания состояний перечисляются под овалами, представляющими определённое состояние. Таблица 10.1 представляет краткое описание таких состояний процесса UNIX. В интересах краткости и придерживаясь темам данной книги, прочие состояния, в которых может находиться некий процесс UNIX не включены в данное обсуждение.

Команда оболочки может быть внутренней (встроенной) или внешней. Некоторой внутренней/ встроенной командой является команда, код которой является частью самого процесса оболочки. Некоторыми обычно используемыми командами являются . (команда точки), bg, cd, continue, echo, exec, exit, export, fg, jobs, pwd, read, readonly, return, set, shift, test, times, trap, umask, unset и wait. внешней командой является команда выполненная в виде отдельного файла с кодом; содержимым этого кода может быть двичный код или некий сценарий оболочки. В качестве обычно применяемых команд можно представить grep, more, cat, mkdir, rmdir, ls, sort, ftp, telnet, lp и ps. Оболочка создаёт некий новый процесс для исполнения какой- то команды. Пока исполняется процесс данной команды, сама оболочка ожидает его завершении. В данном разделе мы описываем как некая оболочка (или некий процесс) создаёт другой процесс и исполняет внешние команды. Вы можете применить команду type для определения того факта, является ли ваша команда встроенной или внешней, как это показано в следующем разделе. В Bash вы можете воспользоваться параметром -a для отображения всех местоположений команд, как показано ниже. Вы можете отметить, что команда bg является встроенной, но также имеет и внешнюю версию. Однако, по умолчанию исполняется встроенная версия. Сама оболочка Bourne может быть запущена через два исполняемых файла, доступных в двух разных местах структуры вашей файловой системы.

Таблица 10-1. Краткое описание состояние процесса UNIX

Состояние	Описание
Ready	Данный процесс готов к исполнению, однако не имеет ресурса ЦПУ. Основываясь на алгоритме планирования, сам планировщик принимает решение по предоставлению ресурса ЦПУ другому процессу. В данном состоянии могут пребывать различные процессы, однако в машине с единственном ЦПУ только один может работать/ исполняться (т.е. применять ЦПУ).
Running	Данный процесс действительно исполняется (т.е. применяет ЦПУ).
Waiting	Данный процесс ожидает события. Возможными событиями могут быть: завершение некоторой операции ввода/ вывода (т.е. операции чтения или записи диска/ терминала), завершение дочернего процесс (данный родитель ожидает выхода одного или более детей) или сам процесс ожидает повторного пробуждения находясь в состоянии сна.
Swapped	Данный процесс готов к исполнению, однако временно помещён на имеющийся диск (в предоставленное пространство подкачки); может потребоваться дополнительная оперативная память, которой в данный момент не имеется.
Zombie	Убитый процесс называется находящимся в состоянии зомби. Обычно, когда его родительский процесс завершился до выполнения вызова выхода данного процесса, он становится неким процессом зомби. Такой процесс завершается и обнаруживает что его не ожидает его родительский процесс. Такой процесс зомби завершён в отношении всех практических целей и не располагается в оперативной памяти, но всё ещё имеет некоторые выделенные ему ресурсы ядра, которые не могут быть возвращены в данную систему. Все зомби и их исполняющиеся потомки со временем принимаются своим прародителем, основным процессом Code, который и удаляет их из данной системы.

$ type bg
bg is a shell builtin
$ type -a bg
bg is a shell builtin
bg is /usr/bin/bg
$ type -a sh
sh is /usr/bin/sh
sh is /usr/sbin/sh
$
		   

Всякий процесс UNIX может создать другой процесс применив системный вызов fork(), который создаёт точную копию оперативной памяти первоначального процесса (т.е. того процесса, который вызвал fork()). Оба процесса продолжат исполнение, начав с того оператора, который следует за таким ветвлением. Разветвляемый процесс именуется родительским процессом, а созданный (ответвлённый) процесс называется дочерним процессом (потомком) что отображается на Рисунке 10.2. Здесь мы отображаем оболочку Bourne, которая создала некий дочерний процесс (другую оболочку Bourne). Мы обсудим использование fork() и прочих системных вызовов, требующихся для создания и взаимодействия между процессами (IPC, interprocess communication) в Главах 18 - 21.

Для исполнения внешней команды в виде исполняемого файла требуется некий механизм, который позволяет данному дочернему процессу стать самой исполняемой командой. Именно для этого и можем применяться системный вызов UNIX exec(), он делает возможным перезапись процесса самого собой тем исполняемым кодом, который представляет следующую команду. Оболочка применяет команды fork() и exec() в тандеме при исполнении внешних команд исполняемых файлов. Рисунок 10.3 отображает последовательность событий для выполнения внешней команды sort, чьим кодом является исполняемый файл /usr/bin/sort.

Само исполнение сценария оболочки (последовательности команд оболочки в некотором файле; см. Главы 12 - 15) слегка отличается от исполнения некоторого исполняемого файла/ команды. В данном случае сценария оболочки сама текущая оболочка создаёт некую дочернюю оболочку и позволяет ей исполнять команды в таком файле сценария одну за другой. Каждая команда в данном файле сценария исполняется в точности так же, как и команда, введённая с клавиатуры; то есть сама дочерняя оболочка создаёт некоторого потомка для каждой исполняемой команды. В то время, когда имеющаяся дочерняя оболочка исполняет команды в данном файле сценария, сама родительская оболочка ожидает завершения своего потомка. Когда такая дочерняя оболочка сталкивается в данном файле сценария с маркером eof, она прекращает своё исполнение. Единственной целью самой дочерней оболочки, как и любой другой оболочки, состоит в исполнении команд, а eof означает "больше нет команд". После окончания дочерней оболочки его родительская оболочка выходит из состояния ожидания и продолжает исполнение. Данная последовательность событий отображена на Рисунке 10.4, который также отображает само исполнение команды find из файла сценария.

Пока другое не определено в самом содержащем данный сценарий файле, данная дочерняя оболочка имеет тот тип, который определён для самой родительской оболочки. То есть, если родитель является оболочкой Bourne, сам потомок также является оболочкой Bourne. Таким образом, по умолчанию сам сценарий оболочки исполняется некоторой "копией" своей родительской оболочки. Однако, некий сценарий, написанный под любую оболочку (C, TC, Bourne, Bash, Korn и т.п.) может исполняться не взирая на имеющийся тип текущей оболочки. Для этого просто определите необходимый тип дочерней оболочки для каждого исполняемого сценария в самой первой строке содержащего её файла в виде #!полный-путь-к-имени-необходимой-оболочки. Например, следующая строка указывает, что дочерней оболочкой является оболочка C, поэтому тот сценарий, который следует за данной строкой исполняется под оболочкой C.

	#!/bin/csh
		   

Кроме того, вы можете исполнять команды в другой оболочке исполняя эту оболочку как дочернюю для текущей рабочей оболочки, выполнить в ней команды и завершить исполнение этой оболочки. Некая дочерняя оболочка также имеет название подоболочки (subshell). Повторим, что командами для исполнения различных оболочек являются sh для оболочки Bourne, csh для оболочки C, tcsh для оболочки TC, ksh для оболочки Korn, bash для оболочки Bourn again. Чтобы запустить некий новый процесс оболочки просто исполните ту команду, которая соответствует той оболочке, которую вы желаете исполнить.

В приводимом далее сеансе текущая оболочка является оболочкой C, а оболочка Bourne исполняется как её потомок. Команда echo исполняется в оболочке Bourne. Затем запускается некая оболочка Bash и команда echo исполняется в ней. Команда ps отображает исполнение всех трёх оболочек. Наконец, и оболочка Bash, и оболочка Bourne прекращаются последовательностью нажатий клавиатуры Ctrl+D, при этом управление возвращается обратно первоначальной оболочке, нашей оболочке C. Самое первое Ctrl+D прекращает исполнение оболочки Bash, передавая управление оболочке Bourne. Вы также можете покинуть исполняющуюся оболочку выполнив команду exit. Рисунок 10.5 иллюстрирует все задействованные этапы, отображая взаимоотношения родитель- потомок между процессами.

% ps
PID TT STAT TIME COMMAND
44387 5 Ss 0:00.97 -csh (csh)
45878 5 R+ 0:00.01 ps
% /bin/sh
$ echo "This is Bourne shell."
This is Bourne shell.
$ bash
[sarwar@pcbsd-srv ~]$ echo "This is Bourne Again SHell."
This is Bourne Again SHell.
[sarwar@pcbsd-srv ~]$ ps
PID TT STAT TIME COMMAND
44387 5 Is 0:00.97 -csh (csh)
45910 5 I 0:00.02 /bin/sh
45935 5 S 0:00.07 bash
46008 5 R+ 0:00.01 ps
[sarwar@pcbsd-srv ~]$ <Ctrl+D>
$ <Ctrl+D>
%
		   

Всякий процесс UNIX имеет некоторые атрибуты, включая идентификатор владельца (именуемый на жаргоне UNIX user ID [UID]), идентификатор процесса (PID), PID его родительского процесса (PPID), название процесса, состояние процесса, запустившая данный процесс исполняемая команда, приоритет данного процесса, время запуска процесса, процент времени исполнения ЦПУ, потреблённый данным процессом, процент объёма основной оперативной памяти, потреблённый данным процессом, размер данного процесса в виртуальной памяти, размер процесса, находящегося в данный момент в основной оперативной памяти, состояние данного процесса, то событие, которое ожидает данный процесс (в случае если он не исполняется), а также продолжительность времени, в течении которого данный процесс исполняется. С точки зрения пользователя и программиста одним из самых полезных среди данных атрибутов является PID, который применяется в качестве параметра в различных командах управления процессами, которые обсуждаются далее в этой главе.

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

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

Вывод команды ps вначале сортируется по связанным с процессами терминалам, а затем по их PID. Вы можете изменить такой установленный по умолчанию порядок сортировки применяя различные опции. Если определено множество таких опций, данная команда придерживается самой последней опции. Все сеансы оболочки в данном разделе демонстрируют данную команду ps с опциями или без них. Все их мы исполнили на машине PC-BSD под управлением оболочки C.

Вывод данной команды ps для версии PC-BSD, как это показано в приводимом ниже сеансе, отображает пять полей о процессах, чьи атрибуты выводятся построчно: идентификатор процесса (PID), тот термина, к которому подключён данный процесс (TT), состояние процесса (STAT), потреблённое данным процессом время ЦПУ (TIME) и использованная пользователем команда для исполнения данного процесса (COMMAND). Данный вывод показывает, что два процесса подключены к терминалу 1: -csh (сама регистрация в оболочке C) и ps, а два подключены к терминалу 2: -csh (опять регистрация в оболочке C) и текстовый редактор vim, - перед некоторой оболочкой, как в случае с -csh, указывает на то, что это регистрация в оболочке. Значение PID подключённого к терминалу 1 процессов -csh и ps равны 37838 и 41626, причём они, соответственно, проработали 19 секунд и 1 секунду. Аналогично, значения PID процессов, исполняющих -csh и vim равны 41496 и 41619, причём они, соответственно, проработали 27 секунд и 19 секунд каждый.

% ps
  PID TT  STAT     TIME COMMAND
37838  1  Ss    0:00.19 -csh (csh)
41626  1  R+    0:00.01 ps
41496  2  Ss    0:00.27 -csh (csh)
41619  2  S+    0:00.25 vim canleave
%
 	   

В предыдущем сеансе само состояние процесса отображается в виде строки символов - например, Ss, S+ и R+. Таблица 10.2 поясняет различные символы в данной строке, перечисленные в колонке состояний процесса STAT).

Таблица 10-2. Краткое описание состояние процесса UNIX

Первый символ	Описание	Дополнительный символ	Описание
D	Процесс на диске или в другом режиме кратковременного ожидания	+	Приоритетный процесс.
I	Простаивающий процесс - в ожидании > 20с	<	Процесс имеет повышенный приоритет
L	Процесс ожидания блокировки	E	Процесс выхода
R	Исполняемый процесс, ожидающий получения ЦПУ	J	Процесс в "jail"
S	Спящий процесс, в ожидании < 20с	L	Блокированный в ядре процесс - например, сырой операцией ввода/ вывода
T	Остановленный/ придержанный процесс	N	Имеющий пониженный приоритет планирования процесс
I	Простаивающий процесс/ поток прерывания	s	Ведущий в сеансе процесс - например, регистрация оболочки
Z	Процесс зомби	V	Приостановлен в vfork(2)
		W	Процесс в страницах подкачки
		X	Процесс отслеживается или отлаживается

Таким образом, процесс с состоянием Ss является ведущим в сеансе процессом, который в настоящее время находится в состоянии сна - то есть пребывает в ожидании менее 20 секунд. Аналогично, процесс с состоянием S+ является приоритетным (foreground) процессом, который пребывает в состоянии ожидания менее 20 секунд. Наконец, тот процесс, у которого состояние R+ является приоритетным процессом, который готов к исполнению и ожидает своего планирования к применению ЦПУ. В Разделе 10.6 мы обсудим подробнее приоритетные и фоновые процессы.

Команда ps -u отображает длинный список всех процессов, относящихся ко всем исполняемым данным пользователям командам. VSZ является виртуальным размером каждого процесса, а RSS (resident set size, размер резидентного набора) является реальным размером данного процесса в памяти. Оба размера приводятся в килобайтах. Отметим, что sarwar зарегистрирован в пяти различных терминалах с пятью исполняющимися зарегистрированными оболочками С.

% ps -u
USER      PID %CPU %MEM   VSZ  RSS TT STAT STARTED    TIME COMMAND
sarwar  37838  0.0  0.1 25548 3900  1 Is+   6:15AM 0:00.20 -csh (csh)
sarwar  41937  0.0  0.1 25548 3900  3 Is+   7:06AM 0:00.20 -csh (csh)
sarwar  41985  0.0  0.1 25548 3576  4 Is+   7:07AM 0:00.10 -csh (csh)
sarwar  44387  0.0  0.1 25548 3940  5 Ss    7:38AM 0:00.50 -csh (csh)
sarwar  44716  0.0  0.1 16592 2304  5 R+    7:41AM 0:00.02 ps -u
sarwar  44428  0.0  0.1 25548 3900  6 Is    7:38AM 0:00.18 -csh (csh)
sarwar  44675  0.0  0.1 16992 2800  6 I+    7:40AM 0:00.06 /bin/sh/usr/bin/man
sarwar  44688  0.0  0.1 14788 2632  6 S+    7:40AM 0:00.03 more
%
 	   

Вы можете определить разделённый запятыми список UID для отображения аналогичной информации об относящейся к ним информации, например ps –u 1004,1009,1020. Напомним, что UID является третьим полем в строке вашего файла /etc/passwd. Отметим, что состояние самых первых трёх процессов Is+, что означает, что они приоритетные простаивающие ведущие процессы. Другими словами, это приоритетные процессы регистрации оболочки, которые не использовались более 20 секунд.

Вы можете воспользоваться опцией –U в PC-BSD и Solaris для отображения значения состояния по умолчанию для всех тех процессов, которые относятся к перечисленным через запятую списке имён пользователей, определённом после данной опции. В приводимом далее примере отображены все процессы, относящиеся к пользователю sarwar. Команда ps –U john,davis,goldman,ibraheem отображает все состояния по умолчанию для всех процессов, относящихся к пользователям john, davis, goldman и ibraheem.

% ps -U sarwar
  PID  TT STAT     TIME COMMAND
 4964   - I     0:00.04 sshd: sarwar@pts/1 (sshd)
 8980   - S     0:00.29 sshd: sarwar@pts/2 (sshd)
 4967   1 Is+   0:00.17 -csh (csh)
 8983   2 Ss    0:00.37 -csh (csh)
13011   2 R+    0:00.02 ps -U sarwar
%
 	   

Для отображения той же самой информации вы также можете воспользоваться разделённым запятыми списком UID всех пользователей. Таким образом, ps –U 1004 отобразит значения по умолчанию состояний для всех процессов, относящихся к пользователю с UID 1004. Аналогично, команда ps –U 1004,1005,1001 отображает значения по умолчанию состояния всех процессов, относящихся к пользователям с UID 1001, 1004 и 1005.

Вы можете применять опции –a и –x для отображения информации о своих процессах, относящихся к другим пользователям процессах, системным процессам, а также не подключённым ни к каким терминалам процессам, например, демонам. Вы можете определить общее число процессов, включая все системные процессы и все демоны, выполняющиеся в системе PC-BSD воспользовавшись командой ps –ax | wc –l. Её вывод содержит некоторую строку заголовка и по строке для каждого процесса ps –ax и wc –l. Таким образом, в нашей системе PC-BSD в настоящее время исполняется 130 процессов, если мы не не будем считать те два процесса, которые созданы самой командной строкой. {Прим. пер.: и строка заголовка.}

% ps -ax | wc -l
     133
%
 	   

Вы можете определить общее число процессов, исполняемых на машине Solaris, воспользовавшись командой ps -e | wc –l.

В Solaris вы можете применять опцию -H для отображения видимых самому ядру потоков, называемых процессами с малым весом (LWP, lightweight processes) для всех исполняемых в вашей системе процессов. Вывод такой команды ps –axH | wc –l отображает в качестве выхода 506. Из этих 506 строк одна служит самому заголовку и по одной строке уходит на каждую из команд ps –axH и wc –l. Таким образом, в тех 130 процессах, которые в настоящее время исполняются в нашей системе запущено 503 видимых ядру потоков.

% ps -axH | wc -l
     506
%
 	   

Тогда как опции –j, -l, -u и -v позволяют нам отображать все значения предварительно определённых ключевых слов в известном порядке и со стандартной информацией в заголовке, опции -O и -o делают возможным для вас отображение персонализированного вывода: значения ключевых слов по вашему выбору, причём в том порядке, который подходит для вас, а также с самим заголовком по вашему вкусу. В последующем сеансе мы отображаем применение команды ps с данными опциями. Ключевые слова dsiz, ssiz и vsiz являются, соответственно, размером (в килобайтах) всех сегментов данных, стека и текста/ кода в образе памяти данного процесса. wchan является ожидаемое событие процесса. Самая последняя команда в данном сеансе показывает как вы можете персонализировать свой заголовок вывода.

% ps -O dsiz,ssiz,tsiz,vsz,rss,wchan
  PID DSIZ SSIZ TSIZ    VSZ  RSS  WCHAN TT  STAT    TIME COMMAND
34860  172  128  348  25548 3940  pause  1  Ss   0:00.28 -csh (csh)
35024   16  128   32  16592 2304  -      1  R+   0:00.00 ps -O dsiz,ssiz,tsiz,vsz
29019  172  128  348  25548 3976  ttyin  4  Is+  0:00.31 -csh (csh)
% ps -o dsiz,ssiz,tsiz,lwp,nlwp,wchan,pcpu,pmem,flags,args
DSIZ SSIZ TSIZ     LWP NLWP WCHAN %CPU %MEM        F COMMAND
 172  128  348  100733    1 pause  0.0  0.1 10004002 -csh (csh)
  16  128   32  100622    1 -      0.0  0.1 10004002 ps -o dsiz,ssiz,tsiz,lwp,nl
 172  128  348  100690    1 ttyin  0.0  0.1 10004002 -csh (csh)
% ps -o user,pid=SON -o ppid=MOM -o args
USER     SON   MOM COMMAND
sarwar 34860 34857 -csh (csh)
sarwar 35281 34860 ps -o user,pid=SON -o ppid=MOM -o args
sarwar 29019 29016 -csh (csh)
%
 	   

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

% ps -L
%cpu %mem acflag acflg args blocked caught class comm command cow cpu cputime dsiz egid egroup emul etime etimes euid f fib flags gid group ignored inblk inblock jid jobc ktrace label lim lockname login logname lstart lwp majflt minflt msgrcv msgsnd mwchan ni nice nivcsw nlwp nsignals nsigs nswap nvcsw nwchan oublk oublock paddr pagein pcpu pending pgid pid pmem ppid pri re rgid rgroup rss rtprio ruid ruser sid sig sigcatch sigignore sigmask sl ssiz start stat state svgid svuid systime tdaddr tdev tdnam time tpgid tsid tsiz tt tty ucomm uid upr uprocp user usertime usrpri vsize vsz wchan xstat
%
 	   

Таблица 10.3 отображает некоторые общеупотребимые ключевые слова и их значение. Отметим, что эти поля отображаются в верхнем регистре в самом заголовке вывода команды ps (т.е. COMMAND для command, PID для pid).

Таблица 10-3. Краткое описание общеупотребимых полей/ влючевых слов команды ps

Поле	Описание	Доле	Описание
command	Выполненная для создания данного процесса команда	ppid	Идентификатор родительского процесса
dsiz	Размер данных в килобайтах	pri	Приоритет планирования
cpu	Кратковременное использование ЦПУ для планирования	rss	Реальный размер процесса (килобайты) а памяти
flags	Отображающие состояние/ событие процесса флаги	sid	Идентификатор сеанса; PID ведущего процесса сеанса
majflt	Общее значение отказов страниц (то же самое, что и PAGEIN)	started	Время запуска данного процесса
mwchan	Событие или блокировка захваченного/ блокированного процесса	stat	Состояние процесса
nlwp	Общее число привязанных к некоторому LWP потоков	time	Время исполнения данного процесса
pcpu	Загрузка процесса до одной предыдущей минуты	tsiz	Размер текста (кода) в килобайтах
pgid	Идентификатор группы процессов	tt	Терминал, к которому подключён данный процесс
pid	Идентификатор процесса	vsz	Виртуальный размер процесса в килобайтах
pmem	Процентное использование памяти процессом	wchan	Событие (или адрес) которое ожидает некий процесс

Сегменты данных, стека и текста/ кода являются частью определённого образа процесса в памяти. тремя дополнительными разделами данного образа в памяти процесса UNIX являются: совместно используемые библиотеки, куча и среда. Рисунок 10.6 отображает весь образ памяти процесса UNIX. Его среда состоит из аргументов командной строки и пяти переменных оболочки (HOME, PATH, SHELL, USER и LOGNAME), доступных через указатели на два массива указателей на заканчивающиеся нулём строки. Стек растёт от верхних адресов памяти к нижним, а куча растёт от нижних адресов памяти к верхним. Порции текста и инициализированных данных считываются из соответствующего файла программы системным вызовом exec(2), а раздел неинициализированных данных (bss) инициализируется нулевым значением, причём также exec(2).

Также вы можете воспользоваться командой size для отображения значений размеров (в байтах) текста/ кода, инициализированных данных и неинициализированных данных (bss) для некоторой исполняемой команды. Ниже приводятся примеры исполнения такой команды в PC-BSD и Solaris, соответственно со значением /usr/bin/sort в качестве аргумента. В обоих случаях четвёртое число является общим размеров разделов текста и данных (т.е. общей суммы первых трёх чисел) в десятичном исчислении. Для версии PC-BSD пятое число является значением общего размера в шестнадцатеричном исчислении.

% size /usr/bin/sort
   text     data       bss dec    hexfilename
  52748     2656     468860092    eabc/usr/bin/sort
%

$ size /usr/bin/sort
69657  + 1584 + 44012 = 115253
$
 	   

Следующий синтаксический блок представляет краткое описание версии Solaris для команды ps.

В версии Solaris обсуждаемая команда ps поддерживает следующие опции аналогичной версии команды PC-BSD: S, a, e, r, v, w и x. Однако, вы запускаете их без применения тире перед опцией, например, ps r. Аналогично, опция -o также работает в Solaris как она это делает в PC-BSD, но не со всеми ключевыми словами, перечисленными в Таблице 10.3, или теми, которые отображались командой ps -L в PC-BSD. Она работает со следующими ключевыми словами, большая часть из которых общая с версией PC=BSD: user, ruser, group, rgroup, uid, ruid, gid, rgid, pid, ppid, pgid, sid, tasked, ctid, pri, opri, pcpu, pmem, vsz, rss, osz, nice, class, time, etime, stime, zone, zoneid, f, s, c, и lgrp.

Вывод команды ps в Solaris отображает четыре поля, как это показано далее, причём pts/1 является псевдотерминалом 1:

$ ps
  PID TTY          TIME CMD
 7243 pts/1        0:00 bash
 7247 pts/1        0:00 ps
$
 	   

Пример исполнения следующего сеанса отображает применение команды ps с различными опциями. Отметим, что вывод команды ps -l включает устаревшие поля F и ADDR, а также вышедшее из употребление поле PRI (именуемое как OPRI в том списке ключевых слов, который был отображён в предыдущем параграфе), причём более низкое значение PRI означает более высокий приоритет. Вы можете использовать опции -y и -l совместно для исключения всех колонок устаревших полей F и ADDR, а также RSS и отображения значения PRI по моде.

$ ps -l
 F S   UID   PID  PPID C PRI NI  ADDR    SZ  WCHAN    TTY TIME CMD
 0 O  1007  9784  9624 0  40 20     ?  2333         pts/2 0:00 ps
 0 S  1007  9624  9621 0  50 20     ?  2546      ?  pts/2 0:00 bash
$ ps -ly
   S   UID   PID  PPID C PRI NI   RSS    SZ  WCHAN    TTY TIME CMD
   S  1007 14081 14080 0  50 20  2284 10188      ?  pts/5 0:00 bash
   O  1007 14116 14081 0  40 20  1472  9332         pts/5 0:00 ps
$ pagesize
4096
$
 	   

Самая первая колонка, S, показывает текущее состояние данного процесса. Состояния процессов в Solaris кратко описаны в Таблице 10.4 совместно с некоторыми полями, которые отличаются от полей, отображённых для команды ps в PC-BSD. Отметим, что сама команда ps находится в состоянии исполнения и bash ожидает некоторого события; этим событием в данном случае является прекращение работы потомка (т.е. самой команды ps, исполняемой в приоритетном режиме). NI отображает значение nice данного процесса; чем выше это значение, тем ниже значение приоритета для данного процесса. Вы можете отображать все приоритеты процессов с помощью опции -c. Поле SZ отображает полный размер (в страницах) данного процесса в виртуальной памяти. Вы можете отобразить сам размер страницы вашей системы выполнив команду pagesize. Как было показано ранее, размер страницы в нашей системе равен 4096 (или 4k) байт. Мы уже обсуждали остальные поля в самом выводе команды ps -ly ранее в данном разделе.

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

Таблица 10-4. Краткое описание общеупотребимых полей/ ключевых слов команды ps

Поле	Значение
CLS	Класс планирования: FSS: Fair share scheduling (справедливого распределения) FX: Fixed IA: Interactive RT: Real-time (времени исполнения) SYS: System SDC: System duty cycle (Рабочего цикла системы) TS: Time-sharing (Разделения времени)
LTIME	Время исполнения для LWP в отчёте
NI	Значение любезности: Само значение любезности процесса; ещё один параметр, применяемый при вычислении значения приоритета процесса
S	Состояние процесса: O: В настоящее время исполняемый в ЦПУ (или ядро) R: Готов к исполнению, пока не спланирован S: В состоянии сна в ожидании исполнения некоторого события T: Остановлен: фоновый, приостановленный, либо подлежащий отслеживанию W: Ожидающий использования ЦПУ ниже значения верхнего уровня Z: Процесс зомби (завершённый/ прерванный, но всё ещё использующий некоторые ресурсы ядра)
STIME	Время запуска процесса
SZ	Размер процесса в виртуальной памяти в страницах. Вы можете применить команду pagesize для определения значения размера страницы в своей системе.
TTY	Терминал: отображает название того терминала, к которому подключён данный процесс

$ ps -c -o pid,pri,opri,args
  PID PRI PRI COMMAND
20041  59  40  ps -c -o pid,pri,opri,args
20033  49  50  -bash
$
 	   

Вы можете применять имеющуюся опцию -t для отображения процессов, связанных с определённым терминалом, как это показано в последующем сеансе. Приводимая команда ps –eLP отображает все имеющиеся LWP, исполняемые в каждом процессе, а также те ЦПУ (показанные под PSR) на которых работают потоки, в нашем случае ЦПУ 0. Отметим, что sched имеет только один поток, а имеющийся процесс zpool -rp, который обрабатывает все запросы ZFS имеет 141 вилъдимый из ядра поток, исполняемый в нашей системе, как это показывается в выводе команды ps –eL | grep "zpool" | wc –l. Вывод команды ps –eL | wc -l показывает, что в настоящий момент в данной системе исполняется 146 LWP. Самая последняя команда в данном сеансе пказывает как вы можете применять опцию –o для отображения различных атрибутов обо всех исполняемых в данной системе процессах.

$ ps -t pts/2
  PID TTY        TIME CMD
 9624 pts/2      0:00 bash
$ ps -eLP
  PID   LWP PSR TTY        LTIME CMD
    0     1   0 ?           0:01 sched
    5     1   0 ?           0:00 zpool-rp
    5     2   0 ?           0:00 zpool-rp
    5     3   0 ?           0:00 zpool-rp
    5     4   0 ?           0:00 zpool-rp
    5     5   0 ?           0:00 zpool-rp
...
14079     1   0 ?           0:00 sshd
14069     1   0 pts/3       0:00 man
14076     1   0 pts/3       0:00 less
14105     1   0 pts/5       0:00 ps
$ ps -eL | grep "zpool" | wc -l
     141
$ ps -eL | wc –l
     416
$ ps -e -o user,uid,pid,ppid,pri,nice,vsz,rss,nlwp,args
    USER   UID   PID PPID PRI NI   VSZ  RSS NLWP COMMAND
    root     0     0    0  96 SY     0    0    1 sched
    root     0     5    0  99 SD     0    0  141 zpool-rpool
    root     0     6    0  99 SD     0    0    1 kmem_task
    root     0     1    0  59 20  3084 1964    1 /usr/sbin/init
    root     0     2    0  98 SY     0    0    2 pageout
    root     0     3    0  60 SY     0    0    1 fsflush
    root     0     7    0  60 SY     0    0    1 intrd
    root     0     8    0  60 SY     0    0    5 vmtasks
    root     0     9    0  99 SD     0    0    1 postwaittq
...
  sarwar  1007  9624 9621  49 20 10188 2300    1 -bash
    root     0  9620  516  59 20 16660 3892    1 /usr/lib/ssh/sshd
  sarwar  1007  9523 9522  59 20 19548 5420    1 /usr/lib/ssh/sshd
  sarwar  1007  9838 9624  59 20  9460 1556    1 ps -e -o
$
 	   

В Разделе 10.2 мы вкратце обсудили как работает планирование в UNIX SV. Здесь мы обсудим как работает планирование в PC-BSD и Solaris. В PC-BSD (т.е. во Free-BSD), все значения приоритетов находятся в диапазоне о 0 до 255. Пороговое значение установлено на 120. Приоритеты процессов пользователей в данной системе вычисляются каждые четыре такта часов (обычно 40 миллисекунд) при помощи следующей формулы:

значение приоритета = порог приоритета + значение любезности + (недавнее использование ЦПУ / 2)
 	   

Значения приоритета ниже пороговой величины, установленной на 120. Данное вычисление вызывает линейное уменьшение значения приоритета некоторого процесса на основании недавнего использования ЦПУ. Цифровой фильтр разложения (т.е. функции распада) применяется каждую секунду к самому последнему применению ЦПУ каждым процессом.

В отличии от более старых версий команд ps и top, которые сообщают приоритеты после вычитания из них 84, более новые версии этих команд все значения приоритетов в том виде, как они хранятся в самих структурах данных ядра, связанных с ним. Таблица 10.5 отображает все классы приоритетов, назначаемые различным категориям процессов/ потоков. Более высокое значение приоритета означает более низкий проритет. Значения класса ITHD служат для потоков, которые обрабатывают прерывания.

Таблица 10-5. Назначение диапазонов приоритетов и классов приоритетов различным категориям процессов/ потоков во FreeBSD

Категория процесса/ потока	Диапазон приоритета	Класс приоритета
Нижняя половина ядра (прерывания)	0-47	ITHD
Пользователь времени исполнения	48-79	REALTIME
Верхняя половина ядра (прерывания)	80-119	KERN
Пользователи с разделением времени	120-223	TIMESHARE
Простаивающие пользователи	224-255	IDLE

Все приоритеты потоков нижней половины ядра и потоков пользователей времени исполнения фиксированы и не подлежат изменению. Приоритеты для потоков самого ядра назначаются таким образом, чтобы вызывать минимальные задержки и предотвращать неограниченную блокировку. Далее, потоки нижней половины (прерывания) могут не допускать прерываний (выгрузки). Таким образом, выполнение потоков, исполняющихся в этих классах приоритета не может чередоваться. Однако, в зависимости от своей текущей загрузки ЦПУ, значения приоритетов пользовательских потоков могут изменяться со временем (увеличиваться или уменьшаться) во времени таким же образом, который описывался в Разделе 10.2. Это означает, что потоки пользовательского уровня могут перемещаться вверх и вниз между очередями, связанными с различными приоритетами. По этой причине мы говорим, что UNIX применяет многоуровневое планирование очередей с обратной связью (multilevel feedback queue scheduling). Множество потоков в очереди с самым высоким приоритетом планируются на основе FCFS.

Планирование ЦПУ в Solaris работает совершенно другим образом, причём в нём присуствтует множество одновременно исполняющихся планировщиков. Глобально имеется 170 значений проиритета; 0 является самым низким, а 169 самым высоким. Более высокое значение приоритета означает более высокий приоритет. В отличии от FreeBSD и большей части прочих систем UNIX, все потоки, включая некий поток ядра, являются выгружаемыми и поток с более высоким приоритетом может выгрузить некий поток с более низким приоритетом.Это позволяет потокам реального времени с высоким приоритетом выгружать потоки ядра. Таким образом, в системе с единственным процессором, никокое ядро или процесс с разделением по времени не исполняется в то время, когда в данной системе имеется процесс реального времени. Таблица 10.6 отображает все классы приоритетов, назначаемые различным категориям процессов/ потоков в Solaris.

Таблица 10-6. Назначение диапазонов приоритетов и классов приоритетов различным категориям процессов/ потоков в Solaris

Категория процесса/ потока	Диапазон приоритета	Класс приоритета
Нижняя половина ядра (прерывания)	160+
Время исполнения	100-159	RT
Сситема/ ядро	60-99	SYS
Интерактивные, разделение времени, фиксированные, справедливого распределения	0-59	IA, TS, FX, FSS

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

 

Упражнение 10.1

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

 

Упражнение 10.2

Исполните определённую команду для отображения всех состояний всех процессов исполняющихся в вашей системе. Какую команду ы исполнили? Каков её PID? Какое значение имеют PID предков всех имеющихся процессов?

Если вы желаете наблюдать за активностью ЦПУ и атрибутами процессов в реальном масштабе времени, вы можете воспользоваться командой top. Она отображает состояние наиболее загруженных в отношении ЦПУ процессов в данной системе при установленном по умолчанию поведении относительно следующих атрибутов процессов: PID, имени регистрации владельца, числа потоков в некотором процессе, приоритете процесса, значении любезности данного процесса, размере процесса в виртуальной памяти, резидентной части данного процесса (т.е. текущего размера процесса в имеющейся основной памяти), состоянии процесса, а также имени команды, использованного при вызове данного процесса. В PC-BSD данная команда помимо этого отображает общее число ЦПУ (или общее число ядер) с которым работает некий процесс (или поток). Запущенная команда top пока не будет нажата <q> или <Q> и продолжает обновлять своё состояние каждую секунду или около того в PC-BSD и каждые пять секунд в Solaris. Время периодического обновления может быть определено в опции командной строки при исполнении самой команды top или путём интерактивной команды при исполнении top. Общее число процессов, чьё состояние отображается зависит от размера применяемого экрана дисплея или размера окна в системах на основе GUI. В интеллектуальных дисплеях или окнах это обычно 15- 30 строк, по одной для процесса.

Данная команда также отображает некоторые важные статистики системы в коротком заголовке, составляющем 5- 8 строк, отображаемых перед самой статистикой всех процессов и/ или потоков. Такая информация заголовка зависит от варианта того UNIX, на котором исполняется данная команда. Общая информация в данном заголовке в PC-BSD и Solaris включает среднюю загруженность, время (дни+часы:минуты:секунды) в течении которого система поднята и работает, текущее время, число процессов в данной системе, число спящих процессов в системе, число процессов зомби, загруженность ЦПУ (процент времени простая, время пользователя, время ядра/ системы и время обработки прерываний), использование пользовательской области в основной памяти (общее и свободное), а также пространства подкачки (общего и свободного). Версия Solaris дополнительно отображает следующие числа на основе секунд: переключения контекста, ловушки, прерывания, системные вызовы, отказы страниц, подкачка памяти (в килобайтах) вверх и вниз, а также общее число дочерних процессов, создаваемых системными вызовами fork(2) и vfork(2) (обсуждаются в Главе 19). Версия PC-BSD также отображает самый последний использованный PID и текущую информацию виртуальной памяти (запрошенные страницы), включая общее число наиболее часто используемых (MFU, most frequently used) и наименее часто используемых (LFU, least frequently used) страниц. Текст заголовка в команде top в Mac OS X (Darwin) также содержит информацию обо всех резидентных (находящихся в памяти) совместных библиотеках, отказах страниц, входящем и исходящем сетевом обмене, а также дисковых операциях ввода/ вывода. Таблица 10.7 отображает отображает такие моментальные снимки заголовков команды top в PC-BSD, Solaris и Mac OS X (Darwin).

Таблица 10-7. Заголовки команды top для PC-BSD, Solaris и MacOS X

PC-BSD Version

last pid: 68271; load averages: 0.05, 0.18, 0.22 up 44+04:02:01 13:45:14 100 processes: 1 running, 98 sleeping, 1 zombie CPU: 0.0% user, 0.0% nice, 0.3% system, 0.1% interrupt, 99.6% idle Mem: 32M Active, 671M Inact, 1776M Wired, 1423M Free ARC: 1232M Total, 465M MFU, 342M MRU, 16K Anon, 142M Header, 283M Other Swap: 2048M Total, 2048M Free

Solaris Version

load averages: 0.00, 0.00, 0.00;           up 4+05:56:55 18:51:51 56 processes: 55 sleeping, 1 on cpu CPU states: 99.9% idle, 0.0% user, 0.1% kernel, 0.0% iowait, 0.0% swap Mem: 32M Active, 671M Inact, 1776M Wired, 1423M Free Kernel: 222 ctxsw, 523 intr, 51 syscall Memory: 4060M phys mem, 2980M free mem, 1024M total swap, 1024M free swap

MacOS X (Linux Darwin) Version

Processes: 75 total, 2 running, 73 sleeping, 372 threads     13:50:38 Load Avg: 0.26, 0.23, 0.18 CPU usage: 0.97% user, 1.45% sys, 97.57% idle SharedLibs: 4164K resident, 15M data, 0B linkedit. MemRegions: 8959 total, 680M resident, 21M private, 439M shared. PhysMem: 1220M wired, 965M active, 1142M inactive, 3327M used, 4863M free. VM: 158G vsize, 1043M framework vsize, 127404(0) pageins, 0(0) pageouts. Networks: packets: 21688/7786K in, 14229/3289K out. Disks: 68678/2474M read, 26190/2661M written.

Основные свойства команды top могут выбираться интерактивными командами при работе top. Приводимый ниже блок синтаксиса и Таблица 10.8 дают краткое описание ввода с клавиатуры для команды top в PC-BSD.

Таблица 10-8. Краткое описание интерактивного ввода с клавиатуры для top в PC-BSD

Команда	Значение
H	Отображает/ переключает статистики потоков в отдельные строки
P	Отображает/ переключает статистики загруженности ЦПУ для каждого ЦПУ
S	Отображает/ переключает процессы системы
^L	Обновление экрана
h или ?	Отображает краткую справку нажатий клавиш
k	Уничтожение процесса PID которого определён в разделяемом пробелами списке
n или #	Изменить число отображаемых процессов
o	Сортировать отображение по cpu, res, size, time и т.п.
r	Изменить значение любезности списка процессов разделённых пробелом PID
s	Изменить периодичность времени обновления (в секундах)
t	Переключить отображение смого процесса top
z	Переключить отображение простаивающих процессов

Команда top поддерживает все свойства своего аналога в PC-BSD. В большинстве одинаковы даже варианты интерактивного ввода с клавиатуры. В нескольких случаях интерактивные нажатия клавиш и опции символов слегка отличаются. Приводимые ниже синтаксис и Таблица 10.9 дают краткое описание интерактивного ввода с клавиатуры для команды top в Solaris.

Таблица 10-9. Краткое описание интерактивного ввода с клавиатуры для top в Solaris

Команда	Значение
H или t	Переключает отображение потоков в отдельные строки
M	Сортировать отображение по использованию памяти (аналогично исполнению команды top –o size)
N	Сортировать отображение по PID (аналогично исполнению команды top –o pid)
P	Сортировать отображение по загруженности ЦПУ (аналогично исполнению команды top –o cpu)
T	Сортировать отображение по времени ЦПУ (аналогично исполнению команды top –o time)
h или ?	Отображает краткую справку интерактивных нажатий клавиш
k	Уничтожение процесса PID которого определён в разделяемом пробелами списке
n или #	Изменить число отображаемых процессов
r	Изменить значение любезности списка процессов разделённых пробелом PID
s	Изменить периодичность времени обновления (в секундах)

Мы отобразим некоторые примеры сеансов команды top вначале для PC-BSD, так как большая часть опций и клавиатурного ввода в обеих системах общие. Почти все не совпадающие варианты и нажатия клавиш имеют различные буквенные обозначения, но производят одни и те же функции. Ниже приводится исполнение без каких- либо параметров. Вывод такой команды показывает, что данная система исполняется на протяжении 33 дней без крушений. Самым последним назначенным PID является 75597. Далее, в настоящее время в данной системе 106 процессов с одним исполняемым, 104 в спящем режиме и одним с состоянием зомби. В правом верхнем углу приводится текущее время, которое обновляется при всяком обновлении вывода top. Демон MySQL (mysqld), которым владеет david является вторым процессом с наивысшим приоритетом после top. Он имеет 41 поток, занимает размер 207М байт, из которых 43.552M расположено в основной памяти, а также исполнялся на протяжении 55 минут и 45 секунд. Вы можете оценить прочие значения в данном заголовке и атрибуты всех процессов, воспользовавшись Таблицей 10.10. Если вы слегка подольше поизучаете вывод, вы отметите, что все процессы перемещаются вверх и вниз по мере изменения их приоритетов. Аналогично, все статистики также периодически меняются в самом заголовке.

% top
last pid: 75597;  load averages:  0.19,  0.25,  0.22   up
32+21:31:09 07:14:21
106 processes: 1 running, 104 sleeping, 1 zombie
CPU: 0.1% user, 0.0% nice, 2.6% system, 0.2% interrupt, 97.1% idle
Mem: 38M Active, 662M Inact, 1287M Wired, 592K Cache, 1914M Free
ARC: 931M Total, 374M MFU, 331M MRU, 16K Anon, 139M Header, 86M Other
Swap: 2048M Total, 2048M Free
  PID USERNAME    THR PRI NICE  SIZE    RES STATE    C   TIME  WCPU COMMAND
75567 sarwar       1  20    0 19772K  2852K  CPU2    2   0:00 0.98% top
 2355 david       41  20    0   207M 43552K  sbwait  1  55:45 0.00% mysqld
 1445 root         1  20    0 14404K  1812K  select  1  51:28 0.00% powerd
 1808 haldaemon    2  20    0 63524K  8148K  select  2  29:17 0.00% hald
 1853 root         1  20    0 23264K  2668K  select  1  23:43 0.00% hald-addon-storage
 2460 malik        6  39   19 88284K 48720K  uwait   0  22:06 0.00% virtuoso-t
 2200 malik        5  52    0   202M 30772K  select  1  15:38 0.00% pc-systemupdatertra
 2339 malik        4  49    0   906M   141M  select  3  14:12 0.00% kdeinit4
 1496 root         1  27    0 12268K  1720K  nanslp  0   9:52 0.00% swapexd
 1442 root         1  20    0 25340K  3652K  select  3   7:29 0.00% ntpd
 1742 root         1  20    0 60832K  6068K  select  0   1:38 0.00% sshd
 1233 root         1  20    0 14428K  1872K  select  1   1:04 0.00% syslogd
 2387 root         2  25    0   192M 28116K  select  3   0:55 0.00% pc-mounttray
 2436 malik        1  20    0   449M 68736K  select  1   0:41 0.00% korgac
 1745 root         1  20    0 16524K  2072K  nanslp  1   0:31 0.00% cron
 1703 root         1  20    0 64328K 13632K  select  1   0:29 0.00% python2.7
 	   

Таблица 10-10. Краткое описание различных полей вывода команды top

Поле	Значение
up	Время работы системы: Общее время (дни+часы:минуты:секунды), которое данная система исполнялась без отключения
CPU	Загрузка ЦПУ: Процентное значение для времён пользователя, любезности, системы, обработки прерываний и простоя
Mem	Физическая память: Активная, пассивная, зашитая (включая уровень BIO данных и кода), кэш, буфер (число байт, используемое для дискового кэширования уровня BIO), свободной
ARC	Кэш адаптивного замещения (ARC, Adaptive replacement cache): Алгоритм замены страниц с лучшей производительностью нежели алгоритм самого последнего использования (LRU, the least recently used), байты MRU (most recently used, самые последние использованные), байты MFU (most frequently used, наиболее часто используемые), байты заголовка и различные прочие быйты
Swap	Пространство подкачки: Общий отложенный на вермя набор и свободный (не используемый) в настоящее время
PID или ?	Идентификатор данного процесса
USERNAME	Имя владельца данного процесса
THR	Threads: Число потоков данного процесса
PRI	Priority: Значение приоритета некоторого процесса, которое прдписано на момент процесса планирования; чем меньше значение данного приоритета, тем выше его приоритет
NICE	Nice value: величина значения любезности; ещё один параметр, применяемый при вычислении значения приоритета процесса. Диапазон его значения от -20 до 19 (20 в Solaris и некоторых прочих системах UNIX)
SIZE	Size: Размер самого образа памяти некоторого процесса (текст, данные и стек) в килобайтах
RES	Резидентная память: Текущий объём пакмяти процесса в килобайтах, который располагается в физической оперативной памяти
STATE	Состояние процесса: Текущее состояние данного процесса - например, запущен, в состоянии сна, исполняется (либо CPUn, например, CPU2 для систем с симметричной многопроцессорностью [SMP]), простаивает, зомби, остановлен, в ожидании, заблокирован - либо то текущее событие, которого дожидаются данные процессы - например, выбора (ожидание системного вызова select для возврата)
C	CPU number: Номер того ЦПУ, на котором исполняется данный процесс - например, 2 означает CPU2. Нумерация начинается с 0
TIME	Время работы процесса: Общий объём времени (минуты:секунды), на протяжении которого исполняется данный процесс, за исключением времени ожидания в очереди или ожидания устройств ввода/ вывода
WCPU	Взвешенная загрузка ЦПУ: Последнее использование ЦПУ, некий параметр, применяемый для вычисления приоритета процесса в целях планирования
COMMAND	Command: Перечень той команды, которая применялась для запуска данного процесса. Опция -f необходима для просмотра всей команды в System V UNIX; в противном случае отображается только самый последний компонент из всего имени пути.

Вы можете взаимодействовать с top пока она исполняется применяя различные интерактивные нажатия с клавиатуры. Вы можете нажать h для отображения различных возможных клавиатурных вводов, которые позволят вам взаимодействовать с top. Когда вы применяете интерактивные команды, top предлагает вам ответить на один или более вопросов, относящихся к той обыденной работе, которую вы желаете выполнить Например, когда вы нажимаете n, top запрашивает у вас общее число процессов для отображения. Вы вводите нужное число и давите на клавишу <Enter> чтобы top начал отображать информацию о запрошенном числе процессов. Аналогично, если вы хотите завершить некий процесс, нажмите k и top запросит у вас PID того процесса, который подлежит прекращению. Вы вводите PID данного процесса и жмёте <Enter> чтобы top завершил этот процесс. Поэтому, если вы желаете отобразить состояние всех процессов, используемых пользователем bob в реальном масштабе времени, вы нажимаете u и вводите имя регистрации для этого пользователя. Следующий вывод отображает мониторинг процессов bob.

...
ARC: 931M Total, 374M MFU, 331M MRU, 16K Anon, 139M Header, 86M
Other
Swap: 2048M Total, 2048M Free
Username to show: bob
  PID USERNAME THR PRI NICE   SIZE   RES   STATE   C   TIME   WCPU COMMAND
78800 bob        1  20    0 19772K 2876K   CPU0    0   0:01  0.59% top
73317 bob        1  36    0 25548K 3904K   pause   3   0:00  0.00% csh
78671 bob        1  20    0 86100K 6948K   select  3   0:00  0.00% sshd
73450 bob        1  21    0 14788K 2632K   ttyin   2   0:00  0.00% more
 	   

Если вы желаете чтобы top отобразила статистики ЦПУ для каждого ЦПУ, вы нажимаете P. Последующий вывод отображает статистики четырёх ЦПУ (или ядер) в вашей системе, CPU0-CPU3.

last pid: 80939; load averages: 0.25, 0.29, 0.28 up
32+22:35:07 08:18:19
116 processes: 1 running, 114 sleeping, 1 zombie
CPU 0:  0.4% user,  0.0% nice,  0.7% system,  0.0% interrupt, 98.9% idle
CPU 1:  0.4% user,  0.0% nice,  8.8% system,  0.0% interrupt, 90.8% idle
CPU 2:  0.0% user,  0.0% nice,  0.7% system,  0.4% interrupt, 98.9% idle
CPU 3:  0.0% user,  0.0% nice,  0.7% system,  0.0% interrupt, 99.3% idle
Mem: 47M Active, 663M Inact, 1289M Wired, 592K Cache, 1902M Free
ARC: 931M Total, 374M MFU, 331M MRU, 16K Anon, 139M Header, 86M Other
Swap: 2048M Total, 2048M Free
<P>
  PID USERNAME  THR PRI NICE    SIZE    RES STATE   C   TIME   WCPU COMMAND
80921 sarwar      1  20    0  19772K  3032K CPU1    1   0:00  0.78% top
 2355 malik      41  20    0    207M 43552K sbwait  1  55:50  0.00% mysqld
 1445 root        1  20    0  14404K  1812K select  3  51:33  0.00% powerd
 1808 haldaemon   2  20    0  63524K  8148K select  2  29:20  0.00% hald
 1853 root        1  20    0  23264K  2668K select  3  23:45  0.00% hald-addo
...
 	   

В следующем сеансе мы покажем, что вы можете отображать процессы системы нажатием S. Отметим, что наш процесс kernel имеет 170 видимых из ядра потоков. Процесс idle исполняется когда в данной системе нет никаких процессов для исполнения. Определённая система переходит в состояние простоя (idle) при возникновении прерывания - например, некий пользователь нажимает какую -то клавишу на клавиатуре или поступает тактовый сигнал от часов.

...
ARC: 931M Total, 374M MFU, 331M MRU, 16K Anon, 139M Header, 86M Other
Swap: 2048M Total, 2048M Free
<S>
  PID USERNAME THR PRI NICE    SIZE    RES STATE   C   TIME    WCPU COMMAND
   11 root       4 155 ki31      0K    64K CPU3    3 3129.1 400.00% idle
80921 sarwar     1  20    0  19772K  3032K CPU0    0   0:03   0.59% top
   21 root       1  16    -      0K    16K syncer  3 106:34   0.29% syncer
   12 root      24 -84    -      0K   384K WAIT    3 384:39   0.00% intr
    0 root     170   8    0      0K  2720K -       3 307:24   0.00% kernel
    4 root       5  -8    -      0K    96K tx->tx  2  72:46   0.00% zfskern
   14 root       1 -16    -      0K    16K -       2  64:36   0.00% rand_harv
...
 	   

Теперь мы покажем пример исполнения top на машине Solaris. Как вы можете обнаружить, данная система находилась в работе на протяжении почти шести дней и в настоящее время имеет 59 процессов с 1 использующим ЦПУ и остальными 58 в спящем режиме (т.е. ожидающими возникновения некоторого события). Далее, последующие события ядра происходят на протяжении самой последней единственной секунды: 215 переключений контекста, 187 захватов, 500 прерываний, 342 системных вызова и 149 отказа страниц. Статистики самого ЦПУ, основной памяти и пространства подкачки отображаются некоторым образом, аналогичным выводу команды top в PC-BSD. Наконец, отметим, что NWLP в третьей колонке отображённых статистик о исполняемых в настоящий момент приложениях служит для общего числа LWP и эквивалентно THD (потокам) отображаемым в выводе команды top для PC-BSD. Демон хозяина запуска средств управления службами (SVC, Service Management Facility) - svc.startd - и демон настройки SVC - svc.configd - имеют, соответственно, 12 и 23 связанных с ними LWP.

$ top
load averages:  0.00,  0.00,  0.00;       up 5+23:32:07   12:27:03
59 processes: 58 sleeping, 1 on cpu
CPU states: 99.9% idle,  0.0% user,  0.2% kernel,  0.0% iowait, 0.0% swap
Kernel: 215 ctxsw, 187 trap, 500 intr, 342 syscall, 149 flt
Memory: 4060M phys mem, 2970M free mem, 1024M total swap, 1024M free swap
   PID USERNAME NLWP PRI NICE  SIZE   RES STATE    TIME    CPU COMMAND
 15538 sarwar      1  59    0   10M 2292K sleep    0:00  0.01% bash
 15548 sarwar      1  59    0 4208K 2460K cpu/1    0:00  0.01% top
 15537 sarwar      1  59    0   19M 5432K sleep    0:00  0.01% sshd
  1215 smmsp       1  59    0 7020K 1472K sleep    0:00  0.00% sendmail
    13 root       12  59    0   37M   29M sleep    0:06  0.00% svc.startd
    86 root        1  59    0 9760K 1060K sleep    0:03  0.00% in.mpathd
 15543 sarwar      1  59    0   19M 5448K sleep    0:00  0.00% sshd
   567 root       28  59    0   98M   16M sleep    0:06  0.00% fmd
    47 root        9  59    0 4332K 2792K sleep    0:02  0.00% dlmgmtd
   845 root        4  59    0 3228K 1408K sleep    0:02  0.00% devchassisd
    15 root       23  59    0   20M   19M sleep    0:18  0.00% svc.configd
    76 netadm      6  59    0 4476K 2768K sleep    0:07  0.00% ipmgmtd
   213 root        6  59    0   13M 3676K sleep    0:02  0.00% devfsadm
  1217 root        1  59    0 7016K 1840K sleep    0:03  0.00% sendmail
...
 	   

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

 

Упражнение 10.3

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

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

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

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

Процессы фонового режима исполняются с более низким приоритетом в сравнении со своими аналогами переднего плана. Таким образом они получают в пользование ЦПУ только когда нет процесса с более высоким приоритетом, которому он требуется. Когда некий процесс фонового режима генерирует вывод, который он отправляет на экран своего дисплея, такой экран выглядит как замусоренный, однако если вы одновременно используете другое приложение, ваша работа остаётся в любом случае неизменной. Вы можете выйти из этого приложения и затем вернуться обратно в него, получив очищенное окно. Некоторые приложения, такие как vim, позволяют вам повторно выводить экран не покидая их. В vim (см. Главу 3) нажатие <Ctrl+L> в командном режиме позволяет вам сделать это.

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

Теперь рассмотрим следующую команду, исполняемую в оболочке Bourne. Она осуществляет поиск целой файловой структуры в некотором файле с названием foo и сохраняет все имена путей, которые содержат этот файл в определённом файле foo.paths. Все сообщения об ошибках отправляются в файл /dev/null, который в UNIX является чёрной дырой: что либо попавшее туда никогда не возвращается. Отметим, что для оболочки C 2> необходимо заменить на >&. Эта команда займёт несколько минут, а возможно и часов, в зависимости от самого размера всей файловой структуры, загруженности системы (в терминах общего числа зарегистрированных в ней пользователей), а также общего числа исполняемых в этой системе процессов. Итак, если вы хотите выполнять некоторую другую работу в своей системе пока исполняется данная команда, вы не можете делать это, так как данная команда исполняется в режиме переднего плана (приоритетном).

$ find / -name foo -print > foo.paths 2> /dev/null
...
$
 	   

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

$ find / -name foo -print > foo.paths 2> /dev/null &
[1] 23467
$
 	   

Численное значение в квадратных скобках возвращается самой оболочкой и является номером задания (также называемое идентификатором задания, job ID) для данного процесса; другой номер является значением PID для данного процесса. В нашем случае номер задания для команды find равен 1, а значение PID 23467. Некое задание является процессом, который не исполняется в приоритетном режиме (переднего плана) и доступен только на том терминале, с которым он связан. Такой процесс обычно работает на заднем плане или является приостановленным процессом.

Команды, выполняющие задачи, которые не привлекают вмешательства со стороны пользователя и имеют длительное время до окончания являются хорошими претендентами на исполнение в фоновом режиме. Некоторыми примерами являются сортировка больших файлов (команда sort), программы громоздких компиляций find (cc, gcc, CC, make и т.п.), программы интенсивных вычислений, например как те, которые определяют является ли большое число простым, а также поиск в больших файловых структурах одного или более файлов (команда find). Команды, которые имеют терминальный ввод/ вывод, например редактор vim, конечно, не являются достойными кандидатами для исполнения в фоновом режиме. Основная причина состоит в том, что когда такая команда исполняется в фоновом режиме, она перестаёт принимать ввод с клавиатуры. Эта команда должна вернуться обратно в приоритетный режим прежде чем она начнёт исполняться вновь. Команда fg позволяет вам перевести некий процесс фонового режима в приоритетный режим (переднего плана).

При исполнении некоторой команды в приоритетном режиме вам может понадобиться приостановить (suspend) её чтобы вернуться обратно в саму оболочку, выполнить что- то в данной обоолчке и затем вернуться к такому приостановленному процессу. Например, скажем, вы находитесь в самой середине изменения программного файла C в vim и вам необходимо скомпилировать определённую программу чтобы определить исправлены ли определённые ошибки. Вы можете сохранить изменения в этом файле, приостановить vim, скомпилировать необходимую программ чтобы просмостреть полученные результаты такой компиляции и вернуться в vim. Вы можете приостановить приоритетный процесс нажав <Ctrl+Z>, переместить некий приостановленный процесс в приоритетный режим применив команду fg, а также переместить приостановленный процесс в фоновый режим с помощью команды bg. Поэтому вы можете приостановить vim нажав <Ctrl+Z>, откомпилировать данную программу чтобы проверить наличие каких- либо ошибок и восстановить данный приостановленный сеанс воспользовавшись командой fg.

Если у вас имеется множество приостановленных процессов, команда fg без параметра переведёт текущий процесс в его приоритетный режим, в команда bg без аргументов восстановит исполнение текущего процесса в его фоновый режим. То задание, которое использует ЦПУ в любой определённый момент называется текущим заданием.

Вы можете применить команду jobs для отображения номеров заданий всех приостановленных (остановленных) и фоновых процессов и идентифицировать какой из них является текущим процессом. Текущий процесс указывается +, а предыдущий процесс - в выводе команды jobs. Ниже приводится краткое описание этой команды.

В последующих сеансах мы покажем как применять команды fg, bg, <Ctrl+Z> и jobs. Мы выполним команды sort и cp в их фоновом режиме. Пары jobID и PID для этих процессов равны [1] 60149 и [2] 60156 для соответствующих команд sort и cp. Команда sort bigdata является исполняемым в настоящее время процессом/ заданием, что отображается в выводе команд jobs и jobs -l, также как и само состояние R данного процесса в выводе самой команды ps. Команда cp bigdata bigdata1 была выгружена в файл подкачки на диск, на что указывает состояние D данного процесса в выводе команды ps.

% sort bigdata > bigdata.sorted &
[1] 60149
% cp bigdata bigdata1 &
[2] 60156
% ps
  PID TT  STAT     TIME COMMAND
56222  1  Ss    0:00.67 -csh (csh)
60149  1  R     0:07.94 sort bigdata
60156  1  S     0:00.00 -csh (csh)
60157  1  D     0:00.34 cp bigdata bigdata1
60164  1  R+    0:00.00 ps
% jobs
[1]  + Running                sort bigdata > bigdata.sorted
[2]  - Running                cp bigdata bigdata1
% jobs -l
[1]  + 60149 Running                sort bigdata > bigdata.sorted
[2]  - 60156 Running                cp bigdata bigdata1
%
 	   

В следующем сеансе самая первая команда fgпереводит текущее задание в приоритетный режим. Команда fg %2 переводит задание номер 2 в его приоритетный режим. Некая строка, которая уникально указывает задание также может быть применена на месте номера задания. Такая строка заключается в двойные кавычки, если имеет внутри себя пробелы. Третья команда fg демонстрирует такое преобразование. Команда jobs -l, как и ожидалось, показывает оба задания как приостановленные. Вывод команды ps показывает, что состоянием команды cp bigdata bigdata1 является TW, что означает, что данный процесс был приостановлен и временно выгружен в файл подкачки на диск. Мы применяем команду bg %1 %2 для запуска исполнения в фоновом режиме своих обоих приостановленных процессов. Позже мы подтверждаем это состояние воспользовавшись командой jobs, которая отображает оба процесса как исполняющиеся, причём процесс sort в настоящий момент использует ЦПУ. Мы также показываем, что команда bg без аргументов помещает текущий (или единственный приостановленный) процесс в фоновый режим. Команда ps -p 60149 показывает, что процесс sort находится в состоянии исполнения и пребывает в данной системе на протяжении 11 минут и 3.78 секунд.

% fg
sort bigdata > bigdata.sorted
<Ctrl+Z>
Suspended
% fg %2
cp bigdata bigdata1
<Ctrl+Z>
Suspended
% fg %"sort"
sort bigdata > bigdata.sorted
<Ctrl+Z>
Suspended
% jobs -l
[1]  + 60149 Suspended                 sort bigdata > bigdata.sorted
[2]  - 60156 Suspended                 cp bigdata bigdata1
% ps
  PID TT  STAT    TIME COMMAND
56222  1  Ss   0:00.96 -csh (csh)
60149  1  T    0:29.29 sort bigdata
60156  1  TW   0:00.00 -csh (csh)
60157  1  TW   0:00.00 cp bigdata bigdata1
61261  1  R+   0:00.02 ps
% bg %1 %2
[1]    sort bigdata > bigdata.sorted &
[2]    cp bigdata bigdata1 &
% jobs
[1]  + Running                         sort bigdata > bigdata.sorted
[2]  - Running                         cp bigdata bigdata1
% fg %1
sort bigdata > bigdata.sorted
<Ctrl+Z>
Suspended
% bg
[1]    sort bigdata > bigdata.sorted &
% jobs
[1]  + Running                         sort bigdata > bigdata.sorted
[2]  - Running                         cp bigdata bigdata1
% ps -p 60149
  PID TT  STAT     TIME COMMAND
60149  2  R    11:03.78 sort bigdata
%
 	   

Как уже обсуждалось ранее в этом разделе, мы рассмотрим последующие сеансы как некоторый дополнительный пример чтобы пояснить работу команд fg и <Ctrl+Z>. Команда gcc -o lab8 lab8.c применяется для компиляции программы C из файла lab8.c и помещения исполняемого файла под названием lab8. Понимание того что из себя представляет компиляция не обсуждается здесь, а более полное обсуждение самих синтаксиса и семантики команды gсс представлены в Главе 17. Здесь мы просто подчёркиваем тот факт, что процессы, которые занимают много времени или те, которые исполняются продолжительный объём времени обычно являются хорошими претендентами на то чтобы быть приостановленными. Данный пример приостановки команды vim представлен только для иллюстрации. Вся последовательность событий отображается в следующем сеансе. Отметим, что вывод команды ps после vim был приостановлен, что отображает состояние vim в виде T, что означает что vim был приостановлен/ остановлен.

% ps
  PID TT  STAT    TIME COMMAND
  587  1  Ss   0:00.17 -csh (csh)
  616  1  R+   0:00.00 ps
% vim lab8.c
#include <stdio.h>
#define SIZE 100
int main (int argc, char *argv[])
{
...
<Ctrl+Z>
Suspended
% ps
  PID TT  STAT    TIME COMMAND
  587  1  Ss   0:00.41 -csh (csh)
  812  1  T    0:00.13 vim lab8.c
 1035  1  R+   0:00.02 ps
% gcc -o lab8 lab8.c
% fg %1
#include <stdio.h>
#define SIZE 100
main (int argc, char *argv[])
{
...
:q!
%
 	   

В последующем упражнении данной главы вы попрактикуетесь в создании приоритетных и фоновых процессов и управлении ними с применением команд bg, fg и jobs.

 

Упражнение 10.4

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

Хотя любой работающий в фоновом режиме процесс может быть назван демоном, в жаргоне UNIX демоном называется некий системный процесс, работающий в фоновом режиме. Демоны часто используются в UNIX для предложения различных видов служб пользователям или для исполнения программного обеспечения и обработки задач администрирования. Например, печать, регистрация в системе, электронная почта, просмотр веб, удалённая регистрация через безопасную оболочку, обмен файлами, взаимодействие на площадках социальных сетей, а также службы учётных записей все они предоставляются через демоны. Службы печати предоставляются через демон печати lpd. Службы учётных записей Finger (см. Главу 11) обрабатываются демоном finger fingerd. Демон inetd, обычно называемый суперсервером UNIX обрабатывает различные относящиеся к Интернету службы, порождая соответствующие демоны серверов во время загрузки системы. Получите доступ к файлу /etc/inetd.conf для просмотра всех служб, предлагаемых данным демоном в вашей системе. Этот файл имеет по одной строке для каждой службы, предлагаемой inetd.

Вы можете набрать множество команд в одной командной строке для определённого последовательного и/ или параллельного исполнения этих команд. Ниже приводится краткое описание такого синтаксиса для последовательного исполнения команд, определяемых в одной командной строке.

Отметим, что точка с запятой применяется как разделитель команд и, по этой причине, не следует за самой последней командой. Никакие пробелы не требуются до и после точки с запятой, но вы можете применять пробельные символы для ясности. Эти команды исполняются одна после другой, в том порядке как они набраны в отдельной строке. В приводимом далее сеансе команды date и echo исполняются последовательно как отдельные процессы. Самый первый сеанс исполняется в оболочке C PC-BSD, а второй работает в Bash Solaris. Отметим разницу между выводами для команды date в этих двух системах.

% date; echo Hello, World!
Sat Sep 20 10:27:50 PKT 2014
Hello, World!
%

$ date; echo Hello, World!
Saturday, September 20, 2014 10:29:05 PM PKT
Hello, World!
$
 	   

Вы можете определить одновременное исполнение команд в командной строке завершив каждую команду амперсандом (&). Та команда, которая завершается с & помимо всего прочего исполняется в фоновом режиме. Никакие пробелы не требуются до и после &, новы можете применять пробельные символы для ясности. Когда вы исполняете некую команду в фоновом режиме, ваша оболочка отображает следующую пару в качестве вывода: [jobID] PID, где самый первый идентификатор задания равен 1, линейно увеличиваясь путём добавления единицы к следующему используемому идентификатору задания. Как и PID, идентификаторы заданий могут повторно использоваться, если в настоящий момент нет назначенных для некоторого процесса. Ниже приводится краткое описание синтаксиса одновременного исполнения команд оболочки, определяемое в одной командной строке.

Последующие сеансы исполнялись в PC-BSD под оболочкой C и в Solaris под Bash, соответственно. Команды date и echo исполняются одновременно в своих фоновых режимах, после чего последовательно исполняются команды uname и who в приоритетном режиме. В общем случае, так как данная команда who исполняется в самом конце, её вывод всегда отображается последним. Все выводы остальных трёх команд (date, echo и uname) могут отображаться в любой последовательности. Данный порядок обусловлен самим планированием процессов и общим объёмом времени, которое занимает исполнение. Таким образом, тот же самый порядок вывода может воспроизводится, а может и нет если вы выполните эту командную строку вновь. В следующем сеансе все выводы отображаются в порядке echo, uname, date и who для PC- BSD и echo, date, uname и who для Solaris. Пары идентификаторов задания и процесса команд date и echo равны, соответственно [1] 15167 и [2] 15168 в PC-BSD. Аналогично, пары идентификаторов задания и процесса команд date и echo в Solaris равны, соответственно, [1] 6802 и [2] 6803.

% date& echo Hello, World!& uname; who
[1] 15167
[2] 15168
Hello, World!
FreeBSD
Sat Sep 20 10:31:51 PKT 2014
malik            pts/0         Aug 14 09:45 (:0)
sarwar           pts/1         Sep 20 10:27 (statichost202-147-168-98.link.net.pk)
[2]  + Done                           echo Hello, World!
[1]  + Done                           date
%

$ date& echo Hello, World\!& uname; who
[1] 6802
[2] 6803
Hello, World!
Saturday, September 20, 2014 03:35:57 PM PKT
SunOS
[1]- Done                     date
[2]+ Done                     echo Hello, World\!
root       console      Sep 19 17:13
sarwar     pts/1        Sep 20 15:30 (statichost202-147-168-98.link.net.pk)
$
 	   

Самый последний & в некоторой командной строке размещает сразу все команды, так как все предыдущие & пребывают в одном процессе. В следующей командной строке, вследствие этого, команда date исполняется как один процесс, а все остальные команды в who; whoami; uname; echo Hello, World!& как другой процесс. Соответствующие пары идентификаторов для задания и процесса для полученных таким образом процессов равны [1] 49380 и [2] 49381 в PC-PSD.

% date & who ; whoami ; uname ; echo Hello, World! &
[1] 49380
[2] 49381
[sarwar@pcbsd-srv] ~/unix3e/ch10% Sat Sep 20 17:49:58 PKT 2014
malik            pts/0        Aug 14 09:45 (:0)
sarwar           pts/1        Sep 20 17:45 (182.178.199.200)
malik            pts/2        Sep 20 10:59 (:0)
sarwar
FreeBSD
Hello, World!
<Enter>
[2]    Done             ( who; whoami; uname; echo Hello, World! )
[1]  + Done              date
%
 	   

Как показывается в следующем сеансе, когда исполнение идёт в Solaris, соответствующие пары идентификаторов задания и процесса для таких двух процессов равны [1] 7540 и [1] 7544. Отметим, что в то время как идентификаторами задания для двух заданий в PC-BSD являются 1 и 2, в Solaris они оба равны 1. Далее, определённые идентификаторы для двух наших процессов в PC-BSD являются последовательными числами, в то время как они не являются последовательными для Solaris. Это означает, что под PC-BSD такие процессы были созданы сразу один за другим и были назначены последовательные идентификаторы заданий и последовательные идентификаторы процессов. С другой стороны, после создания процесса date, в нашей командной строке были созданы три других процесса с идентификаторами процессов 7541, 7542 и 7543 перед тем как в нашей командной строке был создан сам второй процесс. Это объясняет что оба наших процесса получили каждый идентификатор задания 1. Отметим, что мы заменили '! в нашей команде echo на \! в Bash Solaris. Наконец, как отображено в теневых областях обоих сеансов, так как приглашение оболочки возвращается в обеих системах после того, как данные два процесса (задания) были созданы, однако до того как какой- нибудь или любой вывод был отображён на данном экране, нам пришлось нажать на клавишу <Enter> для отображения данного приглашения оболочки вновь.

$ date & who; whoami; uname; echo Hello, World\! &
[1] 7540
Saturday, September 20, 2014 10:54:27 PM PKT
root       console      Sep 19 17:13
sarwar     pts/1        Sep 20 22:48 (182.178.199.200)
[1]+  Done                    date
sarwar
SunOS
[1] 7544
$ Hello, World!
<Enter>
[1]+  Done                    echo Hello, World\!
$
 	   

Как вкратце будет обсуждено в Главе 12, UNIX позволяет вам группировать команды и исполнять их как один процесс разделяя команды с помощью точки с запятой и заключая их в скобки. Это имеет название группирования команд (command grouping). Так как все команды в некоторой группе команд исполняются как некий отдельный процесс, они все исполняются в одной и той же подоболочке. Однако, все эти команды исполняются последовательно, одна за другой. Ниже приводится краткое описание синтаксиса группирования команд.

В следующем сеансе, по этой причине, команды date и echo исполняются последовательно, но как один процесс.

% (date; echo Hello, World!)
Sat Sep 20 22:14:52 PKT 2014
Hello, World!
%
 	   

Вы можете объединять команды, группируя последовательное исплнение путём разделения групп команд с другими командами или группами команд. В нашем следующем сеансе команды date и echo исполняются как один процесс, а вслед за ними исполняется команда who как отдельный процесс.

% (date; echo Hello, World!); who
Sun Sep 21 08:05:55 PKT 2014
Hello, World!
root             pts/0        Aug 14 09:45 (:0)
sarwar           pts/1        Sep 21 08:05 (39.59.18.169)
malik            pts/2        Sep 20 10:59 (:0)
%
 	   

Группы команд могут встраиваться. Сделовательно ((date; echo Hello, World!); who) и ((date; echo Hello, World!); (who; uname)) являются допустимыми командами и предоставляют ожидаемые результаты. Группирование команд становится более существенным когда группы исполняются как отдельные процессы, как это показано в сеансе далее.

% (date ; echo Hello, World!)&
[1] 40563
% Sun Sep 21 08:08:42 PKT 2014
Hello, World!
[1]                                  Done ( date; echo Hello, World! )
% (date; echo Hello, World)& (who; uname)& whoami
[1] 40936
[2] 40938
Sun Sep 21 08:12:30 PKT 2014
Hello, World
malik            pts/0        Aug 14 09:45 (:0)
sarwar           pts/1        Sep 21 08:05 (39.59.18.169)
malik            pts/2        Sep 20 10:59 (:0)
sarwar
[1]  - Done                          ( date; echo Hello, World )
FreeBSD
% <Enter>
[2]    Done                          ( who; uname )
%
 	   

Во второй группе команд, (date; echo Hello, World!) и (who; uname) исполняются в фоновом режиме, команда whoami исполняется в приоритетном режиме; все три команды исполняются одновременно. Опять же, сам порядок вывода зависим от планирования этих команд.

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

 

Упражнение 10.5

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

 

Упражнение 10.6

Какие из следующих команд исполняются последовательно, а какие одновременно? Сколько процессов исполняется одновременно? (who; date) & (cat temp; uname & whoami)

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

Вы можете прекратить приоритетный процесс нажатием <Ctrl+C> или применив команду kill из другой оболочки. Вы можете прекратить некий фоновый процесс одним из двух способов: (1) применив команду kill или (2) вначале переведя процесс в приоритетный режим (переднего плана) воспользовавшись командой fg, а затем нажав <Ctrl+C>. Самая первостепенная задача такой команды kill состоит в отправке сигнала (также имеющего название программного прерывания) некоторому процессу. Операционная система UNIX применяет сигналы для привлечения внимания к некоторому процессу. Вы можете отправить один из различных типов сигналов поддерживаемых вашей системой UNIX некоторому процессу, которым вы владеете или имеете полномочия для выполнения этого. Процесс может по получению некоторого сигнала предпринять три действия:

Для большинства сигналов, установленное по умолчанию действие, в добавление к некоторым прочим событиям, всегда приводит к прекращению данного процесса. Игнорирование сигнала не оказывает никакого воздействия на данный процесс. Определяемое пользователем действие описывается как некое программное выражение (обычно вызов функции), которое принимает управление в определённой части кода в данном процессе. В некотором сценарии оболочки вы можете определить такое действие воспользовавшись командой trap в своей оболочке Bourne. Оболочка C предоставляет ограниченную обработку сигналов через команду onintr. В некоторой программе на C вы можете определить эти действия воспользовавшись библиотечным вызовом signal. Мы обсудим данные команды trap и onintr подробнее в Главах 13 и 15, соответственно. В Главе 19 мы подробно обсудим системный вызов signal(2). Для быстрого ознакомления просмотрите странице руководства воспользовавшись командой man signal или man 3 signal в PC-BSD или системе Solaris. В PC-BSD также можно применить команду man –S3 signal.

Сигналы могут создаваться по различным причинам. Процессы сами по себе вызывают некоторые из этих причин, в то время как остальные являются внешними по отношению к процессам. Некий сигнал, вызываемый каким- то событием, внутренним по отношению к процессу именуется внутренним сигналом, или некой схемой прерывания (trap, не путать с командой trap в оболочке Bourne). Например, исполнение операции деления на ноль в некотором процессе вырабатывает схему прерывания (trap). Некий сигнал, вызванный каким- то событием, внешним по отношению к процессу или аппаратному устройству в вычислительной системе называется внешним сигналом. Если некий внешний сигнал предназначен для некоторого аппаратного устройства, такого как ЦПУ или дисковый контроллер, он именуется аппаратным прерывание или прерыванием. Некое внешнее событие означающее получение внимания одного или более процессов именуется как программное прерывание или сигнал на жаргоне UNIX. Например, некий внутренний сигнал вырабатывается для процесса когда этот процесс пытается исполнить несуществующую инструкцию или доступ к области памяти, доступ к которой ему не разрешён, например к памяти, относящейся к другому процессу или самому ядру UNIX. Вы можете выработать некий внешний сигнал нажав <Ctrl+C>, путём выхода из системы или применив команду kill. Команда kill может применяться для отправки любого типа сигнала в некий процесс. Ниже приводится краткое описание самой команды kill.

Вы можете применить команду kill -1 (номер один) для отправки определённого по умолчанию сигнала всем своим процессам. Только суперпользователь может отправить некий сигнал к тем процессам, которые относятся к другим пользователям. Таким образом, суперпользователь может применять эту команду для отправки сигналов всем имеющимся процессам, исполняемым в данной системе. Вы можете воспользоваться командой kill -l (l нижнего регистра) для отображения всех сигналов, поддерживаемых вашей системой UNIX. Следующая исполняемая на PC-BSD команда показывает, что она поддерживает 32 типа сигналов. Страницы руководства для системных вызовов сигналов могут показать, что система PC-BSD поддерживает 33 типа сигналов. Вы можете воспользоваться командой man signal для собственной проверки. Синтаксический блок показывает подробности некоторых наиболее часто применяемых сигналов.

% kill -l
HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS PIPE ALRM
TERM URG STOP
TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ VTALRM PROF WINCH INFO USR1
USR2 LWP
%
 	   

Solaris поддерживает 72 типа сигналов, что отображается в следующем сеансе:

% kill -l
 1) SIGHUP        2) SIGINT        3) SIGQUIT       4) SIGILL
 5) SIGTRAP       6) SIGABRT       7) SIGEMT        8) SIGFPE
 9) SIGKILL      10) SIGBUS       11) SIGSEGV      12) SIGSYS
13) SIGPIPE      14) SIGALRM      15) SIGTERM      16) SIGUSR1
17) SIGUSR2      18) SIGCHLD      19) SIGPWR       20) SIGWINCH
21) SIGURG       22) SIGIO        23) SIGSTOP      24) SIGTSTP
25) SIGCONT      26) SIGTTIN      27) SIGTTOU      28) SIGVTALRM
29) SIGPROF      30) SIGXCPU      31) SIGXFSZ      32) SIGWAITING
33) SIGLWP       34) SIGFREEZE    35) SIGTHAW      36) SIGCANCEL
37) SIGLOST      38) SIGXRES      39) SIGJVM1      40) SIGJVM2
41) SIGRTMIN     42) SIGRTMIN+1   43) SIGRTMIN+2   44) SIGRTMIN+3
45) SIGRTMIN+4   46) SIGRTMIN+5   47) SIGRTMIN+6   48) SIGRTMIN+7
49) SIGRTMIN+8   50) SIGRTMIN+9   51) SIGRTMIN+10  52) SIGRTMIN+11
53) SIGRTMIN+12  54) SIGRTMIN+13  55) SIGRTMIN+14  56) SIGRTMIN+15
57) SIGRTMAX-15  58) SIGRTMAX-14  59) SIGRTMAX-13  60) SIGRTMAX-12
61) SIGRTMAX-11  62) SIGRTMAX-10  63) SIGRTMAX-9   64) SIGRTMAX-8
65) SIGRTMAX-7   66) SIGRTMAX-6   67) SIGRTMAX-5   68) SIGRTMAX-4
69) SIGRTMAX-3   70) SIGRTMAX-2   71) SIGRTMAX-1   72) SIGRTMAX
%
 	   

Таблица 10.11 показывает некоторые примеры команд kill и их значения.

Таблица 10-11. Некоторые примеры команды kill и их значения

Команда	Значение
kill 1234	Отправляет определённый по умолчанию сигнал (SIGTERM) процессу с PID 1234
kill -9 1234	Отправляет SIGKILL (сигнал гарантированного прекращения) процессу с PID 1234
kill -s kill 1234
kill -s KILL 1234
kill -9 1234 -1004	Отправляет SIGKILL (сигнал гарантированного прекращения) процессу с PID 1234 и всем прочим процессам с идентификатором группы (PGID) 1004
kill -s kill 1234 -1004
kill -s KILL 1234 -1004
kill –TERM -1004	Отправляет SIGTERM всем процессам с идентификатором группы (PGID) 1004
kill -- -1004

Сигнал отсоединения (hang-up) вырабатывается когда вы покидаете систему, сигнал прерывание (interrupt) вырабатывается когда вы нажимаете <Ctrl+C>, а сигнал выхода (quit) создаётся нажатием <Ctrl+\>. Команда kill отправляет сигнал номер 15 для процесса, чей PID определён в качестве её аргумента. Определённым по умолчанию действием для этого сигнала является прекращение того процесса, который получил его. Данный сигнал может перехватываться и игнорироваться процессом, как это можно делать для большинства прочих сигналов. Чтобы завершить тот процесс, который игнорирует сигнал 15 или прочие сигналы, необходимо отправить ему сигнал номер 9, именуемый гарантированным прекращением (sure kill). Команда kill прекращает все процессы, чьи PID представлены в её proc-list, в представлении что эти процессы относятся к тому пользователю, который применяет kill. Следующий сеанс в PC-BSD представляет некие экземпляры того, как может применяться данная команда kill. Однако не прекращайте самый первый процесс регистрации оболочки, так как это выведет вас из системы.

% jobs -l
[1]  + 14338 Running                            sort bigdata > bigdata.sorted
[2]  - 14667 Running                            cp biggerdata biggerdata.bak
[3]    14668 Running                            grep sh biggerdata > lines.sh
% kill 14668
% kill -2 14667
[3]          Terminated                         grep sh biggerdata > lines.sh
% kill -9 14338
[2]          Interrupt                          cp biggerdata biggerdata.bak
% jobs
[1]          Killed                             sort bigdata > bigdata.sorted
% jobs
%
 	   

В данном случае команда kill отправляет сигнал номер 15 процессу с PID 14688. Во втором случае, сигнал номер 2 (SIGINT) отправляется процессу с PID 14667. В обоих случаях так как эти определённые сигналы не перехватываются, данные процессы прекращаются. Команда kill может применяться для прекращения целого ряда процессов в одной командной строке. Например, команда kill -9 13576 20581 прекратит процессы с PID 13576 и 20581.

Идентификатор процесса 0 может применяться для ссылки на все те процессы, которые были созданы в процессе текущего входа в систему. Таким образом, команда kill -9 0 прекратит все процессы, полученные в результате текущего входа в систему, как это показывается в сеансе далее. Отметим, что данная команда прекратит все те процессы, которые явились результатом текущего сеанса регистрации со стороны sarwar, включая и те процессы, которые сопровождают соединения регистрации в безопасной оболочки (ssh) для данного клиента. Таким образом, вы видите приглашение данной локальной машины, некоторое терминальное окно, исполняющее Bash в MacBook Pro под управлением Mac OS X (Darwin), MacBook-Pro:~ syedsarwar$. Это имеет серьёзные последствия, так как тот порядок, в котором kill прекращает процессы не известен в данном случае. Таким образом, если первыми завершатся сама оболочка регистрации и те процессы, которые поддерживают соединения безопасной оболочки с самой машиной клиента, тогда все те процессы, которые исполняются под данной регистрацией в оболочке продолжат исполняться. Вы могли бы заметить это когда зарегистрируетесь вновь и осознаете, что команда ssh требует больше времени для установления соединения со своей удалённой машиной, а когда вы подключитесь и получите исполняемым оболочку регистрации, время отклика системы будет плохим. Команда ps покажет что ваши фоновые процессы из предыдущей регистрации всё ещё исполняются, как это демонстрируется в следующем сеансе в теневых порциях. Отметим, что все состояния таких "остаточных" процессов равны D (выгружены в файл подкачки) и DL (выгружены в файл подкачки и блокированы), причём они не связаны ни с каким терминалом (отметим отрицательные номера терминалов). Вам необходимо прекратить эти процессы чтобы улучшить время отклика данной системы, что показывается в самой последней строке данного сеанса.

% ps -U sarwar
  PID TT STAT   TIME COMMAND
15361 -  S   0:00.01 sshd: sarwar@pts/1 (sshd)
15368 1  Ss  0:00.07 -csh (csh)
15424 1  D   0:07.05 sort bigdata
15437 1  D   0:00.60 cp biggerdata biggerdata.bak
15456 1  D   0:01.31 grep sh biggerdata
15521 1  R+  0:00.00 ps -U sarwar
15158 2- DL  1:58.99 sort bigdata
% kill -9 0
Connection to 192.102.169.10 closed.
MacBook-Pro:~ syedsarwar$ ssh sarwar@192.102.169.10
Password for sarwar@pcbsd-srv:
Last login: Sun Oct 5 10:17:45 2014 from 139.15.192.135
FreeBSD 10.0-RELEASE-p6 (GENERIC) #0 acf484b(releng/10.0): Mon Feb 24 15:14:38 EST 2014
Welcome to FreeBSD!
...
% ps
  PID TT STAT   TIME COMMAND
15424 1- DL  0:23.56 sort bigdata
15437 1- D   0:09.15 cp biggerdata biggerdata.bak
15456 1- D   0:21.06 grep sh biggerdata
15158 2- DL  1:59.38 sort bigdata
15866 3  Ss  0:00.06 -csh (csh)
15913 3  R+  0:00.00 ps
% kill 15158 15424 15437 15456
%
 	   

Команда kill также работает с номерами заданий. Следовательно, следующая команда может быть применена для прекращения процесса с заданием номер 1. Вы можете прекратить множество процессов определив их номера заданий в данной командной строке. Например, kill -9 %1 %3 может применяться для прекращения процессов с номерами заданий 1 и 3.

$ kill -9 %1
[1] + Killed find / -name foo -print > foo.paths &
$
 	   

Когда вы покидаете систему, все тепроцессы, которые исполнялись в вашем сеансе получают сигнал отсоединения (hung-up, сигнал номер 1) и прекращаются согласно определённому по умолчанию действию. Если вы желаете, чтобы процессы продолжили работать даже после того как вы покинули систему, вам необходимо исполнить их таким образом, чтобы они игнорировали сигнал отсоединения при его получении. Вы можете применить команду UNIX nohup для выполнения этой задачи. Далее следует краткое описание синтаксиса данной команды.

Вам необходимо применять команду nohup для процессов, которые имеют долгое время завершения, например, программа сортировки большого файла, содержащего сотни и тысячи пользовательских записей. Очевидно, что вы бы исполняли такой вид задач в фоновом режиме с тем, чтобы она исполнялась с низшим приоритетом. Ниже приводится простая иллюстрация использования такой команды nohup. В данном случае, команда find исполняется в фоновом режиме и не прекращается, когда вы выходите из системы или отправляете сигнал номер 1 (отсоединение, hang-up) через свою команду kill. Если вывод данной команды не перенаправлен, он по умолчанию дописывается в конец файла nohup.out.

$ nohup find / -name foo -print 1> foo.paths 2> /dev/null &
[1] 62808
$ kill -1 62808
$ jobs
[1]+ Running nohup find / -name foo -print > foo.paths 2> /dev/null &
$ kill 62808
$ <Enter>
[1]+ Terminated nohup find / -name foo -print > foo.paths 2> /dev/null
$ jobs
$
 	   

Если вы разделите команды токами с запятой, вы сможете исполнить их в nohup. В следующем сеансе GenData вырабатывает некоторые данные и помещает их в некий файл с именем employees, а команда sort сортирует данный файл и сохраняет отсортированную версию в файле employees.sorted.

$ nohup GenData > employees ; sort employees > employees.sorted &
[2] 15931
$
 	   

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

 

Упражнение 10.7

Представьте команду для прекращения процессов с PID 10974 и идентификатором задания 3.

 

Упражнение 10.8

Исполните самую первую команду nohup, воспользуйтесь ps для проверки того, что данная команда исполняется, покиньте систему, зарегистрируйтесь вновь и примените команду ps -a чтобы определить исполняется ли ваша команда find.

Когда вы включаете свою систему UNIX, само ядро - после выполнения ряда проверок и прочих задач по обустройству - создаёт самый первый процесс в рабочей области. В PC-BSD этот процесс именуется kernel, а в Solaris называется sched. Именно этот процесс, который не имеет родителей обладает PID 0. Значение PPID для этого процесса также равняется 0. Затем он порождает некоторые прочие процессы, которые предназначаются для обработки различных важных задач ядра, включая задачи, относящиеся к виртуальной памяти, обработке файлов, обработке прерываний и выполнению различных задач во время начальной загрузки, например, инициализации аппаратных портов. Некий перечень этих процессов и их целей представлен в Таблица 10.12.

Таблица 10-12. Некоторые примеры команды kill и их значения

PC-BSD	Solaris	Назначение
init	init	Прародитель всех процессов пользователя; все службы уровня пользователя, включая все Интернет службы, все пользовательсткие процессы исполняются под управленем потомков данного процесса
pagedaemon	pageout	Считывает/ записывает страницы на/ с диска
bufdaemon	fsflush	Поддерживает чистыми страницы/ буферы, записывая изменённые (dirty) страницы/ буферы на диск
intr	intrd	Обрабатывает все прерывания (нижняя половина ядра)
vmdaemon	vmtasks	Перемещает процессы из основной памяти в дисковое хранилище

Процесс init является самым первым прародителем всех создаваемых процессов пользователей с тех пор как система поднята и работает. Сам процесс init имеет PID 1 и исполняется с полномочиями суперпользователя. Исполняемый двоичный файл для данного процесса находится в /sbin/init при управлении со стороны PC-BSD и в /usr/sbin/init для Solaris. Данный процесс, после выполнения определённых действий, указанных в файле /etc/rc, считывает свой файл /etc/ttys чтобы определить какие линии ввода/ вывода терминала должны быть активными. Для каждой активой линии, init запускает процесс getty из файла /etc/getty. Данный процесс getty, также исполняемом в режиме суперпользователя, устанавливает атрибуты терминала, такие как скорость передачи информации, как это определено в файле /etc/termcap. Затем он отображает приглашение на ввод login:, приглашая вас зарегистрироваться в данном терминале.

В приглашении login: вы набираете своё регистрационное имя и нажимаете <Return>, после чего процесс getty ответвляет некоторого потомка. Этот дочерний процесс исполняет системный вызов exec чтобы стать неким процессом регистрации для вашего регистрационного имени в качестве его параметра. Данный процесс регистрации запрашивает у вас ваш пароль и проверяет достоверность вашего регистрационного имени и пароля. Если он определяет, что оба верны, данный процесс регистрации исполняется становясь вашей оболочкой регистрации. Если ваш процесс регистрации не находит ваше регистрационное имя в своём файле /etc/passwd или определяет, что введённый вами пароль не соответствует имеющемуся в файле /etc/passwd, он отображает сообщение об ошибке и завершается. Управление возвращается обратно породившему его процессу getty, который повторно отобразит приглашение login:. Когда вы зарегистрируетесь в оболочке, вы можете выполнять свою работу и завершать эту оболочку путём нажатия на <Ctrl+D> или исполнения команды exit. Когда вы сделаете это, ваш процесс оболочки прекратится и управление вернётся обратно к процессу getty, который опять отобразит приглашение login: и жизнь продолжится.

Когда вы регистрируетесь через свою команду ssh, на вашей удалённой машине демон sshd (процесс сервера безопасной оболочки - Secure Shell) создаёт некий дочерний процесс для вас (ваш частный sshd), который обрабатывает взаимодействие с вашим клиентом. Такой сервер sshd возвращается обратно и просматривает дополнительные запросы на соединения SSH от прочих клиентов. Ваш частный sshd порождает другой процесс sshd, который перезаписывает себя неким псевдо-терминалом pts/1, а тот в свою очередь выдаёт приглашение на ввод вашего пароля {Прим. пер.: или устанавливает соединение на основании вашего общедоступного ключа ssh}. По умолчанию данная оболочка регистрации является оболочкой C в PC-BSD и Bash в Solaris. Вы исполняете свои команды под вашей оболочкой регистрации. Когда вы нажимаете <Ctrl+D> для выхода, ваш терминал регистрации прекращает работу вместе с вашим частным демоном sshd. Вы также можете завершать работу, исполняя команду exit.

Рисунок 10.7 и Рисунок 10.8 схематично отображают все иерархии процессов в Solaris и PC-BSD, соответетственно с регистрацией в терминалах и певдотерминалах. Два процесса, ps и more исполняются под оболочками регистрации Bash и C в Solaris и PC-BSD соответственно.

Два процесса UNIX существуют на протяжении всего времени жизни некоторой системы: kernel (PC-BSD) или sched (Solaris) и init. Наш процесс getty, который наблюдает за терминальными соединениями, выполняется пока имеется подключённый к системе терминал. Ваш процесс регистрации в оболочке присутствует пока вы зарегистрированы в системе. Все прочие процессы обычно имеют короткое время существования и остаются пока исполняется некая команда или утилита.

В Solaris вы можете воспользоваться командой ptree для отображения всего дерева исполняющихся в настоящее время процессов в данной системе в графическом виде с отображением взаимоотношений предок- потомок. Вы можете отобразить такое дерево процессов для некоторого пользователя. В приводимом далее сеансе мы применяем команду ptree –a davis для отображения всей иерархии процессов для своего пользователя davis. Данный вывод отображает что самым первым прародителем всех ваших процессов, исполняемых davis, как это и ожидалось, являетя процесс init. Последующий вывод показывает, что davis используется системой в соединении SSH и в настоящее время использует Bash. Без наличия опции -a та строка для процесса init, которая является предком процесса 556 (т.е. самого демона ssh) не отображается. Команда ptree -a 'pgrep sshd' отображает всю иерархию процесса для данного демона sshd.

$ ptree -a davis
1     /usr/sbin/init
  516   /usr/lib/ssh/sshd
    26087 /usr/lib/ssh/sshd
      26088 /usr/lib/ssh/sshd
        26095 -bash
          26188 ptree -a davis
$ ptree -a 'pgrep ssh'
1     /usr/sbin/init
  516   /usr/lib/ssh/sshd
    26087 /usr/lib/ssh/sshd
      26088 /usr/lib/ssh/sshd
        26095 -bash
          26192 ptree -a 516 26087 26088
$
 	   

В PC-BSD вы можете применить команду ps –auxd для отображения взаимоотношений предок- потомок между процессами. Однако, получаемый вывод для данной команды не настолько совершенен, как это имеется в случае с командой ptree, что можно обнаружить в приводимом далее сеансе. Вы можете попробовать исполнить команду ps –auxd | more в своей системе чтобы просмотреть всю иерархию вашей системы.

% ps -dU sarwar
  PID TT STAT    TIME COMMAND
93204 -  S    0:00.18 sshd: sarwar@pts/1 (sshd)
93207 1  Ss   0:00.45 - -csh (csh)
96636 1  R+   0:00.02 `-- ps -dU sarwar
%
 	   

В PC-BSD вы можете исполнить команду ps –aflx | more для отображения всех исполняющихся в вашей системе процессов и некоторых их важных атрибутов, включая PID, PPID, приоритет, значение любезности, виртуальный размер, размер в основной памяти на текущий момент, состояние, ожидаемое событие, а также полное имя команды, использованной для запуска данного процесса. Вы можете отобразить все имена пользователей, PID, PPID, а также полные имена команд для всех процессов в Solaris выполнив команду ps -e -o user,pid,ppid,comm. Мы применили выводы этих команд для построения всей иерархии процесов в двух своих системах, отображённых на Рисунке 10.7 и Рисунке 10.8.

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

Имеющаяся оболочка исполняет команды, создавая дочерний процесс с помощью системных вызовов fork и exec. Когда некий процесс применяет системный вызов fork, имеющееся ядро UNIX создаёт точную копию образа основной памяти данного процесса. Оболочка сама по себе исполняет некую внутреннюю команду. Некая внешняя команда исполняется его дочерней оболочкой, переписывающей себя кодом данной команды через системный вызов exec. Для некоторой внешней команды, заключающей в себе какой- то сценарий оболочки, её дочерняя оболочка исполняет все команды из данного файла сценария одну за другой.

Всякий процесс UNIX имеет различные атрибуты, включая идентификатор процесса (PID), идентификатор родительского процесса (PPID), название процесса, состояние процесса (исполняющийся, приостановленный, выгруженный, зомби и т.п.), тот терминал, из которого исполнился данный процесс, общая продолжительность времени исполнения процесса, а также приоритет процесса. Команда ps может применяться для просмотра статического отображения этих атрибутов. Команда top может быть использована для просмотра динамического отображения всех различных статистик системы и атрибутов всех исполняющихся в данной системе процессов и допускает интерактивные команды через различные нажатия с клавиатуры.

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

Приостановка процессов, перемещение их из приоритетного режима в фоновый и наоборот, наличие возможности отображения их состояния, прерывание их работы с помощью сигналов, а также их прекращение, всё это именуется управлением заданий и UNIX имеет некий набор команд, которые делают возможными такие действия. Приоритетный процесс может быть приостановлен и перемещён в фоновый режим путём нажатия <Ctrl+Z> с последующим исполнением команды bg. Приостановленный и исполняемый в фоновом режиме процесс может быть перемещён в приоритетный режим с помощью команды fg. Команды, которые приостановлены или исполняются в фоновом режиме также именуются заданиями. Команда jobs может применяться для просмотра состояний всех ваших заданий. Вы можете нажать <Ctrl+C> чтобы прекратить некий приоритетный процесс.

Команда kill может прекратить некий процесс с указанием его PID или идентификатора задания. Данная команда может применяться для отправки различных типов сигналов, иначе: программных прерываний, в процессы. Получив любой из сигналов, за исключением одного, некий процесс может предпринять предварительно определённое (определяемое в ядре) действие, выполнить определённое пользователем действие, либо проигнорировать его. Никакой процесс не может игнорировать имеющуюся команду kill -9, сигнал гарантированного прекращения, который помещён на своё место разработчиками UNIX чтобы гарантировать, что любой исполняемый в системе процесс может быть прекращён. Команды, исполненные в общей команде nohup могут продолжить исполнение даже после того как некий пользователь выйдет из системы. Команда kill -9 0 является гарантированным прекращением всех процессов, связанных с данной текущей регистрацией некоторого пользователя. {Прим. пер.: однако, в силу того что порядок останова процесса не определён, она может приводить к оставлению в памяти процессов после уничтожения процесса регистрации оболочки, являющегося прародителем всех таких процессов.}

Вы можете воспользоваться командой ptree в системе Solaris под управлением Bash для отображения структуры дерева для ваших процессов или процессов другого пользователя. С помощью параметра -a отображаемый вывод будет содержать строки для самого процесса прародителя init. Аналогично, в оболочке C PC-BSD вы можете применить команду ps -d чтобы посмотреть менее выразительную версию взаимоотношений предок- потомок и дети одного родителя межлду процессами в своей системе. Команда ps -auxfd отобразит полную иерархию всех процессов в системе, в то время как команда ps -d отображает имеющуюся иерархию процессов некоторого определённого пользователя.