Pid linux что это
Блог о системном администрировании. Статьи о Linux, Windows, СХД NetApp и виртуализации.
Доброго времени, гости моего блога! В сегодняшнем посте расскажу о том, как работают процессы в ОC Linux, а так же как управлять этими самыми процессами, о выполнении процессов в фоне, о повышении/понижении приоритета процессов.
В общем представлении, процесс — это программа, выполняющаяся в оперативной памяти компьютера. Реально, все гораздо сложней.
На которой можно описать пошагово следующие этапы:
Очень наглядную схему предоставила википедия:
В каких же состояниях может находиться процесс в Linux?
Каждый запущенный процесс в любой момент времени находится в одном из следующих состояний (которое называют еще статусом процесса):
Т.к. в большинстве случаев, демоны в Linux простаивают и ожидают поступления каких-либо данных, соответственно, нужны относительно редко, так что держать их в памяти постоянно загруженными и расходовать на это ресурсы системы нерационально. Для организации работы демонов придуман демон inetd или его более защищенная модификация xinetd (eXtended InterNET Daemon или расширенный Интернет демон). В функции inetd (Xinetd) можно выделить:
Все процессы в системе, не важно Linux это или другая ОС, обмениваются между собой какой-либо информацией. Отсюда можно задать вопрос, а как же происходит межПРОЦЕССный обмен?
локальный (привязаны к процессору и возможны только в пределах компьютера);
— каналы
в первом терминале (создаем именованный канал в виде файла pipe и из канала направляем данные с помощью конвейера в архиватор):
во втором терминале (отправляем в именованный канал данные):
в результате это приведет к сжатию передаваемых данных gzip-ом
— сигналы
сигнал — это асинхронное уведомление процесса о каком-либо событии. Когда сигнал послан процессу, операционная система прерывает выполнение процесса. Если процесс установил собственный обработчик сигнала, операционная система запускает этот обработчик, передав ему информацию о сигнале. Если процесс не установил обработчик, то выполняется обработчик по умолчанию.
Все сигналы начинаются на «SIG…» и имеют числовые соответствия, определяемые в заголовочном файле signal.h. Числовые значения сигналов могут меняться от системы к системе, хотя основная их часть имеет в разных системах одни и те же значения. Утилита kill позволяет задавать сигнал как числом, так и символьным обозначением.
Сигналы можно послать следующими способами:
— разделяемая память
Разделяемую память применяют для того, чтобы увеличить скорость прохождения данных между процессами. В обычной ситуации обмен информацией между процессами проходит через ядро. Техника разделяемой памяти позволяет осуществить обмен информацией не через ядро, а используя некоторую часть виртуального адресного пространства, куда помещаются и откуда считываются данные.
После создания разделяемого сегмента памяти любой из пользовательских процессов может подсоединить его к своему собственному виртуальному пространству и работать с ним, как с обычным сегментом памяти.
— очереди сообщений
В общих чертах обмен сообщениями выглядит примерно так: один процесс помещает сообщение в очередь посредством неких системных вызовов, а любой другой процесс может прочитать его оттуда, при условии, что и процесс-источник сообщения и процесс-приемник сообщения используют один и тот же ключ для получения доступа к очереди.
удаленный;
RPC — разновидность технологий, которая позволяет компьютерным программам вызывать функции или процедуры в другом адресном пространстве (как правило, на удалённых компьютерах). Обычно, реализация RPC технологии включает в себя два компонента: сетевой протокол (чаще TCP и UDP, реже HTTP) для обмена в режиме клиент-сервер и язык сериализации объектов (или структур, для необъектных RPC).
— сокеты Unix
Сокеты UNIX бывают 2х типов: локальные и сетевые. При использовании локального сокета, ему присваивается UNIX-адрес и просто будет создан специальный файл (файл сокета) по заданному пути, через который смогут сообщаться любые локальные процессы путём простого чтения/записи из него. Сокеты представляют собой виртуальный объект, который существует, пока на него ссылается хотя бы один из процессов. При использовании сетевого сокета, создается абстрактный объект привязанный к слушающему порту операционной системы и сетевому интерфейсу, ему присваивается INET-адрес, который имеет адрес интерфейса и слушающего порта.
высокоуровневый
Итак. Подведем маленький итог:
Далее поговорим о том, как посмотреть состояние процессов в Linux и о том, как же ими управлять.
Управление процессами
Получение информации о процессе
Перед тем как управлять процессами, нужно научиться получать о процессах необходимую информацию. В Linux существует псевдофайловая система procfs, которая в большинстве дистрибутивов монтируется в общую ФС в каталог /proc. У данной файловой системы нет физического места размещения, нет блочного устройства, такое как жесткий диск. Вся информация, хранимая в данном каталоге находится в оперативной памяти компьютера, контролируется ядром ОС и она не предназначена для хранения файлов пользователя. О структуре данного каталога я написал в статье о файловой системе Linux. В этой файловой системе дано достаточно много информации, чтобы узнать о процессах и о системе в целом.
Но пользоваться данным каталогом очень не удобно, чтобы узнать о каком-либо процессе информацию, придется просмотреть кучу файлов и каталогов. Чтобы избавиться от ненужного труда, можно использовать существующие утилиты ps и top для просмотра информации о процессах.
Чтобы получить список всех процессов, достаточно ввести команду:
# ps aux
Прокомментируем некоторые интересные моменты. Можно заметить, что некоторые процессы указаны в квадратных скобках [ ] – это процессы, которые входят непосредственно в состав ядра и выполняют важные системные задачи, например, такие как управление буферным кэшем [pdflush] и организацией свопинга [kswapd]. С ними лучше не экспериментировать – ничего хорошего из этого не выйдет :). Остальная часть процессов относится к пользовательским.
Какую информацию можно получить по каждому процессу (комментарии к некоторым полям):
С помощью команды можно завершить некоторый процесс (его PID будет запрошен), а с помощью команды можно переопределить значение nice для некоторого процесса.
Полезную информацию, так же, позволяет получить программа lsof, которая выдает список всех файлов, используемых сейчас процессами, включая каталоги, занятые потому, что какой-либо процесс использует их в качестве текущего или корневого; разделяемые библиотеки, загруженные в память; и т. д.
Итак, теперь об управлении процессами.
Управление процессами в Linux
где adnice — значение (от –20 до +19), добавляемое к значению nice процесса-родителя. Отрицательные значения может устанавливать только суперпользователь. Если опция adnice не задана, то по умолчанию для процесса-потомка устанавливается значение nice, увеличенное на 10 по сравнению со значением nice родительского процесса.
Команда renice служит для изменения значения nice для уже выполняющихся процессов. Суперпользователь может изменить приоритет любого процесса в системе. Другие пользователи могут изменять значение приоритета только для тех процессов, для которых данный пользователь является владельцем. При этом обычный пользователь может только уменьшить значение приоритета. Поэтому процессы с низким приоритетом не могут породить «высокоприоритетных детей».
Как я уже писал, одним из средств управления процессами являются сигналы. Некоторые сигналы можно сгенерировать с помощью определенных комбинаций клавиш, но такие комбинации существуют не для всех сигналов. Зато имеется команда kill, которая позволяет послать заданному процессу (указав его PID) любой сигнал:
где SIG — это номер сигнала или наименование сигнала, причем если указание сигнала опущено, то посылается сигнал 15 (SIGTERM — программное завершение процесса). Часто используется сигнал 9 (KILL), с помощью которого суперпользователь может завершить любой процесс. Но сигнал этот очень «грубый», если можно так выразиться, потому что он просто «убивает» процесс, не давая ему времени на корректное сохранение всех обработанных данных. Поэтому в большинстве случаев рекомендуется использовать сигналы TERM или QUIT, которые завершают процесс более «мягко». Если процессу необходимо как-то по-особенному реагировать на сигнал, он может зарегистрировать обработчик, а если обработчика нет, за него отреагирует система.
При обычном запуске процесс работает на переднем плане. то есть процесс «привязывается» к терминалу, с которого он запущен, воспринимая ввод с этого терминала и осуществляя на него вывод. Но можно запустить процесс в фоновом режиме, когда он не связан с терминалом, для чего в конце командной строки запуска программы добавляют символ &.
В оболочке bash имеются две встроенные команды, которые служат для перевода процессов на передний план или возврата их в фоновый режим. Команда fg переводит указанный в аргументе процесс на передний план, а команда bg — переводит процесс в фоновый режим. Одной командой bg можно перевести в фоновый режим сразу несколько процессов, а вот возвращать их на передний план необходимо по одному. Аргументами команд fg и bg могут являться только номера заданий, запущенных из текущего экземпляра shell. Возможные значения заданий можно увидеть, выполнив команду jobs.
При завершении сессии оболочка посылает всем порожденным ею процессам сигнал «отбой», по которому порожденные ею процессы могут завершиться, что не всегда желательно. Если вы хотите запустить в фоновом режиме программу, которая должна выполняться и после вашего выхода из оболочки, то ее нужно запускать с помощью утилиты nohup:
Запущенный таким образом процесс будет игнорировать посылаемые ему сигналы (не игнорируются только сигналы SIGHUP и SIGQUIT). Хочу так же выделить команду pstree, которая показывает дерево процессов. Очень наглядно, кстати.
Ну вот. как-то так. Буду рад любым комментариям и дополнениям.
Upd 2011.11.19: небольшой рестайлинг и дополнение информации о сигналах.
Как узнать PID процесса в Linux
Каждый процесс в операционной системе имеет свой уникальный идентификатор, по которому можно получить информацию об этом процессе, а также отправить ему управляющий сигнал или завершить.
В Linux такой идентификатор называется PID, и узнать его можно несколькими способами. В этой статье мы рассмотрим, как узнать PID процесса в Linux, а также зачем это может вам понадобиться.
Как узнать pid процесса Linux
ps aux | grep имя_процесса
Кроме нужного нам процесса, утилита также выведет PID для grep, ведь процесс был запущен во время поиска. Чтобы его убрать, добавляем такой фильтр:
Например, узнаём PID всех процессов, имя которых содержит слово «Apache»:
2. pgrep
Если вам не нужно видеть подробную информацию о процессе, а достаточно только PID, то можно использовать утилиту pgrep:
По умолчанию утилита ищет по командной строке запуска процесса, если нужно искать только по имени процесса, то надо указать опцию -f:
3. pidof
Эта утилита ищет PID конкретного процесса по его имени. Никаких вхождений, имя процесса должно только совпадать с искомым:
С помощью опции -s можно попросить утилиту выводить только один PID:
4. pstree
Утилита pstree позволяет посмотреть список дочерних процессов для определённого процесса, также их pid-идентификаторы. Например, посмотрим дерево процессов Apache:
Как узнать PID скрипта
Когда вы запускаете скрипт в оболочке, например Bash запускается процесс известный как подоболочка и выполняет последовательно все команды скрипта. Чтобы узнать PID процесса подоболочки Bash, запущенной для скрипта, обратитесь к специальной переменной $$. Эта переменная доступна только для чтения, поэтому вы не сможете ее редактировать:
Каким процессом занят файл Linux
Выше мы рассмотрели, как получить PID процесса Linux по имени, а теперь давайте узнаем PID по файлу, который использует процесс. Например, мы хотим удалить какой-либо файл, а система нам сообщает, что он используется другим процессом.
С помощью утилиты lsof можно посмотреть, какие процессы используют директорию или файл в данный момент. Например, откроем аудио-файл в плеере totem, а затем посмотрим, какой процесс использует её файл:
Здесь будет выведен только файл и PID процесса. После PID идёт одна буква, которая указывает, что делает этот процесс с файлом или папкой:
Кто использовал файл в Linux
Узнать процесс, который сейчас занимает файл, достаточно просто. Но как узнать, какой процесс обращается к файлу не надолго, например, выполняет его как программу или читает оттуда данные? Эта задача уже труднее, но вполне решаема с помощью подсистемы ядра auditd. В CentOS набор программ для работы с этой подсистемой поставляется по умолчанию, в Ubuntu же его придётся установить командой:
sudo apt install auditd
Теперь создаём правило для мониторинга. Например, отследим, кто запускает утилиту who:
Теперь выполним один раз who и посмотрим, что происходит в логе с помощью команды ausearch:
ps aux | grep 15595
Становиться понятно, что это bash.
Какой процесс использует порт в Linux
Иногда необходимо узнать PID Linux-программы, которая использует сетевой порт, например 80. Для этого можно использовать утилиту ss:
Мы видим, что это несколько процессов Apache. Использовав опцию dport, можно узнать, какой процесс отправляет данные на указанный порт:
Выводы
В этой статье мы рассмотрели, как узнать PID процесса в Linux по различным условиям: имени или файлу. Как видите, всё достаточно просто, и в считанные минуты можно можно понять, что происходит с вашей операционной системой, и какой процесс за это отвечает.
Многопроцессорные операционные системы, такие как Linux и BSD, используют несколько методов для максимальной загрузки ЦП. Процесс — это просто исполняемая программа. Поскольку в любой момент времени в Linux запущено значительно больше одного процесса, управление ими чрезвычайно важно. Пользователи регулярно сталкиваются с такими проблемами, как ограничение ресурсов процессора при запуске слишком большого количества программ. Подобные ситуации возникают, когда процессор не справляется с растущим числом процессов. Хотя это не полностью зависит от мощности вашего процессора, работа с зависшими процессами или процессами зомби может быть довольно неприятной. Чтобы облегчить вам жизнь в таких случаях, мы описываем здесь некоторые стандартные способы уничтожения таких процессов.
Мастер управления неотзывчивыми процессами в Linux
Вы узнаете несколько способов как в Linux завершить процесс, который не подает признаков жизни. Если вы юзали Windows, скорее всего вам знаком шорткат Ctrl + Alt + Delete. Точно так же пользователи Mac имеют метод Command + Option + Escape для уничтожения замороженных процессов. Linux гораздо более универсален, чем его аналоги, и предлагает более одного метода для устранения мертвых процессов.
Различные методы убийства мертвого процесса Linux
В основном мы опишем два метода убийства зомби-процессов. Мы будем использовать терминал Linux для первого метода. Для этого сначала нужно идентифицировать id процесса, он же PID, от английского process identifier – идентификатор процесса. После успешного получения мы сможем использовать этот PID, посылая сигнал для уничтожения программы ориентируясь на номер-идентификатор.
Вы также узнаете, как обкашливать такие вопросики, используя графический интерфейс пользователя. Для этого мы собираемся использовать приложение «Системный монитор», доступное в Ubuntu. Хотя это приложение GNOME, аналогичные инструменты доступны и для других сред Linux.
Завершить неотвечающий процесс из командной строки
Существует несколько инструментов для завершения неотвечающего или зависшего процесса из командной строки, включая kill, pkill и killall. Эти команды работают, посылая определенные сигналы не отвечающим процессам. Вам понадобится PID, чтобы вы могли отправить им требуемый завершающий сигнал.
PID или идентификатор процесса — это уникальный номер, который идентифицирует процесс. Эти номера генерируются ядром Linux непосредственно во время выполнения процессов, и диспетчер операционной системы управляет их процессорной активностью. Поэтому, когда вы вызываете приложение, ядро сначала запускает необходимые процессы и присваивает им эти уникальные значения PID. С процессом может быть связано несколько PID. Более того, у каждого процесса есть один родительский процесс с уникальным PPID (идентификатор родительского процесса).
Итак, если вы сможете узнать этот PPID, то сможете отправлять сигнал уничтожения с помощью программ, разработанных для этой цели. Ниже вы узнаете, как проверить запущенные процессы в Linux и определить их PPID из терминала.
Узнайте информацию о PPID
Вы можете узнать PPID процесса, используя несколько команд управления процессами в Linux, таких как pidof, pstree и pgrep. Давайте рассмотрим их одну за другой и посмотрим, как получить PID процесса Linux.
Способ 1: использование команды ps
Команда ps в Linux отображает все запущенные процессы вместе с другой информацией о процессах, такой как PID, в терминале. Мы можем использовать эту команду для вывода списка всех процессов, а затем отфильтровать определенный процесс с помощью команды grep в Linux. Она должна показать нам номер идентификатора процесса, который нам и требуется.
Давайте подробнее поговорим о том, что происходит на демонстрации выше. Во-первых, мы запустили в фоновом режиме текстовый редактор Nano. Затем мы использовали команду ps вместе с командой grep, чтобы узнать PPID этого редактора. Вывод может содержать несколько идентификаторов процессов, но нас интересует только первый, поскольку это наш PPID. Мы также можем использовать команду Linux awk, чтобы узнать эту информацию, как показано ниже.
Эта команда более гибкая, так как она отфильтрует всю несущественную информацию, и покажет только номер PPID, который мы ищем.
Способ 2: Использование команды pstree
Команда pstree предоставляет нам древовидное представление всех запущенных процессов. Она предоставляет графическое представление списка задач Linux из окна терминала. С помощью этой команды вы можете просмотреть PPID или, при желании, информацию о всех PID процесса. Посмотрите приведенные ниже примеры, чтобы узнать, как использовать pstree для поиска PPID определенного процесса.
Теперь подробности. Во-первых, мы породили процесс в фоновом режиме с помощью первой команды. Затем вторая команда получает PPID этого процесса с помощью команды grep в Linux. Наконец, третья команда показывает нам, как получить это же значение с помощью команды awk.
Способ 3: использование команды pgrep
Команда pgrep является одной из самых простых команд управления процессами в Linux. Он проверяет список всех запущенных процессов и выводит PPID процесса. Она работает путем сопоставления регулярных выражений и очень хорошо подходит для написания шелл-скриптов Linux.
Мы породили nano-процесс аналогично предыдущим примерам. Затем мы получили его PPID с помощью команды pgrep. Как только мы получим это значение, мы сможем выполнить задачу уничтожения мертвого процесса максимально легко.
Способ 4: Использование команды pidof
Команда pidof — это еще один простой, но полезный способ определения PPID процесса Linux. Он отображает как PPID, так и все другие PID, связанные с процессом. Ознакомьтесь с приведенной ниже демонстрацией, чтобы увидеть, как использовать ее на практике.
Способ 5: использование команды top
Команда top обеспечивает представление в реальном времени всех запущенных процессов в Unix-подобных операционных системах. Вы можете использовать её, чтобы отобразить список задач Linux в вашем терминале и узнать информацию о PID определенного процесса.
Используйте следующие команды для получения PPID определенного процесса из выходных данных команды, приведённой выше.
Поскольку top обеспечивает вывод в реальном времени вместо выгрузки статических данных на экран, мы использовали опцию -n1 и -b для получения статического вывода. Затем вы можете получить информацию о PPID с помощью команды grep или awk.
Убить не отвечающий процесс Linux
Способ 1: использование команды kill
Простая и надежная как лом, команда kill, благодаря этим своим свойствам, широко используется администраторами Linux. Ей требуется только PID процесса и сигнал. Ядро убивает / останавливает выполнение процесса на основе этого сигнала. Вы можете использовать следующую команду, чтобы просмотреть все доступные сигналы для команды kill.
Как видите, kill предлагает 64 различных сигнала. Однако в этом руководстве мы обсудим только два из них. Это сигнал 9 (SIGKILL) и сигнал 15 (SIGTERM). SIGTERM или сигнал 15 — это безопасный метод уничтожения не отвечающего процесса. SIGKILL или сигнал 9, с другой стороны, принудительно убивает процесс Linux.
Вышеприведенные команды эквивалентны, и они принудительно завершат процесс с PID 8631. Это PPID процесса «nano» в моей системе. Замените его на PID не отвечающего процесса в вашей системе.
Вышеприведенные команды также эквивалентны и будут корректно завершать процесс. Вот почему может пройти некоторое время, прежде чем процесс будет остановлен. Более того, вам может понадобиться добавить sudo перед командой kill, если процесс принадлежит другому пользователю.
Способ 2: использование команды pkill
Команда pkill является одной из самых универсальных команд управления процессами в Linux. Она позволяет нам уничтожать неотвечающий процесс на основе его имени, PID, владельца или других атрибутов. Это идеальный инструмент для начинающих пользователей или людей, которые не знакомы со многими стандартными командами терминала.
Вы можете использовать любую из перечисленных выше команд pkill для уничтожения зомби-процесса в Linux. Также команда pkill позволяет вам отправлять определенные завершающие сигналы.
Способ 3: использование команды killall
Команда killall позволяет пользователям уничтожать неотвечающие процессы на основе их имен. Так значительно проще, но, при не осторожном использовании, может вызвать серьёзные проблемы. Так как killall завершает процессы, основанные на именах, всегда есть шанс, что вы в конечном итоге убьете процесс случайно. Например, если в вашей системе доступны разные версии nano, первая команда в демонстрации ниже уничтожит их все.
Способ 4: использование удобных однострочников
Истинная красота Linux заключается в том, что он позволяет пользователям создавать сложные комбинации команд в зависимости от их потребностей. Чтобы продемонстрировать это, мы предлагаем вам ознакомиться с несколькими однострочниками в разделе ниже.
Теперь подробнее, в первом примере мы использовали интерполяцию оболочки для передачи PID процесса «nano» команде Linux kill. Второй пример использует несколько повседневных команд терминала и перенаправление ввода / вывода, чтобы завершить процесс. Вы сможете создавать свои собственные изящные однострочники, когда лучше освоитесь с терминалом Linux.
Способ 5: уничтожение нескольких процессов с помощью шелл-скриптов Linux
Иногда пользователи могут захотеть завершить более одного процесса. Мы можем легко автоматизировать такие задачи, написав простые сценарии оболочки. Следующий скрипт извлекает PPID процессов, которые вы хотите уничтожить, а затем завершает их, используя сигналы уничтожения.
Теперь сохраните этот файл и добавьте разрешение на выполнение, введя команду ниже.
Теперь вы можете передать этому сценарию имена процессов, которые вы хотите завершить.
Просто замените аргументы именами не отвечающих процессов Linux в вашей системе.
Завершить неотвечающий процесс из графического интерфейса
Вы также можете завершить неотвечающий процесс из GUI или window X. Мы обсудим два способа сделать это в следующем разделе.
Способ 1: использование приложения xkill
Современные дистрибутивы Linux используют оконную систему X window для предоставления конечному пользователю элегантного графического интерфейса. Существует простой инструмент под названием xkill, который позволяет юзерам закрывать неотвечающее окно графического интерфейса. Это возможно, поскольку в Linux окно заголовка приложения отделено от самого приложения.
Просто зайдите в эмулятор терминала Linux и введите xkill. Он превратит ваш курсор мыши в кнопку X, которую можно использовать для уничтожения любого окна GUI.
Теперь все, что вам нужно сделать, это просто щелкнуть по панели окна не отвечающего приложения, и оно будет убито и мгновенно исчезнет.
Способ 2. Использование приложения System Monitor в Ubuntu
Большинство основных дистрибутивов Linux поставляются с какими-то инструментами мониторинга графического интерфейса, которые позволяют пользователям «графически» завершать зависший процесс Linux. Например, приложение System Monitor в Ubuntu позволит нам интуитивно прекратить не отвечающий процесс. Вы можете просто выбрать мертвый процесс из списка процессов и уничтожить его, щелкнув правой кнопкой мыши по процессу и выбрав опцию уничтожения.
Существует еще много альтернатив этому приложению, и мы уверены, что вы легко сможете найти что-то подобное для своего дистрибутив.