Changeset 640

Show
Ignore:
Timestamp:
02/04/07 22:46:50 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r639 r640  
     12007-02-03  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/logger_writer.h: 
     4        - added new #define LOGGER_BUF_PAGESIZE 4096 
     5          to round down write count to a multiple of above value 
     6          if the data size to write is > LOGGER_BUF_PAGESIZE; 
     7          this preserves the write speed-up and 
     8          allows to write as much data as possible without limiting 
     9          the chunk size to logger_writer->max_bufsize; 
     10          this fixes the cases when max_bufsize is set 
     11          to a low value (0 - 16KB or < max request size). 
     12 
     13        * cherokee/logger_writer.c: 
     14        - avoided duplicated code by using new local function 
     15          logger_writer_close_file(); 
     16        - configuration, added saner tests on max_bufsize values; 
     17        - do not use write_fd if the log stream is stderr; 
     18        - do not close log file if it is stderr; 
     19        - cherokee_logger_writer_flush(), 
     20          fixed error handling in order to always flush internal buffer 
     21          on fatal write errors, because we don't want it 
     22          to grow up too much (that data is lost anyway). 
     23         
    1242007-02-02  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    225 

  • cherokee/trunk/cherokee/logger_writer.c

    r638 r640  
    5656 
    5757 
     58static ret_t 
     59logger_writer_close_file (cherokee_logger_writer_t *writer) 
     60{ 
     61        ret_t   ret = ret_ok; 
     62 
     63        if (writer->fd != -1) { 
     64                /* Don't close file if it is stderr 
     65                 */ 
     66                if (writer->type != cherokee_logger_writer_stderr) { 
     67                        if (close (writer->fd) != 0) 
     68                                ret = ret_error; 
     69                } 
     70                writer->fd = -1; 
     71        } 
     72        return ret; 
     73} 
     74 
     75 
    5876ret_t  
    5977cherokee_logger_writer_mrproper (cherokee_logger_writer_t *writer) 
    6078{ 
    61         if (writer->fd != -1) { 
    62                 close (writer->fd); 
    63                 writer->fd = -1; 
    64         } 
     79        ret_t ret; 
     80 
     81        ret = logger_writer_close_file (writer); 
    6582 
    6683        cherokee_buffer_mrproper (&writer->buffer); 
    …… 
    6885        cherokee_buffer_mrproper (&writer->command); 
    6986 
    70         return ret_ok; 
     87        return ret; 
    7188} 
    7289 
    …… 
    7693{ 
    7794        ret_t              ret; 
    78         size_t             nval = 0; 
     95        int                ival = 0; 
    7996        cherokee_buffer_t *tmp  = NULL; 
    8097        cherokee_buffer_t *tmp2 = NULL; 
    …… 
    119136        } 
    120137 
    121  
    122138        /* Read buffer size (bytes) 
    123139         */ 
    …… 
    132148                return ret_ok; 
    133149 
    134         nval = (size_t) atoi (tmp2->buf); 
    135         if (nval > 0 && nval < LOGGER_MIN_BUFSIZE) 
    136                 nval = LOGGER_MIN_BUFSIZE; 
    137         else 
    138         if (nval > LOGGER_MAX_BUFSIZE) 
    139                 nval = LOGGER_MAX_BUFSIZE; 
     150        ival = atoi (tmp2->buf); 
     151        if (ival <= 0) { 
     152                ival = 0; 
     153        } else { 
     154                /* ival > 0 
     155                */ 
     156                if (ival < LOGGER_MIN_BUFSIZE) 
     157                        ival = LOGGER_MIN_BUFSIZE; 
     158                else 
     159                if (ival > LOGGER_MAX_BUFSIZE) 
     160                        ival = LOGGER_MAX_BUFSIZE; 
     161        } 
    140162 
    141163        /* NOTE: nval is always >= 0 because it is unsigned 
    142164         */ 
    143         if (writer->max_bufsize != nval) { 
     165        if (writer->max_bufsize != (size_t) ival) { 
    144166                /* Reallocate buffer to the new size 
    145167                 */ 
    146168                cherokee_buffer_mrproper (&writer->buffer); 
    147                 writer->max_bufsize = nval; 
     169                writer->max_bufsize = (size_t) ival; 
    148170                ret = cherokee_buffer_ensure_size ( 
    149171                        &writer->buffer, 
    …… 
    215237        switch (writer->type) { 
    216238        case cherokee_logger_writer_syslog: 
     239                /* Nothing to do, syslog already opened at startup. 
     240                 */ 
    217241                return ret_ok; 
    218242 
    …… 
    221245 
    222246        case cherokee_logger_writer_stderr: 
     247                /* Nothing to do, syslog already opened at startup. 
     248                 */ 
    223249                writer->fd = STDERR_FILENO; 
    224250                return ret_ok; 
    …… 
    241267 
    242268 
    243 ret_t  
     269ret_t 
    244270cherokee_logger_writer_reopen (cherokee_logger_writer_t *writer) 
    245271{ 
    …… 
    253279        case cherokee_logger_writer_pipe: 
    254280        case cherokee_logger_writer_stderr: 
    255                 if (writer->fd != -1) { 
    256                         /* Don't close file if it is stderr 
    257                          */ 
    258                         if (writer->type != cherokee_logger_writer_stderr || 
    259                                 writer->fd != STDERR_FILENO) { 
    260                                 close (writer->fd); 
    261                         } 
    262                         writer->fd = -1; 
    263                 } 
     281                ret = logger_writer_close_file (writer); 
    264282                break; 
    265283 
    …… 
    287305cherokee_logger_writer_flush (cherokee_logger_writer_t *writer) 
    288306{ 
    289         int re; 
    290         size_t buflen = MIN(writer->max_bufsize, writer->buffer.len); 
     307        ret_t   ret = ret_ok; 
    291308 
    292309        /* The internal buffer might be empty 
    …… 
    301318                /* In this case we ignore errors. 
    302319                 */ 
    303                 fwrite (writer->buffer.buf, 1, writer->buffer.len, stderr); 
     320                if (fwrite (writer->buffer.buf, 1, writer->buffer.len, stderr) 
     321                        != (size_t) writer->buffer.len) 
     322                        ret = ret_error; 
     323                /* Cleanup the log buffer even if there is an error, 
     324                 * because it's safer to go on anyway. 
     325                 */ 
    304326                cherokee_buffer_clean (&writer->buffer); 
    305327                break; 
    …… 
    307329        case cherokee_logger_writer_pipe: 
    308330        case cherokee_logger_writer_file: 
     331                { 
     332                ssize_t nwr = 0; 
     333                size_t  buflen = writer->buffer.len; 
     334 
     335                /* If there is at least 1 page to write 
     336                 * then round down the length to speed up write(s). 
     337                 */ 
     338                if (buflen > LOGGER_BUF_PAGESIZE) 
     339                        buflen &= ~LOGGER_BUF_PAGESIZE; 
    309340                do { 
    310                         re = write (writer->fd, writer->buffer.buf, buflen); 
    311                 } while (re == -1 && errno == EINTR); 
    312                 if (re < 0) 
     341                        nwr = write (writer->fd, writer->buffer.buf, buflen); 
     342                } while (nwr == -1 && errno == EINTR); 
     343                if (nwr <= 0) { 
     344                        /* If an error occured in blocking write, 
     345                         * then cleanup the log buffer now 
     346                         * because we don't want to let it grow too much. 
     347                         */ 
     348                        cherokee_buffer_clean (&writer->buffer); 
    313349                        return ret_error; 
    314  
    315                 cherokee_buffer_move_to_begin (&writer->buffer, re); 
     350                } 
     351                /* OK, something has been written. 
     352                 */ 
     353                cherokee_buffer_move_to_begin (&writer->buffer, nwr); 
    316354                if (! cherokee_buffer_is_empty (&writer->buffer)) 
    317355                        return ret_eagain; 
     356                } 
    318357                break; 
    319358 
    320359        case cherokee_logger_writer_syslog: 
    321                 cherokee_syslog (LOG_INFO, &writer->buffer); 
     360                /* Write to syslog the whole log buffer, 
     361                 * then cleanup it in any case. 
     362                 */ 
     363                ret = cherokee_syslog (LOG_INFO, &writer->buffer); 
    322364                cherokee_buffer_clean (&writer->buffer); 
    323365                break; 
    …… 
    328370        } 
    329371 
    330         return ret_ok; 
    331 } 
    332  
     372        return ret; 
     373} 
     374 

  • cherokee/trunk/cherokee/logger_writer.h

    r638 r640  
    3636CHEROKEE_BEGIN_DECLS 
    3737 
     38#define LOGGER_BUF_PAGESIZE     4096    /* page size to round down write(n) */ 
    3839#define LOGGER_OVF_BUFSIZE      4096    /* buffer size = max_bufsize + value */ 
    3940