Changeset 1658

Show
Ignore:
Timestamp:
02/05/05 14:11:05 (4 years ago)
Author:
morris
Message:

A new signal handling scheme:

  • Block all handled signals in the main thread, this should then
    be inherited by all threads.
  • sigwait() in wd_signals_thread(). Check signal directly. Do away
    with volatile sig_atomic_t flags.

This appears to work on FreeBSD, OpenBSD and Mac OS X. There may be issues on 10.2 or Linux. Fixes #25.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • wired/trunk/wired/files.c

    r763 r1658  
    1 /* $Id: files.c,v 1.78 2005/01/15 21:24:38 morris Exp $ */ 
     1/* $Id$ */ 
    22 
    33/* 
    …… 
    10041004        double                  start, interval; 
    10051005 
    1006         wd_block_signals(); 
    1007  
    10081006        za_log_info("Indexing files..."); 
    10091007 

  • wired/trunk/wired/main.c

    r1631 r1658  
    7373static void                                             wd_delete_status(void); 
    7474 
    75 static void                                             wd_init_signals(void); 
     75static void                                             wd_block_signals(void); 
     76static int                                              wd_wait_signals(void); 
    7677static void *                                   wd_signal_thread(void *); 
    77 static void                                             wd_sig_reload(int); 
    78 static void                                             wd_sig_reregister(int); 
    79 static void                                             wd_sig_reindex(int); 
    80 static void                                             wd_sig_quit(int); 
    81  
    82  
    83 volatile sig_atomic_t                   wd_running = 1; 
    84 volatile sig_atomic_t                   wd_reload; 
    85 volatile sig_atomic_t                   wd_register; 
    86 volatile sig_atomic_t                   wd_index; 
    87 volatile sig_atomic_t                   wd_signal; 
     78 
     79 
     80bool                                                    wd_running = true; 
    8881 
    8982char                                                    wd_root[ZA_PATH_SIZE]; 
    …… 
    246239        /* init subsystems */ 
    247240        wd_init_ssl(); 
    248         wd_init_signals(); 
     241        //wd_init_signals(); 
    249242        wd_init_chats(); 
    250243        wd_init_clients(); 
    …… 
    315308 
    316309        /* create server threads after privilege drop */ 
     310        wd_block_signals(); 
    317311        za_fork_timers(); 
    318312        wd_fork_server(); 
    …… 
    333327        wd_signal_thread(NULL); 
    334328 
    335         /* dropped out of loop */ 
    336         switch(wd_signal) { 
    337                 case SIGINT: 
    338                         za_log_info("Signal INT received, quitting"); 
    339                         break; 
    340  
    341                 case SIGQUIT: 
    342                         za_log_info("Signal QUIT received, quitting"); 
    343                         break; 
    344  
    345                 case SIGTERM: 
    346                         za_log_info("Signal TERM received, quitting"); 
    347                         break; 
    348         } 
    349          
     329        /* dropped out */ 
    350330        wd_exit_clients(); 
    351331         
    …… 
    491471#pragma mark - 
    492472 
    493 static void wd_init_signals(void) { 
    494         signal(SIGPIPE, SIG_IGN); 
    495         signal(SIGHUP, wd_sig_reload); 
    496         signal(SIGUSR1, wd_sig_reregister); 
    497         signal(SIGUSR2, wd_sig_reindex); 
    498         signal(SIGINT, wd_sig_quit); 
    499         signal(SIGTERM, wd_sig_quit); 
    500         signal(SIGQUIT, wd_sig_quit); 
    501 } 
    502  
    503  
    504  
    505 void wd_block_signals(void) { 
     473static void wd_block_signals(void) { 
    506474        sigset_t        signals; 
    507475 
    …… 
    520488 
    521489 
     490static int wd_wait_signals(void) { 
     491        sigset_t    signals; 
     492        int         signal; 
     493 
     494        sigemptyset(&signals); 
     495        sigaddset(&signals, SIGPIPE); 
     496        sigaddset(&signals, SIGHUP); 
     497        sigaddset(&signals, SIGUSR1); 
     498        sigaddset(&signals, SIGUSR2); 
     499        sigaddset(&signals, SIGINT); 
     500        sigaddset(&signals, SIGTERM); 
     501        sigaddset(&signals, SIGQUIT); 
     502 
     503        sigwait(&signals, &signal); 
     504 
     505        return signal; 
     506} 
     507 
     508 
     509 
    522510void * wd_signal_thread(void *arg) { 
     511        int             signal; 
     512 
    523513        while(wd_running) { 
    524                 /* check for config reload */ 
    525                 if(wd_reload) { 
    526                         za_log_info("Signal HUP received, reloading configuration"); 
    527                         wd_read_config(); 
    528                         wd_apply_config(); 
    529                          
    530                         wd_reload = 0; 
    531                 } 
    532  
    533                 /* check for register reload */ 
    534                 if(wd_register) { 
    535                         if(!wd_settings._register) { 
    536                                 za_log_info("Signal USR1 ignored, trackers not enabled"); 
    537                         } else { 
    538                                 za_log_info("Signal USR1 received, registering with trackers"); 
    539                                 wd_trackers_register(); 
    540                         } 
    541  
    542                         wd_register = 0; 
    543                 } 
    544  
    545                 /* check for index reload */ 
    546                 if(wd_index) { 
    547                         if(strlen(wd_settings.index) == 0) { 
    548                                 za_log_warn("Signal USR2 ignored, index not enabled"); 
    549                         } else { 
    550                                 za_log_info("Signal USR2 received, indexing files"); 
    551                                 wd_index_files(); 
    552                         } 
    553  
    554                         wd_index = 0; 
    555                 } 
    556                  
    557                 sleep(600); 
     514                signal = wd_wait_signals(); 
     515 
     516                switch(signal) { 
     517                        case SIGHUP: 
     518                                za_log_info("Signal HUP received, reloading configuration"); 
     519                                wd_read_config(); 
     520                                wd_apply_config(); 
     521                                break; 
     522                                 
     523                        case SIGUSR1: 
     524                                if(!wd_settings._register) { 
     525                                        za_log_info("Signal USR1 ignored, trackers not enabled"); 
     526                                } else { 
     527                                        za_log_info("Signal USR1 received, registering with trackers"); 
     528                                        wd_trackers_register(); 
     529                                } 
     530                                break; 
     531 
     532                        case SIGUSR2: 
     533                                if(strlen(wd_settings.index) == 0) { 
     534                                        za_log_warn("Signal USR2 ignored, index not enabled"); 
     535                                } else { 
     536                                        za_log_info("Signal USR2 received, indexing files"); 
     537                                        wd_index_files(); 
     538                                } 
     539                                break; 
     540 
     541                        case SIGINT: 
     542                                za_log_info("Signal INT received, quitting"); 
     543                                wd_running = false; 
     544                                break; 
     545 
     546                        case SIGQUIT: 
     547                                za_log_info("Signal QUIT received, quitting"); 
     548                                wd_running = false; 
     549                                break; 
     550 
     551                        case SIGTERM: 
     552                                za_log_info("Signal TERM received, quitting"); 
     553                                wd_running = false; 
     554                                break; 
     555                } 
    558556        } 
    559557 
    560558        return NULL; 
    561559} 
    562  
    563  
    564  
    565 static void wd_sig_reload(int sigraised) { 
    566         wd_reload = 1; 
    567         wd_signal = sigraised; 
    568 } 
    569  
    570  
    571  
    572 static void wd_sig_reregister(int sigraised) { 
    573         wd_register = 1; 
    574         wd_signal = sigraised; 
    575 } 
    576  
    577  
    578 static void wd_sig_reindex(int sigraised) { 
    579         wd_index = 1; 
    580         wd_signal = sigraised; 
    581 } 
    582  
    583  
    584 static void wd_sig_quit(int sigraised) { 
    585         wd_running = 0; 
    586         wd_signal = sigraised; 
    587 } 

  • wired/trunk/wired/main.h

    r1587 r1658  
    4242void                                                            wd_write_status(bool); 
    4343 
    44 void                                                            wd_block_signals(void); 
    4544 
    46  
    47 extern volatile sig_atomic_t            wd_running; 
    48 extern volatile sig_atomic_t            wd_reload; 
    49 extern volatile sig_atomic_t            wd_register; 
    50 extern volatile sig_atomic_t            wd_index; 
    51 extern volatile sig_atomic_t            wd_signal; 
     45extern bool                                                     wd_running; 
    5246 
    5347extern char                                                     wd_config[ZA_PATH_SIZE]; 

  • wired/trunk/wired/server.c

    r1648 r1658  
    414414        int                                                     err, length; 
    415415 
    416         wd_block_signals(); 
    417  
    418416        while(wd_running) { 
    419417                length = sizeof(ss); 
    …… 
    474472        int                                                     err, length; 
    475473 
    476         wd_block_signals(); 
    477  
    478474        while(wd_running) { 
    479475                length = sizeof(ss); 
    …… 
    584580        CFNetServiceRef         service; 
    585581        CFStringRef                     name; 
    586  
    587         wd_block_signals(); 
    588582 
    589583        while(wd_running) { 

  • wired/trunk/wired/trackers.c

    r1643 r1658  
    267267        const char              *argument; 
    268268 
    269         wd_block_signals(); 
    270  
    271269        ZA_LIST_FOREACH(tracker->addresses, node, address) { 
    272270                tracker->active = false;