señal de llamada después de la horquilla

Question

¿Hay alguna diferencia entre "código listado 1" y "código listado 2"? Debido a que en el Listado de Código 1, el proceso secundario es capaz de atrapar la señal SIGTERM y salir muy bien. Pero la lista de códigos 2 está terminando abruptamente en la señal SIGTERM.

estoy usando Linux y C.

Listado de Código 1

if (signal(SIGTERM, stopChild) == SIG_ERR) { 
    printf("Could not attach signal handler\n"); 
    return EXIT_FAILURE; 
} 
pid = fork(); 

Listado de Código 2

pid = fork(); 
if (signal(SIGTERM, stopChild) == SIG_ERR) { 
    printf("Could not attach signal handler\n"); 
    return EXIT_FAILURE; 
} 

La parte extraña es que en Listado de Código 2, los procesos hijo y principal configuran el controlador de señal para SIGTERM. Entonces, se supone que esto debe funcionar. ¿No es así?

Answer 1

Si envía el SIGTERM de la matriz, el resultado final depende del orden en que se programen los procesos.

Si el niño se programó en primer lugar, todo funciona:

           +---------------+ 
               | pid = fork(); | 
               +-------+-------+ 
        parent        |        child 
          +-----------------------------+-----------------------------+ 
          |               | 
          |         +-------------------------+--------------------------+ 
          |         | if (signal(SIGTERM, stopChild) == SIG_ERR) {  | 
          |         |  printf("Could not attach signal handler\n"); | 
          |         |  return EXIT_FAILURE;       | 
          |         | }             | 
          |         +-------------------------+--------------------------+ 
          |               | 
          .               . 
          .               . 
          .               . 
          |               | 
+-------------------------+--------------------------+        | 
| if (signal(SIGTERM, stopChild) == SIG_ERR) {  |        | 
|  printf("Could not attach signal handler\n"); |        | 
|  return EXIT_FAILURE;       |        | 
| }             |        | 
+-------------------------+--------------------------+        | 
          |               | 
          |               | 
          |               | 
      +-------------+-------------+            | 
      | if (pid > 0) {   |            | 
      |  kill(pid, SIGTERM); |            | 
      | }       |            | 
      +-------------+-------------+            | 
          |               | 
          |               | 
          |               | 

Pero si el paren se programó en primer lugar, el niño puede no haber tenido tiempo para configurar el controlador de señal:

           +---------------+ 
               | pid = fork(); | 
               +-------+-------+ 
        parent        |        child 
          +-----------------------------+-----------------------------+ 
          |               | 
+-------------------------+--------------------------+        | 
| if (signal(SIGTERM, stopChild) == SIG_ERR) {  |        | 
|  printf("Could not attach signal handler\n"); |        | 
|  return EXIT_FAILURE;       |        | 
| }             |        | 
+-------------------------+--------------------------+        | 
          |               | 
          |               | 
          |               | 
      +-------------+-------------+            | 
      | if (pid > 0) {   |            | 
      |  kill(pid, SIGTERM); |            | 
      | }       |            | 
      +-------------+-------------+            | 
          |               | 
          .               . 
          .               . 
          .               . 
          |               | 
          |         +-------------------------+--------------------------+ 
          |         | if (signal(SIGTERM, stopChild) == SIG_ERR) {  | 
          |         |  printf("Could not attach signal handler\n"); | 
          |         |  return EXIT_FAILURE;       | 
          |         | }             | 
          |         +-------------------------+--------------------------+ 
          |               | 
          |               | 
          |               | 

Este se llama raza condición, porque el resultado final depende de quién se ejecuta primero.

Answer 2

Pues bien, según el hombre tenedor:

El tenedor(), fork1(), y forkall() Funciones de crear un nuevo proceso. El espacio de direcciones del nuevo proceso (proceso secundario) es una copia exacta del espacio de direcciones del proceso de llamada (proceso principal). El proceso hijo hereda los atributos siguientes del proceso principal:

...

los valores de manejo o la señal (es decir, SIG_DFL, SIG_IGN, SIG_HOLD, dirección de función)

En el primer ejemplo el controlador de señal se copiará desde el contexto del padre al hijo bifurcado. Pero no puedo explicar por qué en el segundo ejemplo de configuración, el controlador de señal en el niño fallaría.

Answer 3

En primer lugar, signal() está en desuso, es mejor usar sigaction(). No creo que fork() esté en peligro de desaparecer del todo, ya que muchas cosas lo usan, pero sigaction() proporciona una interfaz mucho más agradable.

El comportamiento que está experimentando normalmente se produce llamando al tenedor() desde dentro de un subproceso. POSIX aborda esta specifically:

Un proceso se crea con un solo hilo . Si un proceso multiproceso de llama fork(), el nuevo proceso contendrá una réplica de la cadena de llamada y su espacio de direcciones completo, incluyendo posiblemente los estados de mutexes y otros recursos. En consecuencia, para evitar errores, el proceso hijo solo puede ejecutar operaciones async-signal-safe hasta en el momento en que se llame a una de las funciones de exec. [THR] Los manipuladores de horquillas pueden establecerse por medio de la función pthread_atfork() para mantener invariantes de aplicación a través de llamadas fork().

Cuando el tenedor llamadas de aplicación() desde un manejador de señal y cualquiera de los tenedor manipuladores registrados por pthread_atfork() llama a una función que no está desincronizado-señal segura, el comportamiento es indefinido.

Esto significa que, en lugar de heredar una copia de todo el espacio de direcciones de los padres, que heredan sólo una copia de las llamadas roscas espacio de direcciones, que no contiene los controladores. Podría ser concebible que estés, de hecho (quizás incluso inconscientemente) llamando fork() desde dentro de un hilo.

Un proceso secundario obtiene una copia del espacio de direcciones del padre. La única diferencia con las señales sería pendientes de las señales, que el niño no recibirá ya que recibe un conjunto de señales inicializado a cero. Pero sí, sí recibe una copia de los controladores.