Id процесса что это

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

Любая выполняемая программа в системе называется процессом. Все, от системы X Window до системных программ (демонов), которые запускаются при включении компьютера, является процессом. Каждый процесс запускается от имени какого-то пользователя. Процессы, которые были запущены при загрузке системы, обычно выполняются от имени пользователя root или от имени пользователя nobody. Процессы, запущенные пользователем, обычно выполняются от его имени.

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

Для управления процессами используются следующие команды:

& — запуск программы в фоновом режиме; + — приостановка текущего процесса; bg – перевод приостановленного процесса в фоновый режим; fg – возврат процесса из фонового режима; jobs – список процессов в фоновом режиме; ps – список программ, выполняемых на терминале; kill, killall – принудительное завершение процессов; top – вывод динамической информации о процессах; nice- изменение приоритета;

Перевод в фоновый режим

Программы, запущенные из командной строки, обычно выполняются на переднем плане (foreground) и связаны с терминалом. Это позволяет пользователю видеть весь вывод программы и взаимодействовать с ней. Но бывают такие случаи, когда требуется, чтобы программа не занимала терминал, тогда ее запускают в фоновом режиме (foneground).

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

$ amp *.mp3 &

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

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

$ bg

Таким образом, приостановленный процесс будет переведен в фоновый режим.

Вывод из фонового режима

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

$ fg

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

[1]+ Done /bin/ls $LS_OPTIONS

Это указывает, что фоновый процесс (в данном случае ls) завершился.

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

$ jobs [1] Stopped vim [2]- Stopped amp [3]+ Stopped man ps

Команда выведет список всех фоновых процессов, и все они будут приостановлены. Номера — это идентификаторы для всех фоновых процессов. Если возле номера отображается знак плюс, то это означает, что этот процесс будет выведен из фонового режима по команде fg без указания аргументов.

Если же требуется перевести на передний план vim, то придется ввести:

$ fg 1

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

Список выполняемых программ

Простой ввод ps выдаст список программ, выполняемых на терминале. Довольно часто этот список будет невелик:

$ ps PID TTY TIME CMD 7923 ttyp0 00:00:00 bash 8059 ttyp0 00:00:00 ps

При использовании утилиты ps выводится следующая информация:

• PID — идентификационный номер (ID) процесса. Каждый выполняющийся процесс получает уникальный идентификатор. В ядрах 2.4.х ID процессов может быть любым числом от 1 и до 232. Каждому новому процессу присваивается свободный PID;
• TTY — идентификатор терминала, на котором выполняется процесс. Простое выполнение ps покажет процессы, выполняемые на текущем терминале, так что для всех процессов в столбце TTY будет выведена идентичная информация. Как видно из примера, оба показанных процесса выполняются на терминале ttyp0. Это говорит нам о том, что эти процессы запущены либо удаленно, либо из какого-то X-терминала;
• TIME — счетчик процессорного времени выполнения процесса. Оно не является фактическим временем, с момента запуска процесса. Так как Linux многозадачная операционная система, то в любой момент времени есть несколько выполняемых процессов, и каждый из этих процессов получает небольшую порцию процессорного времени. Так вот, информация, указанная в столбце TIME, показывает время, которое гораздо меньше фактического времени выполнения процесса. Если это время больше, чем несколько минут у одного из процессов, то, скорее всего, что-то не так;
• CMD — сведения о программе. Отображается только имя программы — опции командной строки и аналогичная информация не выводится. Для того чтобы увидеть эту информацию, необходимо воспользоваться дополнительными опциями при запуске ps.

Далее будут описаны некоторые наиболее часто используемые опции утилиты ps.

Расширенный список процессов можно получить, выдав команду:

$ ps -ax PID TTY STAT TIME COMMAND

1  ? S 0:03 init [3]

2  ? SW 0:13 [kflushd]

3  ? SW 0:14 [kupdate]

4  ? SW 0:00 [kpiod]

5  ? SW 0:17 [kswapd]

11  ? S 0:00 /sbin/kerneld

30  ? SW 0:01 [cardmgr]

50  ? S 0:00 /sbin/rpc.portmap

54  ? S 0:00 /usr/sbin/syslogd

57  ? S 0:00 /usr/sbin/klogd -c 3

59  ? S 0:00 /usr/sbin/inetd

61  ? S 0:04 /usr/local/sbin/sshd

63  ? S 0:00 /usr/sbin/rpc.mountd

65  ? S 0:00 /usr/sbin/rpc.nfsd

67  ? S 0:00 /usr/sbin/crond -l10

69  ? S 0:00 /usr/sbin/atd -b 15 -l 1

77  ? S 0:00 /usr/sbin/apmd

79  ? S 0:01 gpm -m /dev/mouse -t ps2

94  ? S 0:00 /usr/sbin/automount /auto file /etc/auto.misc

106 tty1 S 0:08 -bash 108 tty3 SW 0:00 [agetty]

109 tty4 SW 0:00 [agetty] 110 tty5 SW 0:00 [agetty]

111 tty6 SW 0:00 [agetty]

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

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

А так же еще несколько новых столбцов с интересной информацией.

В системе большинство из процессов выполняются на устройстве «?». Это процессы, запущенные с более неактивного терминала. И поэтому они больше не принадлежат определенному терминалу.

Столбец STAT показывает состояние (status) процесса: S используется для спящего (sleeping) процесса (процесс ожидает, пока что-то произойдет); Z используется для зомбированных процессов (zombied). Зомбированные процессы — это такие процессы, родительский процесс которых завершился, оставив дочерние процессы рабочими, что не всегда корректно.

Если требуется получить больше информации о выполняемых процессах, можно применить такую команду:

$ ps -aux USER PID  %CPU  %MEM VSZ RSS TTY STAT START TIME COMMAND

root 1 0.0 0.0 344 80  ? S Mar02 0:03 init [3]

root 2 0.0 0.0 0 0  ? SW Mar02 0:13 [kflushd]

root 3 0.0 0.0 0 0  ? SW Mar02 0:14 [kupdate]

root 4 0.0 0.0 0 0  ? SW Mar02 0:00 [kpiod]

root 5 0.0 0.0 0 0  ? SW Mar02 0:17 [kswapd]

root 11 0.0 0.0 1044 44  ? S Mar02 0:00 /sbin/kerneld

root 30 0.0 0.0 1160 0  ? SW Mar02 0:01 [cardmgr]

bin 50 0.0 0.0 1076 120  ? S Mar02 0:00 /sbin/rpc.port

root 54 0.0 0.1 1360 192  ? S Mar02 0:00 /usr/sbin/sysl

root 57 0.0 0.1 1276 152  ? S Mar02 0:00 /usr/sbin/klog

root 59 0.0 0.0 1332 60  ? S Mar02 0:00 /usr/sbin/inet

root 61 0.0 0.2 1540 312  ? S Mar02 0:04 /usr/local/sbi

root 63 0.0 0.0 1796 72  ? S Mar02 0:00 /usr/sbin/rpc.

root 65 0.0 0.0 1812 68  ? S Mar02 0:00 /usr/sbin/rpc.

root 67 0.0 0.2 1172 260  ? S Mar02 0:00 /usr/sbin/cron

root 77 0.0 0.2 1048 316  ? S Mar02 0:00 /usr/sbin/apmd

root 79 0.0 0.1 1100 152  ? S Mar02 0:01 gpm

root 94 0.0 0.2 1396 280  ? S Mar02 0:00 /usr/sbin/auto

chris 106 0.0 0.5 1820 680 tty1 S Mar02 0:08 -bash

root 108 0.0 0.0 1048 0 tty3 SW Mar02 0:00 [agetty]

root 109 0.0 0.0 1048 0 tty4 SW Mar02 0:00 [agetty]

root 110 0.0 0.0 1048 0 tty5 SW Mar02 0:00 [agetty]

root 111 0.0 0.0 1048 0 tty6 SW Mar02 0:00 [agetty]

Это достаточно полный набор информации. Здесь имеются новые столбцы, которые описывают следующее: какой пользователь запустил процесс, сколько системных ресурсов использует процесс (%CPU, %MEM, VSZ и RSS столбцы) и дату, когда процесс был запущен. Очевидно, здесь предоставлено достаточно информации о процессах, которая может быть полезна для системного администратора. В случае если информация не помещается на экран, следует использовать опцию -w.

Принудительное завершение процессов

Для принудительного завершения процессов в системе используется утилита kill. Необходимость в этом появляется, если процесс вышел из-под контроля, забирает много системных ресурсов или остался в памяти после завершения работы программы.

Для того чтобы принудительно завершить процесс, пользователю надо знать либо его PID, либо имя. Чтобы получить PID, можно воспользоваться утилитой ps. Например, чтобы завершить процесс 4747, необходимо задать такую команду:

$ kill 4747

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

Также имеется другая разновидность утилиты kill, которая называется killall. Функция утилиты соответствует ее названию. Она завершает все из запущенных программ, с указанным именем. Если требуется завершить все выполняемые процессы vim, то следует воспользоваться такой командой:

$ killall vim

Все процессы vim, выполняемые пользователем, будут завершены. Если эту команду выполнит root, то она принудительно завершит вообще все процессы vim, выполняемые любым из пользователей. Это предоставляет интересный способ «выбрасывания» всех пользователей из системы:

#killall bash

Некоторые процессы не могут быть завершены обычной командой kill, и понадобится воспользоваться дополнительными опциями. Если процесс с PID 4747 не завершился после выполнения kill, то можно попробовать следующую команду:

$ kill -9 4747

Практически наверняка, это заставит процесс 4747 завершиться. Можно воспользоваться этим же ключом с утилитой killall. Этот ключ позволяет посылать различные сигналы программам. Обычный kill посылает процессу сигнал SIGTERM (terminate — завершить). kill -9 посылает SIGKILL (kill — убить). В распоряжении пользователей целый набор различных сигналов и можно запросить их список, выполнив:

$ kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP

6) SIGABRT 7) SIGBUS

SIGFPE 9) SIGKILL 10) SIGUSR1

11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM

17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP

21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25)

SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR

Номера используются для kill, а имя без предшествующего SIG используется для killall. Вот пример:

$ killall -KILL vim

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

Динамическая информация о процессах

Утилита top обеспечивает вывод динамической информации о процессах, выполняемых в системе.

$ top

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

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

9 самых простых способов узнать идентификатор процесса (PID) в Linux

В основном, мы смотрим PID, чтобы убить невосприимчивую программу, и она похожа на диспетчер задач Windows.

Linux GUI также предлагает ту же функцию, но CLI — эффективный способ выполнения операции kill.

Что такое идентификатор процесса PID?

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

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

Процесс — это исполняемый экземпляр программы.

Каждый раз, идентификатор процесса будет получать изменения ко всем процессам, кроме init, поскольку init всегда является первым процессом в системе и является предком всех других процессов. Это PID — 1. Максимальное значение PID по умолчанию — 32 768.

Это было проверено, выполнив следующую команду в системе # cat/proc/sys/kernel/pid_max В 32-битных системах 32768 является максимальным значением, но мы можем установить любое значение до 2 22 (приблизительно 4 миллиона) в 64-битных системах. Вы можете спросить, почему нам нужно такое количество PID? потому что мы не можем повторно использовать PID сразу. Также во избежание возможных ошибок.

PID для запущенных процессов в системе можно найти с помощью следующих девяти методов, таких как команда pidof, команда pgrep, команда ps, команда pstree, команда ss, команда netstat, команда lsof, команда fuser и команда systemctl.

• pidof: pidof — найти идентификатор процесса запущенной программы.
• pgrep: pgre — поиск или обработка сигналов на основе имени и других атрибутов.
• ps: ps — сообщает моментальный снимок текущих процессов.
• pstree: pstree — отображает дерево процессов.
• ss: ss используется для вывода статистики сокетов.
• netstat: netstat отображает список открытых сокетов.
• lsof: lsof — список открытых файлов.
• fuser: идентификаторы процессов в списке терминов всех процессов, которые открывают один или несколько файлов
• systemctl: systemctl — Управление системой systemd и менеджером сервисов

В этом уроке мы рассмотрим идентификатор процесса Apache для проверки.

Метод-1: Использование команды pidof

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

Он выводит эти идентификаторы на стандартный вывод.

Чтобы продемонстрировать это, мы узнаем идентификатор процесса Apache2 из системы Debian 9.

# pidof apache2 3754 2594 2365 2364 2363 2362 2361

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

Следовательно, нам нужно выяснить родительский PID (PPID), который мы ищем.

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

Способ-2: Использование команды pgrep

pgrep просматривает текущие процессы и перечисляет идентификаторы процессов, которые соответствуют критериям выбора для stdout.

# pgrep apache2 2361 2362 2363 2364 2365 2594 3754

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

В моем случае это 3754.

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

Метод-3: Использование команды pstree

pstree показывает запущенные процессы как дерево.

Дерево коренится либо в pid, либо в init, если pid опущен.

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

pstree визуально объединяет идентичные ветви, помещая их в квадратные скобки и префикс  с количеством повторений.

# pstree -p | grep «apache2» |-apache2(3754)-+-apache2(2361) | |-apache2(2362) | |-apache2(2363) | |-apache2(2364) | |-apache2(2365) | `-apache2(2594)

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

# pstree -p | grep «apache2» | head -1 |-apache2(3754)-+-apache2(2361)

Команда pstree очень простая, потому что она отдельно разделяет родительский и дочерний процессы

Метод-4: Использование команды ps

ps отображает информацию о выборе активных процессов.

Он отображает идентификатор процесса (pid = PID), терминал, связанный с процессом (tname = TTY), кумулятивное время процессора в формате [DD-] hh: mm: ss (time = TIME) и исполняемое имя (ucmd = ЦМД).

По умолчанию выходной файл не сортируется.

# ps aux | grep «apache2» www-data 2361 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2362 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2363 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2364 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2365 0.0 0.4 302652 8400 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2594 0.0 0.4 302652 8400 ? S 06:55 0:00 /usr/sbin/apache2 -k start root 3754 0.0 1.4 302580 29324 ? Ss Dec11 0:23 /usr/sbin/apache2 -k start root 5648 0.0 0.0 12784 940 pts/0 S+ 21:32 0:00 grep apache2

Из вышеприведенного вывода мы можем легко идентифицировать идентификатор родительского процесса (PPID) на основе даты начала процесса.

В моем случае процесс apache2 был запущен @ Dec11, который является родителем, а другие — дочерними. PID apache2 равен 3754.

Метод-5: Использование команды ss

ss используется для вывода статистики сокетов.

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

Он может отображать больше информации о TCP и состоянии, нежели другие инструменты.

Он может отображать статистику для всех типов сокетов, таких как PACKET, TCP, UDP, DCCP, RAW, домен Unix и т. д.

# ss -tnlp | grep apache2 LISTEN 0 128 :::80 :::* users:((«apache2»,pid=3319,fd=4),(«apache2»,pid=3318,fd=4),(«apache2»,pid=3317,fd=4))

Метод-6: Использование команды netstat

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

По умолчанию netstat отображает список открытых сокетов.

Если вы не укажете каких-либо семейств адресов, будут выведены активные сокеты всех сконфигурированных семейств адресов.

Эта программа устарела. Замена для netstat — ss.

# netstat -tnlp | grep apache2 tcp6 0 0 :::80 :::* LISTEN 3317/apache2

Метод-7: использование команды lsof

lsof — список открытых файлов.

Команда lsof Linux выводит информацию о файлах, открытых для процессов, запущенных в системе.

# lsof -i -P | grep apache2 apache2 3317 root 4u IPv6 40518 0t0 TCP *:80 (LISTEN) apache2 3318 www-data 4u IPv6 40518 0t0 TCP *:80 (LISTEN) apache2 3319 www-data 4u IPv6 40518 0t0 TCP *:80 (LISTEN)

Метод-8: Использование команды fuser

Утилита fuser должна записывать на стандартный вывод идентификаторы процессов процессов, запущенных в локальной системе, которые открывают один или несколько именованных файлов.

# fuser -v 80/tcp USER PID ACCESS COMMAND 80/tcp: root 3317 F…. apache2 www-data 3318 F…. apache2 www-data 3319 F…. apache2

Метод-9: Использование команды systemctl

systemctl — Управление системой systemd и менеджером сервисов.

Это замена старого системного управления SysV и большинство современных операционных систем Linux были адаптированы systemd.

# systemctl status apache2 ● apache2.service — The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; disabled; vendor preset: enabled) Drop-In: /lib/systemd/system/apache2.service.d └─apache2-systemd.conf Active: active (running) since Tue 2018-09-25 10:03:28 IST; 3s ago Process: 3294 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SUCCESS) Main PID: 3317 (apache2) Tasks: 55 (limit: 4915) Memory: 7.9M CPU: 71ms CGroup: /system.slice/apache2.service ├─3317 /usr/sbin/apache2 -k start ├─3318 /usr/sbin/apache2 -k start └─3319 /usr/sbin/apache2 -k start Sep 25 10:03:28 ubuntu systemd[1]: Starting The Apache HTTP Server… Sep 25 10:03:28 ubuntu systemd[1]: Started The Apache HTTP Server. Please follow and us:

Атрибуты процесса Идентификатор процесса (pid)

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

Идентификатор родительского процесса (ррid)

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

Исходный процесс в терминологии ОС UNIXназывают родительским, а его клон –порожденным. Помимо собственногоидентификатора, каждый процесс имеетатрибут РРID, т.е. идентификаторсвоего родительского процесса.

Идентификатор пользователя (uid) и эффективный идентификатор пользователя (euid)

UID – это идентификационный номерпользователя, создавшего данный процесс.Вносить изменения в процесс могут толькоего создатель и привилегированныйпользователь. Система учета относит насчет создателя процесса все ресурсы,которые использует его процесс.

EUID– это «эффективный»UIDпроцесса. ЕUIDиспользуется для того, чтобы определить,к каким ресурсам и файлам у процессаесть право доступа. У большинствапроцессовUIDи ЕUID будутодинаковыми. Исключение составляютпрограммы, у которых установлен битсмены идентификатора пользователя (см.обSUIDв разделе, посвященномустановлению прав доступа на файлы икаталоги).

Идентификатор группы (gid) и эффективный идентификатор группы (egid)

GID– это идентификационныйномер группы данного процесса. Допустимыеидентификаторы групп указываются вфайле/etc/groupи в поле GID файла/еtc/passwd.Когда процесс запускается, егоGIDустанавливается равнымGIDродительского процесса.

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

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

Приоритет и значениеnice

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

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

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

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

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

• у нового процесса свой PID;
• PPIDнового процесса равенPIDродителя;
• учетная информация нового процесса обнулена;
• у нового процесса имеется свой собственный экземпляр дескрипторов файлов.

Когда система загружается, ядросамостоятельно создает несколькопроцессов. Наиболее важный из них –процесс (демон) init,PIDкоторого всегда равен1. Этот процесс отвечает за вызовshellдля выполнения сценариев запускаrc,если Ваша система их использует.Все процессы, кроме тех, которые создаетядро, являются потомкамиinit.

После обработки файлов запуска процессinitзапускает длякаждого виртуального терминала процессgetty.

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

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

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

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

Иногдаinitне выполняет своиобязанности как следует, и зомби остаютсяв системе. Но каких-либо проблем приэтом они не создают.

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

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

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

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

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

В структуре данных ядра хранится всевозможная информация о каждом процессе. К наиболее важным относят:

• Таблицу распределения памяти
• Текущий статус (неактивен, приостановлен, выполняется и т.п.)
• Приоритет
• Информацию об используемых ресурсах
• Информацию о файлах и сетевых портах, открытых процессом
• Маску сигналов (запись о том, какие сигналы блокируются)
• Имя владельца процесса

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

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

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

Атрибуты процесса

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

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

В операции клонирования исходный процесс называют родительским, а его клон — дочерним. Помимо собственного идентификатора, каждый дочерний процесс имеет атрибут PPID (Parent Proccess ID), который совпадает с идентификатором породившего его дочернего процесса. Стоит отметить, что PPID — весьма полезная информация, если приходится иметь дело с неизвестными процессами. Отслеживание истоков процесса может облегчить понимание его назначения и значимости.

Когда система загружается, ядро самостоятельно запускает несколько процессов. Наиболее важный из них — демон init, идентификатор которого всегда равен 1. Демон init отвечает за выполнение сценариев запуска системы. Все процесса, кроме тех, что создаются ядром, являются потомками демона init. 

UID (User ID)  — это идентификатор пользователя, создавшего данный процесс. Менять атрибуты процесса могут только его создатель (владелец) и суперпользователь. EUID (Effective User ID) — это текущий пользовательский идентификатор процесса, предназначенный для того, чтобы определить, к каким ресурсам и файлам у процесса есть доступ в данный момент. У большинства программ значения UID и EUID одинаковы. Исключение составляют программы, у которых установлен бит смены идентификатора пользователя (setuid).

GID (Group ID) — это идентификатор группы, к которому принадлежит владелец процесса. Текущий идентификатор группы (EGID) связан с атрибутом GID так же, как и значение EUID связано с UID.

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

Работа с процессами в Linux

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

user@ubuntu$ ps aux

Ключ a используется для вывода всех процессов, ключ x — отображает процессы, отсоединенные от терминала, ключ u — обеспечивает фильтрование по имени или идентификатору пользователя, который запустил программу.

Значение столбцов при выводе команды ps aux:

1. USER — имя владельца процесса
2. PID — идентификатор процесса
3. %CPU — доля времени центрального процессора, которая тратится на данный процесс (в процентах)
4. %MEM — часть реальной памяти, которая тратится на данный процесс (в процентах)
5. VSZ — виртуальный размер процесса
6. RSS — количество страниц памяти
7. TTY — идентификатор управляющего терминала
8. STAT — текущий статус процесса (R-выполняется, D-ожидает записи на диск, S-неактивен, T-приостановлен, Z-зомби)
9. TIME — количество времени центрального процессора, затраченное на выполнение данного процесса
10. COMMAND — имя и аргументы команды

Ниже в сокращенном виде показаны результаты работы команды ps lax. Обратите внимание на дополнительные поля PPID (идентификатор родительского процесса), NI (фактор уступчивости), WCHAN (ресурс, которого ожидает процесс).

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

Очень удобно искать идентификатор процесса с помощью связки команд ps и grep. PS выводит список процессов, после чего передает управление команде grep, которая в свою очередь выделяет из списка искомый процесс. Пример: найдем PID для процесса cron.

Как видно PID для процесса cron равен 879.

Команда ps позволяет сделать только разовый «снимок» системы. Для динамического отслеживания процессов используют команду top.

Наиболее активные процессы находятся вверху. Команда top отображает также статистику по статусам процессов, объем используемых ресурсов ЦПУ и оперативной памяти.

Сигналы — это запросы на прерывания, реализуемые на уровне процессов.

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

Дамп памяти — это файл, содержащий образ памяти процесса

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

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

Определено свыше тридцати разных сигналов, и они находят самое разное применение. Самые распространенные из них:

1. KILL — безусловное завершение процесса на уровне ядра
2. STOP — приостанавливает выполнение процесса
3. CONT — возобновляет выполнение процесса
4. TSTP — генерируется при нажатии CTRL + Z, приостанавливает процесс пользователем
5. TERM — запрос на завершение программы (процесс осуществляет очистку и нормально завершается)
6. QUIT — то же самое, что и TERM + создается дамп памяти
7. HUP — команда сброса
8. BUS — ошибка на шине (указывает на неправильное обращение к памяти)
9. SEGV — ошибка на сегментации (указывает на неправильное обращение к памяти)

Сигналы KILL и STOP нельзя ни перехватить, ни заблокировать, ни проигнорировать.

Команда kill используется для отправки сигналов процессу. Kill имеет следующий синтаксис:

user@ubuntu$ kill [-сигнал] PID

Для примера уничтожим процесс cron. Ранее мы выяснили, что его PID = 879.

user@ubuntu$ kill -KILL 879

Как видим процесс cron убран. Сигналы типа kill надо посылать с правами суперпользователя. Также перед тем, как убивать cron я убрал строчку respawn в конфигурационном файле cron.conf, который находится в папке /etc/init/cron.conf.

Напоследок расскажу про еще одну интересную вещь. Upstart — это система инициализации ОС, которая управляет запуском демонов в течении загрузки системе. Хранятся конфигурационные файлы Upstart в папке /etc/init. Существует несколько команд для работы с Upstart.

user@ubuntu$ status [имя процесса] — статус процесса

user@ubuntu$ start [имя процесса] — запуск процесса

user@ubuntu$ stop [имя процесса] — остановка процесса

user@ubuntu$ restart [имя процесса] — рестарт процесса

Хотите оставаться на связи в любой стране? Советую приобрести первую универсальную сим-карту для путешественников DrimSIM. Интернет всего от 1 рубля за мегабайт. Звонки от 3 рублей за минуту. И это все в 197 странах. Подробнее о предложении можно узнать здесь.

Как узнать PID процесса в Linux

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

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

1. ps

Самый распространённый способ узнать PID Linux — использовать утилиту ps:

ps aux | grep имя_процесса

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

ps aux | grep имя_процесса | grep -v grep

Например, узнаём PID всех процессов, имя которых содержит слово «Apache»:

ps aux | grep apache | grep -v grep

2. pgrep

Если вам не нужно видеть подробную информацию о процессе, а достаточно только PID, то можно использовать утилиту pgrep:

pgrep apache

По умолчанию утилита ищет по командной строке запуска процесса, если нужно искать только по имени процесса, то надо указать опцию -f:

pgrep -f apache

3. pidof

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

pidof apache2

С помощью опции -s можно попросить утилиту выводить только один PID:

pidof -s apache2

4. pstree

Утилита pstree позволяет посмотреть список дочерних процессов для определённого процесса, также их pid-идентификаторы. Например, посмотрим дерево процессов Apache:

pstree -p | grep apache2

Каким процессом занят файл Linux

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

С помощью утилиты lsof можно посмотреть, какие процессы используют директорию или файл в данный момент. Например, откроем аудио-файл в плеере totem, а затем посмотрим, какой процесс использует её файл:

lsof /home/sergiy/трек.mp3

В начале строки мы видим название программы, а дальше идёт её PID. Есть ещё одна утилита, которая позволяет выполнить подобную задачу — это fuser:

fuser /home/sergiy/трек.mp3

Здесь будет выведен только файл и PID процесса. После PID идёт одна буква, которая указывает, что делает этот процесс с файлом или папкой:

• c — текущая директория;
• r — корневая директория;
• f — файл открыт для чтения или записи;
• e — файл выполняется как программа;
• m — файл подключен в качестве библиотеки.

Кто использовал файл в Linux

Узнать процесс, который сейчас занимает файл, достаточно просто. Но как узнать, какой процесс обращается к файлу не надолго, например, выполняет его как программу или читает оттуда данные? Эта задача уже труднее, но вполне решаема с помощью подсистемы ядра auditd. В CentOS набор программ для работы с этой подсистемой поставляется по умолчанию, в Ubuntu же его придётся установить командой:

sudo apt install auditd

Теперь создаём правило для мониторинга. Например, отследим, кто запускает утилиту who:

auditctl -w /usr/bin/who -p x -k who_exec

Здесь -w — адрес файла, который мы будем отслеживать, —p — действие, которое нужно отслеживать, —k — произвольное имя для правила. В качестве действия могут использоваться такие варианты:

• x — выполнение;
• w — запись;
• r — чтение;
• a — изменение атрибутов.

Теперь выполним один раз who и посмотрим, что происходит в логе с помощью команды ausearch:

sudo ausearch -i -k who_exec

Здесь в секции SYSCALL есть PID процесса, под которым была запущена программа, а также PPID — программа, которая запустила нашу who. Копируем этот PID и смотрим информацию о нём с помощью ps:

ps aux | grep 15595

Становиться понятно, что это bash.

Какой процесс использует порт в Linux

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

sudo ss -lptn 'sport = :80'

Мы видим, что это несколько процессов Apache. Использовав опцию dport, можно узнать, какой процесс отправляет данные на указанный порт:

sudo ss -lptn 'dport = :80'

Выводы

В этой статье мы рассмотрели, как узнать PID процесса в Linux по различным условиям: имени или файлу. Как видите, всё достаточно просто, и в считанные минуты можно можно понять, что происходит с вашей операционной системой, и какой процесс за это отвечает.

Дорогие читатели, если вы увидели ошибку или опечатку в статье «Id процесса что это», помогите нам ее исправить! Выделите ошибку и нажмите одновременно клавиши «Ctrl» и «Enter». Мы получим ваше сообщение и внесём исправления в ближайшее время.