Le gestionnaire de sigaction ne ferme pas le processus

J’ai le code de gestionnaire de sigaction suivant

void signal_term_handler(int sig) { int rc = async_lockf(pid_file, F_UNLCK); if(rc) { char piderr[] = "PID file unlock failed!\n"; write(STDOUT_FILENO, piderr, (sizeof(piderr))-1); } close(pid_file); char exitmsg[] = "EXIT Daemon:TERM signal Received!\n"; write(STDOUT_FILENO, exitmsg, (sizeof(exitmsg))-1); _exit(EXIT_SUCCESS); //async-signal-save exit } 

Tous les appels de fonction dans la fonction ci-dessus constituent une sauvegarde de signal asynchrone. Même async_lockf() est une sauvegarde async-signal-save:

 /* * The code of async_lockf is copied from eglibc-2.11.3/io/lockf.c * The lockf.c is under the terms of the GNU Lesser General Public * Copyright (C) 1994,1996,1997,1998,2000,2003 Free Software Foundation, Inc. * This file is part of the GNU C Library. */ int async_lockf(int fd, int cmd) { struct flock fl = {0}; /* async_lockf is always relative to the current file position. */ fl.l_whence = SEEK_CUR; fl.l_start = 0; fl.l_len = 0; switch (cmd) { case F_TEST: /* Test the async_lock: return 0 if FD is unlocked or locked by this process; return -1, set errno to EACCES, if another process holds the lock. */ fl.l_type = F_RDLCK; if (fcntl (fd, F_GETLK, &fl) < 0) return -1; if (fl.l_type == F_UNLCK || fl.l_pid == getpid ()) return 0; errno = EACCES; return -1; case F_ULOCK: fl.l_type = F_UNLCK; cmd = F_SETLK; break; case F_LOCK: fl.l_type = F_WRLCK; cmd = F_SETLK; break; case F_TLOCK: fl.l_type = F_WRLCK; cmd = F_SETLK; break; default: errno = EINVAL; return -1; } /* async_lockf() is a cancellation point but so is fcntl() if F_SETLKW is used. Therefore we don't have to care about cancellation here, the fcntl() function will take care of it. */ return fcntl (fd, cmd, &fl); } 

le gestionnaire sigaction devrait fermer l’application si j’exécute la commande kill -15 mais parfois, le processus est en cours d’exécution et ne se ferme pas. cela arrive rarement. Par exemple, si je lance l’application et que je m’arrête avec kill -15 1000 fois, ce comportement ne se produit que ~ 5 fois.

Une explication pour ce comportement étrange? Pourquoi mon application n’existe pas? Surtout que j’utilise la fonction async-signal-save ( _exit() ) pour fermer le processus

Pour voir ce qui se passe, essayez d’attacher strace ou gdb au processus et de voir où il se bloque. Ma meilleure hypothèse est que vous avez un code qui masque des signaux ( sigprocmask ) tout en effectuant une opération de blocage, empêchant ainsi le gestionnaire de signaux de s’exécuter.