verificar - ver procesos pid linux

¿Cómo puedo saber en Linux qué proceso envió una señal a mi proceso?

Question

Tengo una aplicación java que tiene SIG TERM . Quiero saber el pid del proceso que envió esta señal.
¿Es eso posible?

Answer 1

Dos métodos específicos de Linux son SA_SIGINFO y signalfd() , que permite a los programas recibir información muy detallada sobre las señales enviadas, incluido el PID del remitente.

• Llame a SA_SIGINFO y struct sigaction una struct sigaction que tenga el manejador de señal deseado en sa_sigaction y el indicador sa_flags en el conjunto sa_flags . Con este indicador, su manejador de señales recibirá tres argumentos, uno de los cuales es una estructura siginfo_t que contiene el PID y el UID del remitente.

• Llame a signalfd() y lea signalfd_siginfo estructuras signalfd_siginfo desde él (generalmente en algún tipo de bucle de selección / encuesta). Los contenidos serán similares a siginfo_t .

Cuál utilizar depende de cómo se escribe su aplicación; probablemente no funcionarán bien fuera de C, y no tendría ninguna esperanza de que funcionen en Java. Tampoco son portátiles fuera de Linux. También es probable que sean la manera muy incorrecta de hacer lo que estás tratando de lograr.

Answer 2

No, las señales no son un canal de comunicación entre procesos. Que yo sepa, no hay PID aprobado. El PID de envío es irrelevante para todos los usos que he visto para las señales. Puede estar relativamente seguro de que los procesos que envían la señal tenían privilegios de raíz o pertenecían al mismo UID que su proceso.

Es posible que el proceso que envió la señal ya no exista. Si se usó el comando kill en lugar del shell incorporado, es casi seguro que el proceso ya no existe.

Desde el lado de Java esto es aún más difícil. El proceso se ejecuta en una máquina virtual Java, que se abstrae del sistema operativo. No todos los conceptos de sistema operativo existen con esta máquina.

Answer 3

También necesitaba identificar el remitente de la señal en un programa, así que tomé la answer de Grawity y la utilicé en mi programa, funciona bien.

Aquí está el código de ejemplo:

send_signal_raise.c

// send signal to self test - raise()
#include <stdio.h>
#include <signal.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
static int int_count = 0, max_int = 5;
static struct sigaction siga;
static void multi_handler(int sig, siginfo_t *siginfo, void *context) {
// get pid of sender,
pid_t sender_pid = siginfo->si_pid;
if(sig == SIGINT) {
int_count++;
printf("INT(%d), from [%d]/n", int_count, (int)sender_pid);
return;
} else if(sig == SIGQUIT) {
printf("Quit, bye, from [%d]/n", (int)sender_pid);
exit(0);
}
return;
}
int raise_test() {
// print pid
printf("process [%d] started./n", (int)getpid());
// prepare sigaction
siga.sa_sigaction = *multi_handler;
siga.sa_flags |= SA_SIGINFO; // get detail info
// change signal action,
if(sigaction(SIGINT, &siga, NULL) != 0) {
printf("error sigaction()");
return errno;
}
if(sigaction(SIGQUIT, &siga, NULL) != 0) {
printf("error sigaction()");
return errno;
}
// use "ctrl + c" to send SIGINT, and "ctrl + /" to send SIGQUIT,
int sig;
while(1) {
if(int_count < max_int) {
sig = SIGINT;
} else {
sig = SIGQUIT;
}
raise(sig); // send signal to itself,
sleep(1); // sleep a while, note that: SIGINT will interrupt this, and make program wake up,
}
return 0;
}
int main(int argc, char *argv[]) {
raise_test();
return 0;
}

Compilar:

gcc -pthread -Wall send_signal_raise.c

Ejecutar:

./a.out

Que hace:

El programa envía SIGINT a sí mismo 10 veces, antes de enviar SIGQUIT para terminarse.

Además, durante su ejecución, presione CTRL + C para enviar SIGINT , o CTRL + / para enviar SIGQUIT que terminará el programa a mano.

El programa pudo identificar con éxito quién envió la (s) señal (es).