Véase aquí
Il y a dos des signaux qui peuvent suspendre l'exécution d'un processus. L'un est "gracieux", l'autre est "forcé".
Le "gracieux" est SIGTSTP et son but est de demander "gentiment" au processus, s'il en a envie, de suspendre son exécution jusqu'à ce qu'il reçoive un SIGCONT . Dans le cas de SIGTSTP le processus peut ignorer SIGTSTP et continuer à s'exécuter de toute façon, ce qui nécessite la coopération d'un programme conçu pour gérer SIGTSTP.
Celui qui est "énergique" est SIGSTOP et son but est de suspendre tous les threads de l'espace utilisateur associés à ce processus. Il est tout aussi impossible que le processus ignore SIGSTOP comme il l'est pour elle d'ignorer SIGKILL (ce dernier tue le processus avec force).
Pour envoyer un signal arbitraire, y compris n'importe lequel de ceux mentionnés ici, vous pouvez utiliser des programmes tels que kill , killall ou pkill ; ou utiliser l'appel système kill(2) . Consultez les pages de manuel de votre système d'exploitation pour obtenir des détails dépendants de la plate-forme/architecture/version et des errata concernant les éléments ci-dessus. Notez que le mot "kill" dans toutes ces commandes et dans le syscall est un mauvais terme. Ces commandes sont no conçu, exclusivement, pour mettre fin aux processus. Ils puede Mais les signaux peuvent également être utilisés pour d'autres fonctionnalités que la fin d'un processus. Par exemple, SIGSTOP ne fait que suspendre le processus, et ce n'est qu'un des nombreux signaux qui peuvent être envoyés de cette façon.
Pour ajouter une condition de reprise automatique du processus après une certaine période de temps, vous devrez utiliser une sorte de processus de surveillance qui reste en cours d'exécution et définit une minuterie afin de réveiller le processus de surveillance, qui appelle à son tour kill(2) à nouveau et envoie le SIGCONT au processus arrêté, afin de demander au noyau de reprendre l'exécution. Notez que Linux dispose de plusieurs mécanismes de chronométrage avec différents degrés d'exactitude et de précision ; en outre, si votre système est très occupé, votre processus de surveillance peut ne pas être réveillé avant que son chronomètre n'ait expiré, et le réveil peut donc être retardé.
Si vous dépendez de la précision très précise de la suspension et de la reprise du processus suspendu, vous devrez peut-être exécuter votre programme de surveillance avec des autorisations en temps réel (cf. cette page de manuel sur sched_setscheduler(2) pour des informations sur la façon de rendre votre processus en temps réel). Vous pouvez également utiliser les High-Resolution Timers, une fonctionnalité du noyau Linux (qui n'est disponible que si votre matériel les prend en charge), en combinaison avec la planification en temps réel, pour obtenir très une précision inférieure à la milliseconde sur le timing, puis se réveiller et envoyer le signal pour reprendre le processus surveillé très rapidement.
Vous n'avez pas indiqué quelles technologies vous êtes prêt à utiliser pour mettre en œuvre cette solution. Au minimum, vous aurez besoin d'un script bash, bien que vous ne puissiez pas obtenir un timing très fin de cette façon. Voici un script bash "script" (non testé, donc faites attention) qui est juste une preuve de concept de votre requête. Si vous avez besoin d'un timing précis, vous devrez écrire un programme, probablement en C/C++ ou dans un autre langage natif, et utiliser l'ordonnancement en temps réel et les hrtimers.
#!/bin/bash
#This is the process you want to suspend.
screen -mdS child bash -c "cat /dev/urandom | base64"
#This is the process ID of the child process
THEPID=$(screen -list | grep child | cut -f1 -d'.' | sed 's/\W//g')
#Send SIGSTOP to the child process.
kill -SIGSTOP ${THEPID}
#Now it is suspended. This process will sleep for 10 seconds asynchronously, then resume the process.
screen -mdS monitor bash -c "sleep 10; kill -SIGCONT ${THEPID}"
Notez que le script se terminera et le script de contrôle se terminera, mais en raison de screen contrôlant le processus de surveillance, il continuera à fonctionner en arrière-plan pendant 10 secondes (en fonction de l'argument passé à la commande sleep ) et ensuite se réveiller et continuer le processus de l'enfant. Mais cela se fera longtemps après que le script de contrôle se soit terminé. Si vous voulez attendre de manière synchrone que le temps s'écoule, il suffit d'omettre le deuxième appel à screen et coder en dur le sleep et le kill dans le script de contrôle.
Vous pouvez vérifier que le processus est bien suspendu en exécutant la commande suivante
screen -rS child
après avoir lancé ce script. Vous ne verrez rien sur la console. Puis, après l'expiration du timer (10 secondes), il inondera votre écran de données base64 (caractères aléatoires de 0-9 et A-F). Appuyez sur Ctrl+C pour quitter.
