Avec des boucles d'event

D'expérience, c'est pas une bonne idée de gérer ça dans des handler de signaux (je pense que c'est ce que tu veux dire par interruption ?).

Je comprends pas bien ce que tu veux faire, mais ça devrait t'aider à mieux voir le truc :

Si tu as des impératifs de temps de traitement rapide de plusieurs connections, je pense qu'il vaut mieux sauver les événements dans ton cycle de read (ou de poll) sur to FD et laisser le traitement de ceux-ci dans un autre thread.

C'est plus simple avec un bout de code genre :

int event_process_step(void)
{
 struct event ev;
 if (pop_event(&ev) == 0)
 return 0;
 return process_event(&ev);
}
int event_read_step(int fd)
{
 struct event ev;
 int ret;
 ret = read(fd, &ev, sizeof ev);
 if (ret == sizeof ev)
 ret = push_event(&ev);
 else
 ret = -1;
 return ret;
}
/*
 * Soit avec des threads
 */
void *thread_read(void *arg)
{
 struct poll_table *table = arg;
 for (;;) {
 fd = poll_get_fd(table);
 if (fd < 0)
 break;
 if (fd == 0)
 break;
 if (event_read_step(fd) < 0)
 break;
 }
 return NULL;
}
void *thread_process(void *arg)
{
 for (;;) {
 int worked;
 worked = event_process_step();
 if (workded < 0)
 break;
 if (worked == 0)
 more_work();
 }
 return NULL;
}
/*
 * Soit sans thread
 */
void loop_process(struct poll_table *table)
{
 for (;;) {
 int worked;
 fd = poll_get_fd(table);
 if (fd < 0)
 break;
 if (fd == 0)
 break;
 if (event_read_step(fd) < 0)
 break;
 worked = event_process_step();
 if (workded < 0)
 break;
 if (worked == 0)
 more_work();
 }
}
/*
 * Ou même avec un peu de repartition de charge
 */
void loop_process_fair(struct poll_table *table)
{
 for (;;) {
 int worked;
 worked = 0;
 while (worked < MAX_READ_WORK) {
 fd = poll_get_fd(table);
 if (fd < 0)
 break;
 if (fd == 0)
 break;
 if (event_read_step(fd) < 0)
 break;
 worked ++;
 }
 while (worked < MAX_PROCESS_WORK) {
 done = event_process_step();
 if (done < 0)
 break;
 if (done == 0)
 break;
 worked ++;
 }
 more_work();
 }
}

Bref, tu vois l'idée ...