Linux послать сообщение процессу

Обновлено: 30.06.2024

• TCP
• UDP
• розетки
• труб
• именованные каналы
• сопоставленные в памяти файлы

есть ли еще способы и что является самым быстрым?

Я бы предложил посмотреть на это также:Как использовать общую память с Linux в C.

в принципе, я бы отбросил сетевые протоколы, такие как TCP и UDP, при выполнении IPC на одной машине. Они имеют накладные расходы на упаковку и связаны с еще большим количеством ресурсов (например, порты, интерфейс loopback).

хотя все вышеперечисленные ответы очень хороши, я думаю, мы должны обсудить, что такое "самый быстрый" [и должно ли это быть "самым быстрым" или просто "достаточно быстрым для "?]

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

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

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

конечно, еще одно соображение должно быть "мы когда-нибудь будем использовать две отдельные машины [или две виртуальные машины в одной системе] для решения этой проблемы. В этом случае сетевое решение является лучшим выбором - даже если это не самый быстрый, я запустил локальный стек TCP на своих машинах на работе для эталонных целей и получил 20-30Gbit/s (2-3GB/s) с устойчивым трафиком. Необработанный memcpy в том же процессе получает около 50-100GBit / s (5-10GB / s) (если размер блока действительно крошечный и не вписывается в кэш L1). Я не измерил стандартную трубу, но я ожидаю, что это где-то примерно в середине этих двух чисел. [Это числа, которые примерно подходят для ряда различных средних довольно современных ПК-очевидно, на ARM, MIPS или другом встроенном контроллере стиля, ожидайте меньшее число для всех этих методов]

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

▍Команды who и mesg

Ядром скрипта являются несколько команд, которые мы ещё не обсуждали. Всё остальное должно быть вам знакомо по предыдущим материалам.

Первое, что нам тут понадобится — команда who . Она позволяет узнать сведения о пользователях, работающих в системе. В простейшем виде её вызов выглядит так:

Результаты вызова команды who

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

Команда mesg

▍Команда write

Итак, мы, работая под пользователем likegeeks , инициируем сеанс связи с пользователем testuser , который работает в терминале pts/1 , следующим образом:

Здесь результаты работы команды who передаются команде grep . Ключ -i этой команды позволяет игнорировать регистр символов. Ключ -m 1 включён в вызов команды на тот случай, если пользователь вошёл в систему несколько раз. Эта команда либо не выведет ничего, либо выведет имя пользователя (его мы укажем при вызове скрипта, оно попадёт в позиционную переменную $1 ), соответствующее первому найденному сеансу. Вывод grep мы передаём awk . Эта команда, опять же, либо не выведет ничего, либо выведет элемент, записанный в собственную переменную $1 , то есть — имя пользователя. В итоге то, что получилось, попадает в переменную logged_on .

Теперь надо проверить переменную l ogged_on , посмотреть, есть ли в ней что-нибудь:

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

Проверка статуса пользователя

Тут мы проверяем, является ли logged_on переменной с нулевой длиной. Если это так, нам сообщат о том, что в данный момент пользователь в систему не вошёл и скрипт завершит работу с помощью команды exit . В противном случае выполнение скрипта продолжится.

▍Проверка возможности записи в терминал пользователя

▍Проверка правильности вызова скрипта

Проверка параметров командной строки, указанных при вызове скрипта

▍Получение сведений о терминале пользователя

Вызов готового скрипта выглядит так:

Вот полный текст сценария:

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

Сейчас мы собираемся создать сценарий командной строки, который предназначен для поиска в заданных директориях первой десятки папок, на которые приходится больше всего дискового пространства. В этом нам поможет команда du , которая выводит сведения о том, сколько места на диске занимают файлы и папки. По умолчанию она выводит сведения лишь о директориях, с ключом -a в отчёт попадают и отдельные файлы. Её ключ -s позволяет вывести сведения о размерах директорий. Эта команда позволяет, например, узнать объём дискового пространства, который занимают данные некоего пользователя. Вот как выглядит вызов этой команды:

Для наших целей лучше подойдёт ключ -S (заглавная S), так как он позволяет получить сведения как по корневой папке, так и по вложенным в неё директориям:

Вызов команды du с ключами -s и -S

Нам нужно найти директории, на которые приходится больше всего дискового пространства, поэтому список, который выдаёт du , надо отсортировать, воспользовавшись командой sort :

Отсортированный список объектов

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

Для того, чтобы ограничить полученный список первыми десятью записями, воспользуемся потоковым редактором sed , который позволит удалить из полученного списка все строки, начиная с одиннадцатой. Следующий шаг — добавить к каждой полученной строке её номер. Тут также поможет sed , а именно — его команда N :

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

В начале строки выводится её номер, потом идёт двоеточие и знак табуляции, далее — объём дискового пространства, следом — ещё один знак табуляции и имя папки.

Соберём вместе всё то, о чём мы говорили:

Вывод сведений о дисковом пространстве

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

Переберём список с помощью цикла for и вызовем вышеописанную последовательность команд для каждого элемента списка. Вот что получилось в результате:

Получение сведений о нескольких директориях

Как видите, скрипт выводит, в виде удобного списка, сведения о директориях, список которых хранится в MY_DIRECTORIES .

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

Итоги

На сегодня это всё. В следующий раз поговорим об автоматизации работы с интерактивными утилитами с помощью expect.

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

Для начала, посмотрим кто находится в системе:

Так же, можно использовать:

Для примера, я залогинился на сервер дважды от одного и того же юзера.

-=== СПОСОБ 1 — Используем echo команду ==-

PS: Я использую в данном примере подсветку, чтобы можно было сразу ее увидеть и другому пользователю все было понятно.

-=== СПОСОБ 2 — Используем write команду ==-

Так же, можно использовать следующий пример:

Очень простая и полезная тулза.

-=== СПОСОБ 3 — Используем wall команду ==-

Доброго времени, гости моего блога! В сегодняшнем посте расскажу о том, как работают процессы в ОC Linux, а так же как управлять этими самыми процессами, о выполнении процессов в фоне, о повышении/понижении приоритета процессов.

В общем представлении, процесс - это программа, выполняющаяся в оперативной памяти компьютера. Реально, все гораздо сложней.

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

Все новые процессы в Linux порождаются клонированием какого-то уже имеющегося процесса, с помощью вызова системных функций clone(2) и fork(2) (от forking - порождение). У нового (порожденного или дочернего) процесса тоже окружение, что и у родителя, отличается только номер ID процесса (т.н. PID). Жизнь типичного процесса в Linux можно представить следующей схемой:

На которой можно описать пошагово следующие этапы:

• процесс /bin/bash клонирует себя системным вызовом fork()
• при этом создается клон /bin/bash с новым PID (идентификатор процесса) и PPID - равный PID родителя
• Клон выполняет системный вызов exec с указанием на исполняемый файл и заменяет свой код - кодом исполняемого файла (родительский процесс при этом ждет завершения потомка - wait)
  • при этом, если по каком-то причинам, потомок завершил свою работу, а родительский процесс не смог получить об этом сигнал, то данный процесс (потомок) не освобождает занятые структуры ядра и состояние процесса становиться - zombie. О состояниях процесса ниже.

  Очень наглядную схему предоставила википедия:

  
  

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

  Первый процесс в системе запускается при инициализации ядра. Данный процесс называется - init и имеет PID=1. Это прородитель всех процессов в системе. Подробнее о процессе загрузки ядра и рождении процесса init можно почитать тут.

  В каких же состояниях может находиться процесс в Linux?

  Каждый запущенный процесс в любой момент времени находится в одном из следующих состояний (которое называют еще статусом процесса):

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

  Т.к. в большинстве случаев, демоны в Linux простаивают и ожидают поступления каких-либо данных, соответственно, нужны относительно редко, так что держать их в памяти постоянно загруженными и расходовать на это ресурсы системы нерационально. Для организации работы демонов придуман демон inetd или его более защищенная модификация xinetd (eXtended InterNET Daemon или расширенный Интернет демон). В функции inetd (Xinetd) можно выделить:

  • установить ограничение на количество запускаемых серверов ( служб , демонов)
  • наблюдение за соединениями на определенных портах и обработка входящих запросов
  • ограничение доступа к сервисам на основе ACL (списков контроля доступа)

  Все процессы в системе, не важно Linux это или другая ОС, обмениваются между собой какой-либо информацией. Отсюда можно задать вопрос, а как же происходит межПРОЦЕССный обмен?

  В ОС LINUX существует несколько видов можпроцессного обмена, а точнее сказать средств межпроцессного взаимодействия (Interprocess Communication - IPC), которые можно разбить на несколько уровней:

  локальный (привязаны к процессору и возможны только в пределах компьютера);

  -- каналы

  1. pipe (они же конвейеры, так же неименованные каналы), о них я много рассказывал в прошлом посте, примером можно привести: команда1 | команда2. По сути, pipe использует stdin, stdout и stderr.
     
  2. Именованные каналы (FIFO: First In First Out). Данный вид канала создаётся с помощью mknod или mkfifo, и два различных процесса могут обратиться к нему по имени. Пример работы с fifo:

  в первом терминале (создаем именованный канал в виде файла pipe и из канала направляем данные с помощью конвейера в архиватор):

  во втором терминале (отправляем в именованный канал данные):

  в результате это приведет к сжатию передаваемых данных gzip-ом

  -- сигналы

  • с терминала, нажатием специальных клавиш или комбинаций (например, нажатие Ctrl-C генерирует SIGINT, а Ctrl-Z SIGTSTP);
  • ядром системы:
    • при возникновении аппаратных исключений (недопустимых инструкций, нарушениях при обращении в память, системных сбоях и т. п.);
    • ошибочных системных вызовах;
    • для информирования о событиях ввода-вывода;
    • из шелла, утилитой /bin/kill.

    -- разделяемая память

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

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

    удаленный;

    -- удаленные вызовы процедур (Remote Procedure Calls - RPC)

    -- сокеты Unix

    Сокеты UNIX бывают 2х типов: локальные и сетевые. При использовании локального сокета, ему присваивается UNIX-адрес и просто будет создан специальный файл (файл сокета) по заданному пути, через который смогут сообщаться любые локальные процессы путём простого чтения/записи из него. Сокеты представляют собой виртуальный объект, который существует, пока на него ссылается хотя бы один из процессов. При использовании сетевого сокета, создается абстрактный объект привязанный к слушающему порту операционной системы и сетевому интерфейсу, ему присваивается INET-адрес, который имеет адрес интерфейса и слушающего порта.

    высокоуровневый

    1. Обычно - пакеты программного обеспечения, которые реализуют промежуточный слой между системной платформой и приложением. Эти пакеты предназначены для переноса уже испытанных протоколов коммуникации приложения на более новую архитектуру. Примером можно привести: DIPC, MPI и др. (мне не знакомы, честно говоря)

    Итак. Подведем маленький итог:

    • В Linux есть процессы,
    • каждый процесс может запускать подпроцессы (нити),
    • создание нового процесса создается клонированием исходного,
    • прородителем всех процессов в системе является процесс init, запускаемый ядром системы при загрузке.
    • процессы взаимодействуют между собой по средствам можпроцессного взаимодействия:
      • каналы
      • сигналы
      • сокеты
      • разделяемая память
      • PID - идентификатор процесса
      • PPID - идентификатор процесса, породившего данный
      • UID и GID - идентификаторы прав процесса (соответствует UID и GID пользователя, от которого запущен процесс)
      • приоритет процесса
      • состояние процесса (выполнение, сон и т.п.)
      • так же у процесса есть таблица открытых (используемых) файлов

      Далее поговорим о том, как посмотреть состояние процессов в Linux и о том, как же ими управлять.

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

      Получение информации о процессе

      Перед тем как управлять процессами, нужно научиться получать о процессах необходимую информацию. В Linux существует псевдофайловая система procfs, которая в большинстве дистрибутивов монтируется в общую ФС в каталог /proc. У данной файловой системы нет физического места размещения, нет блочного устройства, такое как жесткий диск. Вся информация, хранимая в данном каталоге находится в оперативной памяти компьютера, контролируется ядром ОС и она не предназначена для хранения файлов пользователя. О структуре данного каталога я написал в статье о файловой системе Linux. В этой файловой системе дано достаточно много информации, чтобы узнать о процессах и о системе в целом.

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

      Чтобы получить список всех процессов, достаточно ввести команду:

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

      Какую информацию можно получить по каждому процессу (комментарии к некоторым полям):

      • PID, PPID – идентификатор процесса и его родителя.
      • %CPU – доля процессорного времени, выделенная процессу.
      • %MEM – процент используемой оперативной памяти.
      • VSZ – виртуальный размер процесса.
      • TTY – управляющий терминал.
      • STAT– статус процесса:
        • R – выполняется;
        • S – спит;
        • Z – зомби;
        • + — сортировка по PID;
        • + — сортировать процессы по возрасту;
        • +

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

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

        Итак, теперь об управлении процессами.

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

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

        где adnice — значение (от –20 до +19), добавляемое к значению nice процесса-родителя. Отрицательные значения может устанавливать только суперпользователь. Если опция adnice не задана, то по умолчанию для процесса-потомка устанавливается значение nice, увеличенное на 10 по сравнению со значением nice родительского процесса.

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

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

        Два сигнала – 9 ( KILL ) и 19 ( STOP ) – всегда обрабатывает система. Первый из них нужен для того, чтобы убить процесс наверняка (отсюда и название). Сигнал STOP приостанавливает процесс: в таком состояниипроцесс не удаляется из таблицы процессов, но и не выполняется до тех пор, пока не получит сигнал 18 ( CONT) – после чего продолжит работу. В Linux сигнал STOP можно передать активному процессу с помощью управляющего символа " ^Z ".

        Обычные пользователи могут посылать сигналы только тем процессам, для которых они являются владельцами. Если в команде kill воспользоваться идентификатором процесса (PID), равным -1, то указанный в команде сигнал будет послан всем принадлежащим данному пользователю процессам. Суперпользователь root может посылать сигналы любым процессам. Когда суперпользователь посылает сигнал идентификатору -1, он рассылается всем процессам, за исключением системных. Если этим сигналом будет SIGKILL, то у простых пользователей будут потеряны все открытые ими, но не сохраненные файлы данных.

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

        В оболочке bash имеются две встроенные команды, которые служат для перевода процессов на передний план или возврата их в фоновый режим. Команда fg переводит указанный в аргументе процесс на передний план, а команда bg — переводит процесс в фоновый режим. Одной командой bg можно перевести в фоновый режим сразу несколько процессов, а вот возвращать их на передний план необходимо по одному. Аргументами команд fg и bg могут являться только номера заданий, запущенных из текущего экземпляра shell. Возможные значения заданий можно увидеть, выполнив команду jobs.

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

        Запущенный таким образом процесс будет игнорировать посылаемые ему сигналы (не игнорируются только сигналы SIGHUP и SIGQUIT). Хочу так же выделить команду pstree, которая показывает дерево процессов. Очень наглядно, кстати.

        Ну вот. как-то так. Буду рад любым комментариям и дополнениям.

        Upd 2011.11.19: небольшой рестайлинг и дополнение информации о сигналах.

        Читайте также:

          
        • Сообщение по астрономии время и календарь
          
        • Газпром нефтехим салават сообщение
          
        • Что содержит узловое сообщение
          
        • Решение задач на пк сообщение
          
        • Сообщение о социальных отношениях