Changeset 1654

Show
Ignore:
Timestamp:
07/16/08 18:07:32 (6 months ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r1653 r1654  
    112008-07-16  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/Makefile.am, cherokee/init.c, 
     4        cherokee/handler_server_info.c, cherokee/bogotime.c, 
     5        cherokee/thread.c, cherokee/bogotime.h, cherokee/nonce.c, 
     6        cherokee/server-protected.h, cherokee/iocache.c, 
     7        cherokee/connection.c, cherokee/server.c: The 'bogonow' 
     8        time (trick) has been moved to a separate file. It is no longer a 
     9        cherokee_server_t property, so it can be accessed from within any 
     10        class. This is mostly a clean up patch. 
    211 
    312        * cherokee/main_guardian.c (main): Clean up. 

  • cherokee/trunk/cherokee/Makefile.am

    r1574 r1654  
    945945config_node.c \ 
    946946config_reader.h \ 
    947 config_reader.c  
     947config_reader.c \ 
     948bogotime.h \ 
     949bogotime.c 
    948950 
    949951libcherokee_client_la_SOURCES = \ 

  • cherokee/trunk/cherokee/connection.c

    r1614 r1654  
    2626#include "connection.h" 
    2727#include "connection-protected.h" 
     28#include "bogotime.h" 
    2829 
    2930#include <errno.h> 
    …… 
    482483         */ 
    483484        cherokee_buffer_add_str (buffer, "Date: "); 
    484         cherokee_buffer_add_buffer (buffer, &CONN_SRV(conn)->bogo_now_strgmt); 
     485        cherokee_buffer_add_buffer (buffer, &cherokee_bogonow_strgmt); 
    485486        cherokee_buffer_add_str (buffer, CRLF); 
    486487 

  • cherokee/trunk/cherokee/handler_server_info.c

    r1475 r1654  
    2525#include "common-internal.h" 
    2626#include "handler_server_info.h" 
     27#include "bogotime.h" 
    2728 
    2829#ifdef HAVE_SYS_UTSNAME_H 
    …… 
    182183add_uptime_row (cherokee_buffer_t *buf, cherokee_server_t *srv) 
    183184{ 
    184         unsigned int elapse = srv->bogo_now - srv->start_time; 
     185        unsigned int elapse = cherokee_bogonow_now - srv->start_time; 
    185186        unsigned int days; 
    186187        unsigned int hours; 

  • cherokee/trunk/cherokee/init.c

    r1524 r1654  
    2929#include "ncpus.h" 
    3030#include "util.h" 
     31#include "bogotime.h" 
    3132 
    3233 
    …… 
    5354        cherokee_trace_init(); 
    5455 
     56        /* Init the bogotime mechanism 
     57         */ 
     58        cherokee_bogotime_init(); 
     59 
    5560        /* Get the CPU number 
    5661         */ 

  • cherokee/trunk/cherokee/iocache.c

    r1610 r1654  
    3131#include "server-protected.h" 
    3232#include "util.h" 
     33#include "bogotime.h" 
    3334 
    3435#ifdef HAVE_SYS_MMAN_H 
    …… 
    240241        } 
    241242 
    242         PRIV(entry)->stat_update = iocache->srv->bogo_now; 
     243        PRIV(entry)->stat_update = cherokee_bogonow_now; 
    243244        return ret_ok; 
    244245} 
    …… 
    254255        /* The stat information has to be fresh enough 
    255256         */ 
    256         if (iocache->srv->bogo_now >= (PRIV(entry)->stat_update + FRESHNESS_TIME_STAT)) { 
     257        if (cherokee_bogonow_now >= (PRIV(entry)->stat_update + FRESHNESS_TIME_STAT)) { 
    257258                ret = iocache_entry_update_stat (iocache, entry, filename); 
    258259                if (ret != ret_ok) return ret; 
    …… 
    312313 
    313314        PUBL(entry)->mmaped_len  = entry->state.st_size; 
    314         PRIV(entry)->mmap_update = iocache->srv->bogo_now; 
     315        PRIV(entry)->mmap_update = cherokee_bogonow_now; 
    315316 
    316317        return ret_ok; 
    …… 
    331332                if (PRIV(entry)->ref_counter > 1) 
    332333                        update = false; 
    333                 else if (iocache->srv->bogo_now < (PRIV(entry)->mmap_update + FRESHNESS_TIME_MMAP)) 
     334                else if (cherokee_bogonow_now < (PRIV(entry)->mmap_update + FRESHNESS_TIME_MMAP)) 
    334335                        update = false; 
    335336        } 
    …… 
    509510        /* May update the stat info 
    510511         */ 
    511         if (iocache->srv->bogo_now >= (PRIV(entry)->stat_update + FRESHNESS_TIME_STAT)) { 
     512        if (cherokee_bogonow_now >= (PRIV(entry)->stat_update + FRESHNESS_TIME_STAT)) { 
    512513                ret = iocache_entry_update_stat (iocache, entry, filename); 
    513514                if (unlikely (ret != ret_ok)) goto error; 

  • cherokee/trunk/cherokee/nonce.c

    r1131 r1654  
    2828#include "connection-protected.h" 
    2929#include "server-protected.h" 
     30#include "bogotime.h" 
    3031 
    3132struct cherokee_nonce_table { 
    …… 
    9899         */ 
    99100        cherokee_buffer_clean (nonce); 
    100         cherokee_buffer_add_ullong16(nonce, (cullong_t) CONN_SRV(conn)->bogo_now); 
     101        cherokee_buffer_add_ullong16(nonce, (cullong_t) cherokee_bogonow_now); 
    101102        cherokee_buffer_add_ulong16 (nonce, (culong_t) rand()); 
    102103        cherokee_buffer_add_ulong16 (nonce, (culong_t) POINTER_TO_INT(conn)); 

  • cherokee/trunk/cherokee/server-protected.h

    r1439 r1654  
    5959 
    6060struct cherokee_server { 
    61         /* Current time 
     61        /* Exit related 
    6262         */ 
    6363        time_t                       start_time; 
    64         time_t                       bogo_now; 
    65         struct tm                    bogo_now_tmloc; 
    66         struct tm                    bogo_now_tmgmt; 
    67         int                          bogo_now_tzloc_sign; 
    68         cuint_t                      bogo_now_tzloc_offset; 
    69         cherokee_buffer_t            bogo_now_strgmt; 
    70         CHEROKEE_RWLOCK_T           (bogo_now_mutex); 
    71  
    72         /* Exit related 
    73          */ 
    7464        cherokee_buffer_t            panic_action; 
    7565        cherokee_boolean_t           wanna_exit; 

  • cherokee/trunk/cherokee/server.c

    r1568 r1654  
    7979#include "mime.h" 
    8080#include "util.h" 
    81 #include "dtm.h" 
    8281#include "fdpoll.h" 
    8382#include "fdpoll-protected.h" 
    …… 
    8887#include "config_reader.h" 
    8988#include "init.h" 
     89#include "bogotime.h" 
    9090 
    9191#define ENTRIES "core,server" 
    …… 
    172172        cherokee_buffer_add_str (&n->panic_action, CHEROKEE_PANIC_PATH); 
    173173 
    174         /* Bogo now 
    175          */ 
    176         n->bogo_now        = 0; 
    177         n->bogo_now_tzloc_sign = '+'; 
    178         n->bogo_now_tzloc_offset = 0; 
    179         CHEROKEE_RWLOCK_INIT (&n->bogo_now_mutex, NULL); 
    180  
    181         CHEROKEE_RWLOCK_WRITER (&n->bogo_now_mutex); 
    182         cherokee_buffer_init (&n->bogo_now_strgmt); 
    183         cherokee_buffer_ensure_size (&n->bogo_now_strgmt, DTM_SIZE_GMTTM_STR); 
    184         CHEROKEE_RWLOCK_UNLOCK (&n->bogo_now_mutex); 
    185  
    186174        /* Time managing hack 
    187175         */ 
    …… 
    365353        srv->vserver_default = NULL; 
    366354 
    367         cherokee_buffer_mrproper (&srv->bogo_now_strgmt); 
    368355        cherokee_buffer_mrproper (&srv->timeout_header); 
    369356 
    …… 
    12641251 
    12651252 
    1266 static void 
    1267 update_bogo_now (cherokee_server_t *srv) 
    1268 { 
    1269         time_t  newtime; 
    1270  
    1271         /* Read the time 
    1272          */ 
    1273         newtime = time (NULL); 
    1274         if (srv->bogo_now >= newtime)  
    1275                 return; 
    1276  
    1277         /* Update internal variables 
    1278          */ 
    1279         CHEROKEE_RWLOCK_WRITER (&srv->bogo_now_mutex);      /* 1.- lock as writer */ 
    1280  
    1281         srv->bogo_now = newtime; 
    1282  
    1283         /* Convert time to both GMT and local time struct 
    1284          */ 
    1285         cherokee_gmtime    (&newtime, &srv->bogo_now_tmgmt); 
    1286         cherokee_localtime (&newtime, &srv->bogo_now_tmloc); 
    1287  
    1288 #ifdef HAVE_STRUCT_TM_GMTOFF 
    1289         srv->bogo_now_tzloc_sign = srv->bogo_now_tmloc.tm_gmtoff < 0 ? '-' : '+'; 
    1290         srv->bogo_now_tzloc_offset = abs(srv->bogo_now_tmloc.tm_gmtoff / 3600); 
    1291 #else 
    1292         srv->bogo_now_tzloc_sign = timezone < 0 ? '-' : '+'; 
    1293         srv->bogo_now_tzloc_offset = abs(timezone / 3600); 
    1294 #endif 
    1295          
    1296         cherokee_buffer_clean (&srv->bogo_now_strgmt); 
    1297         { 
    1298         size_t  szlen = 0; 
    1299         char bufstr[DTM_SIZE_GMTTM_STR + 2]; 
    1300  
    1301         szlen = cherokee_dtm_gmttm2str (bufstr, sizeof(bufstr), 
    1302                                         &srv->bogo_now_tmgmt); 
    1303         cherokee_buffer_add (&srv->bogo_now_strgmt, bufstr, szlen); 
    1304         } 
    1305  
    1306         /* NOTE: a local time string should have {+-}timezone_offset (hours) 
    1307          *       added to date-time GMT string. 
    1308          */ 
    1309  
    1310         CHEROKEE_RWLOCK_UNLOCK (&srv->bogo_now_mutex);      /* 2.- release */ 
    1311 } 
    1312  
    1313  
    13141253ret_t 
    13151254cherokee_server_unlock_threads (cherokee_server_t *srv) 
    …… 
    13181257        cherokee_list_t *i; 
    13191258 
    1320         /* Update bogo_now before launch the threads 
    1321          */ 
    1322         update_bogo_now (srv); 
     1259        /* Update bogotime before launch the threads 
     1260         */ 
     1261        cherokee_bogotime_update(); 
    13231262 
    13241263        /* Launch all the threads 
    …… 
    13401279        /* Get the server time. 
    13411280         */ 
    1342         update_bogo_now (srv); 
     1281        cherokee_bogotime_update (); 
    13431282        update_bogo_conns_num (srv); 
    13441283 
    …… 
    13551294        /* Logger flush  
    13561295         */ 
    1357         if (srv->log_flush_next < srv->bogo_now) { 
     1296        if (srv->log_flush_next < cherokee_bogonow_now) { 
    13581297                flush_logs (srv); 
    1359                 srv->log_flush_next = srv->bogo_now + srv->log_flush_elapse; 
     1298                srv->log_flush_next = cherokee_bogonow_now + srv->log_flush_elapse; 
    13601299        } 
    13611300 
    13621301        /* Clean IO cache 
    13631302         */ 
    1364         if (srv->iocache_clean_next < srv->bogo_now) { 
     1303        if (srv->iocache_clean_next < cherokee_bogonow_now) { 
    13651304                cherokee_iocache_clean_up (srv->iocache);        
    1366                 srv->iocache_clean_next = srv->bogo_now + IOCACHE_DEFAULT_CLEAN_ELAPSE; 
     1305                srv->iocache_clean_next = cherokee_bogonow_now + IOCACHE_DEFAULT_CLEAN_ELAPSE; 
    13671306        } 
    13681307 
    13691308#ifdef _WIN32 
    1370         if (unlikely (cherokee_win32_shutdown_signaled(srv->bogo_now))) 
     1309        if (unlikely (cherokee_win32_shutdown_signaled (cherokee_bogonow_now))) 
    13711310                srv->wanna_exit = true; 
    13721311#endif 

  • cherokee/trunk/cherokee/thread.c

    r1611 r1654  
    4141#include "util.h" 
    4242#include "fcgi_manager.h" 
     43#include "bogotime.h" 
    4344 
    4445 
    …… 
    5051 
    5152static void 
    52 update_bogo_now_internal (cherokee_thread_t *thd) 
    53 { 
    54         cherokee_server_t *srv = THREAD_SRV(thd); 
    55  
     53update_bogo_now (cherokee_thread_t *thd) 
     54{ 
    5655        /* Has it changed? 
    5756         */ 
    58         if (thd->bogo_now == srv->bogo_now) 
     57        if (thd->bogo_now == cherokee_bogonow_now) 
    5958                return; 
    6059 
    6160        /* Update time_t 
    6261         */ 
    63         thd->bogo_now = srv->bogo_now; 
     62        thd->bogo_now = cherokee_bogonow_now; 
    6463 
    6564        /* Update struct tm 
    6665         */ 
    67         memcpy (&thd->bogo_now_tmgmt, &srv->bogo_now_tmgmt, sizeof(struct tm)); 
    68         memcpy (&thd->bogo_now_tmloc, &srv->bogo_now_tmloc, sizeof(struct tm)); 
     66        cherokee_bogotime_lock_read(); 
     67 
     68        memcpy (&thd->bogo_now_tmgmt, &cherokee_bogonow_tmgmt, sizeof(struct tm)); 
     69        memcpy (&thd->bogo_now_tmloc, &cherokee_bogonow_tmloc, sizeof(struct tm)); 
    6970 
    7071        /* Update cherokee_buffer_t 
    7172         */ 
    7273        cherokee_buffer_clean (&thd->bogo_now_strgmt); 
    73         cherokee_buffer_add_buffer (&thd->bogo_now_strgmt, &srv->bogo_now_strgmt); 
    74  
    75 } 
    76  
    77  
    78 static void 
    79 update_bogo_now (cherokee_thread_t *thd) 
    80 { 
    81         CHEROKEE_RWLOCK_READER (&THREAD_SRV(thd)->bogo_now_mutex); 
    82         update_bogo_now_internal(thd); 
    83         CHEROKEE_RWLOCK_UNLOCK (&THREAD_SRV(thd)->bogo_now_mutex); 
    84 } 
    85  
    86  
    87 static void 
    88 try_to_update_bogo_now (cherokee_thread_t *thd) 
    89 { 
    90         int unlocked; 
    91         cherokee_server_t *srv = THREAD_SRV(thd); 
    92  
    93         /* Try to lock 
    94          */ 
    95         unlocked = CHEROKEE_RWLOCK_TRYREADER (&srv->bogo_now_mutex);        /* 1.- lock a reader */ 
    96         if (unlocked) return; 
    97  
    98         update_bogo_now_internal (thd); 
    99  
    100         CHEROKEE_RWLOCK_UNLOCK (&srv->bogo_now_mutex);                      /* 2.- release */ 
     74        cherokee_buffer_add_buffer (&thd->bogo_now_strgmt, &cherokee_bogonow_strgmt); 
     75 
     76        cherokee_bogotime_release(); 
    10177} 
    10278 
    …… 
    15221498        /* Try to update bogo_now 
    15231499         */ 
    1524         try_to_update_bogo_now (thd); 
     1500        cherokee_bogotime_try_update(); 
    15251501 
    15261502        /* Reset the server socket. 
    …… 
    18601836        /* Try to update bogo_now 
    18611837         */ 
    1862         try_to_update_bogo_now (thd); 
    1863  
     1838        cherokee_bogotime_try_update(); 
    18641839 
    18651840        /* If the thread is full of connections, it should not