Как Ctrl-C завершает дочерний процесс?

Ответ 1

Сигналы по умолчанию обрабатываются ядром. Старые системы Unix имели 15 сигналов; теперь у них больше. Вы можете проверить </usr/include/signal.h> (или kill -l). CTRL + C - это сигнал с именем SIGINT.

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

Все сигналы (но SIGKILL) могут обрабатываться программой.

И вот что делает оболочка:

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

Вы можете trap сигнализировать в своей оболочке script тоже...

И вы можете настроить обработку сигналов для своей интерактивной оболочки, попробуйте ввести это в верхней части ~/.profile. (Убедитесь, что вы уже вошли в систему и протестировали его с помощью другого терминала - вы можете заблокировать себя)

trap 'echo "Dont do this"' 2

Теперь, каждый раз, когда вы нажимаете CTRL + C в своей оболочке, он печатает сообщение. Не забудьте удалить строку!

Если вы заинтересованы, вы можете проверить обычную старую обработку сигнала /bin/sh в исходном коде здесь.

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

Ответ 2

Сначала прочитайте статью Википедии о терминальном интерфейсе POSIX.

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

Сам процесс оболочки находится в еще одной группе процессов, и он не получает сигнал, когда одна из этих групп процессов находится на переднем плане. Это просто.

Ответ 3

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

Никакой процесс не обязательно принудительно закрывается (хотя по умолчанию, если вы не обрабатываете sigint, я считаю, что поведение должно вызывать abort(), но мне нужно будет это посмотреть).

Конечно, текущий процесс изолирован от оболочки, которая запустила его.

Если вам нужна родительская оболочка, запустите свою программу с помощью exec:

exec ./myprogram

Таким образом, родительская оболочка заменяется дочерним процессом

Ответ 4

CTRL + C - это карта команды kill. Когда вы нажимаете на них, kill посылает сигнал SIGINT, который прерывает процесс.

Убить: http://en.wikipedia.org/wiki/Kill_ (команда)

SIGINT: http://en.wikipedia.org/wiki/SIGINT_ (POSIX)

Ответ 5

setpgid POSIX C группа процессов минимальный пример

Это может быть легче понять с помощью минимального работоспособного примера базового API.

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

main.c:

#define _XOPEN_SOURCE 700
#include <assert.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

volatile sig_atomic_t is_child = 0;

void signal_handler(int sig) {
    char parent_str[] = "sigint parent\n";
    char child_str[] = "sigint child\n";
    signal(sig, signal_handler);
    if (sig == SIGINT) {
        if (is_child) {
            write(STDOUT_FILENO, child_str, sizeof(child_str) - 1);
        } else {
            write(STDOUT_FILENO, parent_str, sizeof(parent_str) - 1);
        }
    }
}

int main(int argc, char **argv) {
    pid_t pid, pgid;

    (void)argv;
    signal(SIGINT, signal_handler);
    signal(SIGUSR1, signal_handler);
    pid = fork();
    assert(pid != -1);
    if (pid == 0) {
        /* Change the pgid.
         * The new one is guaranteed to be different than the previous, which was equal to the parent's,
         * because 'man setpgid' says:
         * > the child has its own unique process ID, and this PID does not match
         * > the ID of any existing process group (setpgid(2)) or session.
         */
        is_child = 1;
        if (argc > 1) {
            setpgid(0, 0);
        }
        printf("child pid, pgid = %ju, %ju\n", (uintmax_t)getpid(), (uintmax_t)getpgid(0));
        assert(kill(getppid(), SIGUSR1) == 0);
        while (1);
        exit(EXIT_SUCCESS);
    }
    /* Wait until the child sends a SIGUSR1. */
    pause();
    pgid = getpgid(0);
    printf("parent pid, pgid = %ju, %ju\n", (uintmax_t)getpid(), (uintmax_t)pgid);
    /* man kill explains that negative first argument means to send a signal to a process group. */
    kill(-pgid, SIGINT);
    while (1);
}

GitHub вверх по течению.

Компилировать с:

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -Wpedantic -o setpgid setpgid.c

Запустить без setpgid

Без аргументов CLI setpgid не выполняется:

./setpgid

Возможный результат:

child pid, pgid = 28250, 28249
parent pid, pgid = 28249, 28249
sigint parent
sigint child

и программа зависает.

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

Тогда всякий раз, когда вы нажмете:

Ctrl + C

Он выводит снова:

sigint parent
sigint child

Это показывает, как:

• отправить сигнал всей группе процессов с помощью kill(-pgid, SIGINT)
• Ctrl + C на терминале по умолчанию отправляет уничтожение всей группе процессов

Выйдите из программы, отправив разные сигналы обоим процессам, например, SIGQUIT с помощью Ctrl + \.

Запустить с setpgid

Если вы запускаете с аргументом, например:

./setpgid 1

потом потомок меняет свой pgid, и теперь каждый раз из одного родителя печатается только один sigint:

child pid, pgid = 16470, 16470
parent pid, pgid = 16469, 16469
sigint parent

Вы по-прежнему можете убить родителя, как и раньше, с помощью SIGQUIT:

Ctrl + \

однако у ребенка теперь есть другой PGID, и он не получает этот сигнал! Это видно из:

ps aux | grep setpgid

Вам придется убить его явно с помощью:

kill -9 16470

Это проясняет, почему существуют группы сигналов: в противном случае мы бы получили кучу процессов, которые будут очищаться вручную все время.

Проверено на Ubuntu 18.04.