Comment traiter le signal en python sur une machine windows

Python os.kill enveloppements deux indépendants des Api Windows. Il appelle GenerateConsoleCtrlEvent lorsque le sig paramètre est CTRL_C_EVENT ou CTRL_BREAK_EVENT. Dans ce cas, le pid paramètre est un processus d'ID de groupe. Si le dernier appel échoue, et pour tous les autres sig valeurs, il appelle OpenProcess et puis TerminateProcess. Dans ce cas, le pid paramètre est un IDENTIFIANT de processus et la sig valeur est passée comme le code de sortie. Terminaison d'un processus de Windows ressemble à l'envoi de SIGKILL à un processus POSIX. En général, cela devrait être évitée, car elle ne permet pas l'arrêt du processus proprement.

Noter que les docs pour os.kill tort de prétendre que la "kill() en outre, prend processus de poignées pour être tué", qui n'a jamais été vrai. Il appelle OpenProcess pour obtenir un handle de processus.

La décision d'utiliser WinAPI CTRL_C_EVENT et CTRL_BREAK_EVENT, au lieu de SIGINT et SIGBREAK, est malheureux pour la croix-plate-forme de code. Il n'est également pas défini ce GenerateConsoleCtrlEvent n'lorsqu'il est passé d'un ID de processus qui n'est pas un processus ID de groupe. L'utilisation de cette fonction dans une API qui prend un ID de processus est douteux, au mieux, et potentiellement très mal.

Pour vos besoins particuliers, vous pouvez écrire un adaptateur fonction qui rend os.kill un peu plus convivial pour la croix-plate-forme de code. Par exemple:

import os
import sys
import time
import signal
if sys.platform != 'win32':
kill = os.kill
sleep = time.sleep
else: 
# adapt the conflated API on Windows.
import threading
sigmap = {signal.SIGINT: signal.CTRL_C_EVENT,
signal.SIGBREAK: signal.CTRL_BREAK_EVENT}
def kill(pid, signum):
if signum in sigmap and pid == os.getpid():
# we don't know if the current process is a
# process group leader, so just broadcast
# to all processes attached to this console.
pid = 0
thread = threading.current_thread()
handler = signal.getsignal(signum)
# work around the synchronization problem when calling
# kill from the main thread.
if (signum in sigmap and
thread.name == 'MainThread' and
callable(handler) and
pid == 0):
event = threading.Event()
def handler_set_event(signum, frame):
event.set()
return handler(signum, frame)
signal.signal(signum, handler_set_event)                
try:
os.kill(pid, sigmap[signum])
# busy wait because we can't block in the main
# thread, else the signal handler can't execute.
while not event.is_set():
pass
finally:
signal.signal(signum, handler)
else:
os.kill(pid, sigmap.get(signum, signum))
if sys.version_info[0] > 2:
sleep = time.sleep
else:
import errno
# If the signal handler doesn't raise an exception,
# time.sleep in Python 2 raises an EINTR IOError, but
# Python 3 just resumes the sleep.
def sleep(interval):
'''sleep that ignores EINTR in 2.x on Windows'''
while True:
try:
t = time.time()
time.sleep(interval)
except IOError as e:
if e.errno != errno.EINTR:
raise
interval -= time.time() - t
if interval <= 0:
break
def func(signum, frame):
# note: don't print in a signal handler.
global g_sigint
g_sigint = True
#raise KeyboardInterrupt
signal.signal(signal.SIGINT, func)
g_kill = False
while True:
g_sigint = False
g_kill = not g_kill
print('Running [%d]' % os.getpid())
sleep(2)
if g_kill:
kill(os.getpid(), signal.SIGINT)
if g_sigint:
print('SIGINT')
else:
print('No SIGINT')

Discussion

Windows n'est pas de mettre en œuvre les signaux au niveau du système [*]. Microsoft C runtime met en œuvre les six signaux qui sont requis par la norme C: SIGINT, SIGABRT, SIGTERM, SIGSEGV, SIGILL, et SIGFPE.

SIGABRT et SIGTERM sont mis en place seulement pour le processus en cours. Vous pouvez appeler le gestionnaire via C augmenter. Par exemple (en Python 3.5):

>>> import signal, ctypes
>>> ucrtbase = ctypes.CDLL('ucrtbase')
>>> c_raise = ucrtbase['raise']
>>> foo = lambda *a: print('foo')
>>> signal.signal(signal.SIGTERM, foo)
<Handlers.SIG_DFL: 0>
>>> c_raise(signal.SIGTERM)
foo
0

SIGTERM est inutile.

Vous aussi vous ne pouvez pas faire grand chose avec SIGABRT en utilisant le module du signal car le annuler fonction tue le processus une fois que le gestionnaire retourne, qui se produit immédiatement lorsque vous utilisez le module de signal interne du gestionnaire (il se déclenche un drapeau pour le régime enregistré d'Python appelable à être appelé dans le thread principal). Pour Python 3, vous pouvez utiliser à la place la faulthandler module. Ou appelez le CRT est signal fonction via ctypes pour définir un ctypes rappel que le gestionnaire.

Le CRT met en œuvre SIGSEGV, SIGILL, et SIGFPE par la fixation d'un Windows structuré gestionnaire d'exception pour les Fenêtres correspondantes exceptions:

STATUS_ACCESS_VIOLATION          SIGSEGV
STATUS_ILLEGAL_INSTRUCTION       SIGILL
STATUS_PRIVILEGED_INSTRUCTION    SIGILL
STATUS_FLOAT_DENORMAL_OPERAND    SIGFPE
STATUS_FLOAT_DIVIDE_BY_ZERO      SIGFPE
STATUS_FLOAT_INEXACT_RESULT      SIGFPE
STATUS_FLOAT_INVALID_OPERATION   SIGFPE
STATUS_FLOAT_OVERFLOW            SIGFPE
STATUS_FLOAT_STACK_CHECK         SIGFPE
STATUS_FLOAT_UNDERFLOW           SIGFPE
STATUS_FLOAT_MULTIPLE_FAULTS     SIGFPE
STATUS_FLOAT_MULTIPLE_TRAPS      SIGFPE

Le CRT de la mise en œuvre de ces signaux est incompatible avec Python de traitement de signal. L'exception filtre les appels enregistrés gestionnaire, puis retourne EXCEPTION_CONTINUE_EXECUTION. Cependant, Python gestionnaire seuls les voyages d'un drapeau pour l'interprète d'appeler le régime enregistré d'callable un peu plus tard dans le thread principal. Ainsi, l'errant, le code qui a déclenché l'exception de continuer à déclencher dans une boucle sans fin. En Python 3, vous pouvez utiliser le faulthandler module d'exception pour ces signaux.

Qui laisse SIGINT, pour qui Windows ajoute la non-standard SIGBREAK. Les deux console et non de la console de processus peuvent raise ces signaux, mais seulement un processus de console peut recevoir d'un autre processus. Le CRT met en œuvre par l'enregistrement d'une console de contrôle du gestionnaire d'événement via SetConsoleCtrlHandler.

La console envoie un événement de contrôle par la création d'un nouveau thread en pièce jointe dans un processus qui commence à s'exécuter à CtrlRoutine dans kernel32.dll ou kernelbase.dll (sans-papiers). Que le gestionnaire ne pas exécuter dans le thread principal peut conduire à des problèmes de synchronisation (par exemple, dans le REPL ou avec input). Aussi, un événement de contrôle de ne pas interrompre le thread principal si elle est bloquée en attente sur un objet de synchronisation ou en attente d'e/S synchrones à compléter. Les soins doivent être prises pour éviter de bloquer le thread principal si elle doit être interruptible par SIGINT. Python 3 tentatives de contourner ce problème en utilisant un Windows événement de l'objet, qui peut également être utilisé en attend que devrait être interruptible par SIGINT.

Lorsque la console envoie le processus CTRL_C_EVENT ou CTRL_BREAK_EVENT, le CRT du gestionnaire d'appels enregistrés SIGINT ou SIGBREAK gestionnaire, respectivement. Le SIGBREAK gestionnaire est également appelé à la CTRL_CLOSE_EVENT que la console envoie quand la fenêtre est fermée. Python par défaut de la manipulation SIGINT par rasing un KeyboardInterrupt dans le thread principal. Cependant, SIGBREAK est d'abord le défaut CTRL_BREAK_EVENT gestionnaire, qui appelle ExitProcess(STATUS_CONTROL_C_EXIT).

Vous pouvez envoyer un événement de contrôle de tous les processus attachés à la console via GenerateConsoleCtrlEvent. Cela peut cibler un sous-ensemble de processus qui appartiennent à un groupe de processus, ou un groupe cible de 0 à envoyer l'événement à tous les processus attachés à la console actuelle.

Groupes de processus ne sont pas bien documentés aspect de l'API Windows. Il n'y a pas de public API pour interroger le groupe d'un processus, mais tous les processus dans une session Windows appartient à un groupe de processus, même si c'est juste la wininit.exe groupe (session des services) ou winlogon.exe groupe (session interactive). Un nouveau groupe est créé par le passage de la création du drapeau CREATE_NEW_PROCESS_GROUP lors de la création d'un nouveau processus. Le groupe ID est l'ID de processus du processus créé. À ma connaissance, la console est le seul système qui utilise les processus de groupe, et c'est juste pour GenerateConsoleCtrlEvent.

Ce que la console n'lorsque l'ID de la cible n'est pas un groupe de processus ID n'est pas défini et ne doit pas être invoqué. Si à la fois le processus et de son processus parent sont attachés à la console, puis l'envoi d'un événement de contrôle agit fondamentalement comme l'objectif du groupe est de 0. Si le processus parent n'est pas attaché à la console, puis GenerateConsoleCtrlEvent échoue, et os.kill appels TerminateProcess. Bizarrement, si vous ciblez le "Système" de processus (PID 4) et de ses processus enfant smss.exe (gestionnaire de session), l'appel réussit, mais rien ne se passe sauf que la cible est à tort ajouté à la liste des processus attachés (c'est à dire GetConsoleProcessList). C'est probablement parce que le processus parent est le "Ralenti", qui, depuis c'est le PID 0, est implicitement accepté que la diffusion PGID. Le processus parent règle s'applique également aux non-console de processus. Le ciblage d'un non-console processus enfant ne fait rien-sauf à tort endommager la console la liste des processus en ajoutant de la seule processus. J'espère qu'il est clair que vous ne devez envoyer un événement de contrôle dans le groupe 0 ou à un connu processus de groupe que vous avez créé via CREATE_NEW_PROCESS_GROUP.

Ne comptez pas sur d'être en mesure d'envoyer CTRL_C_EVENT à rien, mais le groupe 0, puisque c'est d'abord désactivé dans un nouveau groupe de processus. Il n'est pas impossible d'envoyer cet événement à un nouveau groupe, mais le processus cible première est de permettre CTRL_C_EVENT en appelant SetConsoleCtrlHandler(NULL, FALSE).

CTRL_BREAK_EVENT est tout ce que vous pouvez compter sur, car il ne peut pas être désactivé. L'envoi de cet événement est un moyen simple pour normalement tuer un processus enfant qui a commencé avec CREATE_NEW_PROCESS_GROUP, en supposant qu'il a un Windows CTRL_BREAK_EVENT ou C SIGBREAK gestionnaire. Si non, le gestionnaire par défaut va se terminer le processus, le réglage du code de sortie pour STATUS_CONTROL_C_EXIT. Par exemple:

>>> import os, signal, subprocess
>>> p = subprocess.Popen('python.exe',
...         stdin=subprocess.PIPE,
...         creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
>>> os.kill(p.pid, signal.CTRL_BREAK_EVENT)
>>> STATUS_CONTROL_C_EXIT = 0xC000013A
>>> p.wait() == STATUS_CONTROL_C_EXIT
True

Noter que CTRL_BREAK_EVENT n'était pas envoyé la procédure en cours, car l'exemple d'objectifs le groupe de processus de le processus de l'enfant (y compris l'ensemble de ses processus enfants qui sont attachés à la console, et ainsi de suite). Si on a utilisé du groupe 0, le processus actuel aurait été tué ainsi puisque je n'ai pas de définir un SIGBREAK gestionnaire. Nous allons essayer, mais avec un gestionnaire d'ensemble:

>>> ctrl_break = lambda *a: print('^BREAK')
>>> signal.signal(signal.SIGBREAK, ctrl_break)
<Handlers.SIG_DFL: 0>
>>> os.kill(0, signal.CTRL_BREAK_EVENT)
^BREAK

---

[*]

Windows a les appels de procédure asynchrone (APC) de la file d'attente une fonction cible à un fil. Voir l'article À l'intérieur de NT de l'Appel de Procédure Asynchrone pour une analyse en profondeur de Windows Apc, en particulier pour clarifier le rôle de noyau de mode Apc. Vous pouvez file d'attente de l'utilisateur, le mode APC à un thread via QueueUserAPC. Ils ont aussi mis en file d'attente par ReadFileEx et WriteFileEx pour la fin d'e/S de routine.

Un utilisateur en mode APC s'exécute lorsque le thread entre dans une alertable d'attente (par exemple, WaitForSingleObjectEx ou SleepEx avec bAlertable comme TRUE). En mode noyau de l'Apc, d'autre part, d'obtenir expédiés immédiatement (lors de l'IRQL est ci-dessous APC_LEVEL). Ils sont généralement utilisés par le gestionnaire d'e/S à compléter asynchronous I/O les Paquets de Demande dans le contexte du thread qui a émis la demande (par exemple, la copie de données à partir de l'IRP à une mémoire tampon en mode utilisateur). Voir Attend et les Apc pour un tableau qui montre comment les Apc affecter alertable et non alertable attend. Notez qu'en mode noyau de l'Apc de ne pas interrompre une attente, mais au lieu de cela sont effectuées à l'interne par l'attente de la routine.

Windows pourrait mettre en œuvre POSIX comme signaux à l'aide de l'Apc, mais dans la pratique, on utilise d'autres moyens pour les mêmes fins. Par exemple:

• La Gestion Structurée Des Exceptions, par exemple __essayer, __à l'exception de, __enfin, __laisser, RaiseException, AddVectoredExceptionHandler.

• Répartiteur De Noyau D'Objets (c'est à dire Les Objets De Synchronisation), par exemple SetEvent, SetWaitableTimer.

• Fenêtre de Messages, par exemple SendMessage (à une procédure de fenêtre), PostMessage (à un thread de message de la file d'attente pour être expédié à une procédure de fenêtre), PostThreadMessage (à un thread de message de la file d'attente), WM_CLOSE, WM_TIMER.

Fenêtre de messages peuvent être transmis et affiché à tous les threads que la part de l'appelant fil de bureau et qui sont à la même ou plus bas niveau d'intégrité. L'envoi d'un message de fenêtre met dans un système de file d'attente à l'appel de la procédure de fenêtre lorsque le thread appelle PeekMessage ou GetMessage. Poster un message, il ajoute au fil du message de la file d'attente, qui a un quota par défaut de 10 000 messages. Un thread avec un message de la file d'attente doit avoir une boucle de message pour traiter la file d'attente via GetMessage et DispatchMessage. Threads dans une console processus n'ont généralement pas de file d'attente de messages. Cependant, la console de l'hôte processus, conhost.exe, n'est évidemment. Lorsque le bouton de fermeture est cliqué, ou lorsque le processus principal de la console est tué via le gestionnaire des tâches ou taskkill.exe, un WM_CLOSE message est posté sur la file d'attente de message de la fenêtre de la console de fil. La console dans les virages envoie un CTRL_CLOSE_EVENT à l'ensemble de ses processus attachés. Si un processus gère l'événement, c'est 5 secondes de fermer correctement avant d'être fermée.