Changeset 693

Show
Ignore:
Timestamp:
11/03/07 11:13:53 (13 years ago)
Author:
ppalmers
Message:

format the message before sending it to the debugModuleManager such that there can't be any interference between messages of different debugModules.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/debugmodule/debugmodule.cpp

    r692 r693  
    8484                         ... ) const 
    8585{ 
     86    const char *warning = "WARNING: message truncated!\n"; 
     87    const int warning_size = 32; 
    8688    va_list arg; 
    87  
     89    char msg[MB_BUFFERSIZE]; 
     90 
     91    // format the message such that it remains together 
     92    int chars_written=0; 
     93    int retval=0; 
     94 
     95    va_start( arg, format ); 
     96    retval = vsnprintf(msg+chars_written, MB_BUFFERSIZE, format, arg); 
     97    va_end( arg ); 
     98    if (retval >= 0) {  // ignore errors 
     99        chars_written += retval; 
     100    } 
     101 
     102    // output a warning if the message was truncated 
     103    if (chars_written == MB_BUFFERSIZE) { 
     104        snprintf(msg+MB_BUFFERSIZE-warning_size, warning_size, "%s", warning); 
     105    } 
     106 
     107    // print to backlog if necessary 
    88108    if (level <= BACKLOG_MIN_LEVEL) { 
    89         va_start( arg, format ); 
    90         DebugModuleManager::instance()->backlog_va_print( format, arg ); 
    91         va_end( arg ); 
    92     } 
    93  
    94     if ( level > m_level ) { 
    95         return; 
    96     } 
    97  
    98     va_start( arg, format ); 
    99     DebugModuleManager::instance()->va_print( format, arg ); 
    100     va_end( arg ); 
     109        DebugModuleManager::instance()->backlog_print( msg ); 
     110    } 
     111 
     112    // print to stderr if necessary 
     113    if ( level <= m_level ) { 
     114        DebugModuleManager::instance()->print( msg ); 
     115    } 
    101116} 
    102117 
     
    109124                    ... ) const 
    110125{ 
     126    const char *warning = "WARNING: message truncated!\n"; 
     127    const int warning_size = 32; 
     128 
    111129    va_list arg; 
    112     va_start( arg, format )
     130    char msg[MB_BUFFERSIZE]
    113131 
    114132    // remove the path info from the filename 
     
    123141    struct timespec ts; 
    124142    clock_gettime(CLOCK_MONOTONIC, &ts); 
    125     uint32_t ts_usec=(uint32_t)(ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL); 
    126  
     143    long unsigned int ts_usec=(uint32_t)(ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL); 
     144 
     145    // format the message such that it remains together 
     146    int chars_written=0; 
     147    int retval=0; 
     148    retval = snprintf(msg, MB_BUFFERSIZE, "%010lu: %s (%s)[%4d] %s: ",  
     149                      ts_usec, getPreSequence( level ), 
     150                      fname,  line,  function ); 
     151    if (retval >= 0) chars_written += retval; // ignore errors 
     152 
     153    va_start( arg, format ); 
     154    retval = vsnprintf( msg + chars_written, 
     155                        MB_BUFFERSIZE - chars_written, 
     156                        format, arg); 
     157    va_end( arg ); 
     158    if (retval >= 0) chars_written += retval; // ignore errors 
     159 
     160    retval = snprintf( msg + chars_written, 
     161                       MB_BUFFERSIZE - chars_written, 
     162                       "%s", getPostSequence( level ) ); 
     163    if (retval >= 0) chars_written += retval; // ignore errors 
     164 
     165    // output a warning if the message was truncated 
     166    if (chars_written == MB_BUFFERSIZE) { 
     167        snprintf(msg + MB_BUFFERSIZE - warning_size, 
     168                 warning_size, 
     169                 "%s", warning); 
     170    } 
     171 
     172    // print to backlog if necessary 
    127173    if (level <= BACKLOG_MIN_LEVEL) { 
    128         va_start( arg, format ); 
    129         DebugModuleManager::instance()->backlog_print( "%010lu: %s (%s)[%4d] %s: ",  
    130                     ts_usec, getPreSequence( level ), 
    131                     fname,  line,  function ); 
    132         DebugModuleManager::instance()->backlog_va_print( format, arg ); 
    133         DebugModuleManager::instance()->backlog_print( "%s", getPostSequence( level ) ); 
    134         va_end( arg ); 
    135     } 
    136  
    137     if ( level > m_level ) { 
    138         return; 
    139     } 
    140  
    141     va_start( arg, format ); 
    142     DebugModuleManager::instance()->print( "%010lu: %s (%s)[%4d] %s: ",  
    143                  ts_usec, getPreSequence( level ), 
    144                  fname,  line,  function ); 
    145     DebugModuleManager::instance()->va_print( format, arg ); 
    146     DebugModuleManager::instance()->print( "%s", getPostSequence( level ) ); 
    147     va_end( arg ); 
     174        DebugModuleManager::instance()->backlog_print( msg ); 
     175    } 
     176 
     177    // print to stderr if necessary 
     178    if ( level <= m_level ) { 
     179        DebugModuleManager::instance()->print( msg ); 
     180    } 
    148181} 
    149182 
     
    392425 
    393426void 
    394 DebugModuleManager::backlog_print(const char *fmt, ...) 
    395 
    396     const char *warning = "WARNING: message truncated!\n"; 
    397     const int warning_size = 32; 
    398     char msg[MB_BUFFERSIZE]; 
    399     va_list ap; 
    400  
     427DebugModuleManager::backlog_print(const char *msg) 
     428
    401429    unsigned int ntries; 
    402430    struct timespec wait = {0,50000}; 
    403  
    404     /* format the message first */ 
    405     va_start(ap, fmt); 
    406     if (vsnprintf(msg, BACKLOG_MB_BUFFERSIZE-warning_size, fmt, ap)  
    407         >= (BACKLOG_MB_BUFFERSIZE-warning_size)) { 
    408         // output a warning if the message was truncated 
    409         snprintf(msg+BACKLOG_MB_BUFFERSIZE-warning_size, warning_size, "%s", warning); 
    410     } 
    411     va_end(ap); 
    412  
    413431    // the backlog 
    414     ntries=5
     432    ntries=1
    415433    while (ntries) { // try a few times 
    416434        if (pthread_mutex_trylock(&bl_mb_write_lock) == 0) { 
    417             strncpy(bl_mb_buffers[bl_mb_inbuffer], msg, BACKLOG_MB_BUFFERSIZE); 
     435            strncpy(bl_mb_buffers[bl_mb_inbuffer], msg, MB_BUFFERSIZE); 
    418436            bl_mb_inbuffer = BACKLOG_MB_NEXT(bl_mb_inbuffer); 
    419437            pthread_mutex_unlock(&bl_mb_write_lock); 
     
    428446 
    429447void 
    430 DebugModuleManager::print(const char *fmt, ...) 
    431 
    432     const char *warning = "WARNING: message truncated!\n"; 
    433     const int warning_size = 32; 
    434     char msg[MB_BUFFERSIZE]; 
    435     va_list ap; 
    436  
     448DebugModuleManager::print(const char *msg) 
     449
    437450#ifdef DO_MESSAGE_BUFFER_PRINT 
    438451    unsigned int ntries; 
    439452    struct timespec wait = {0,50000}; 
    440453#endif 
    441  
    442     /* format the message first, to reduce lock contention */ 
    443     va_start(ap, fmt); 
    444     if (vsnprintf(msg, MB_BUFFERSIZE-warning_size, fmt, ap) >= MB_BUFFERSIZE-warning_size) { 
    445         // output a warning if the message was truncated 
    446         snprintf(msg+MB_BUFFERSIZE-warning_size, warning_size, "%s", warning); 
    447     } 
    448     va_end(ap); 
    449454 
    450455    if (!mb_initialized) { 
     
    457462 
    458463#ifdef DO_MESSAGE_BUFFER_PRINT 
    459     ntries=5
     464    ntries=1
    460465    while (ntries) { // try a few times 
    461466        if (pthread_mutex_trylock(&mb_write_lock) == 0) { 
     
    480485} 
    481486 
    482 void 
    483 DebugModuleManager::backlog_va_print (const char *fmt, va_list ap) 
    484 { 
    485     const char *warning = "WARNING: message truncated!\n"; 
    486     const int warning_size = 32; 
    487     char msg[MB_BUFFERSIZE]; 
    488     unsigned int ntries; 
    489     struct timespec wait = {0,50000}; 
    490  
    491     /* format the message first */ 
    492     if (vsnprintf(msg, BACKLOG_MB_BUFFERSIZE-warning_size, fmt, ap)  
    493         >= BACKLOG_MB_BUFFERSIZE-warning_size) { 
    494         // output a warning if the message was truncated 
    495         snprintf(msg+BACKLOG_MB_BUFFERSIZE-warning_size, warning_size, "%s", warning); 
    496     } 
    497  
    498     // the backlog 
    499     ntries=5; 
    500     while (ntries) { // try a few times 
    501         if (pthread_mutex_trylock(&bl_mb_write_lock) == 0) { 
    502             strncpy(bl_mb_buffers[bl_mb_inbuffer], msg, BACKLOG_MB_BUFFERSIZE); 
    503             bl_mb_inbuffer = BACKLOG_MB_NEXT(bl_mb_inbuffer); 
    504             pthread_mutex_unlock(&bl_mb_write_lock); 
    505             break; 
    506         } else { 
    507             nanosleep(&wait, NULL); 
    508             ntries--; 
    509         } 
    510     } 
    511     // just bail out should it have failed 
    512 } 
    513  
    514 void 
    515 DebugModuleManager::va_print (const char *fmt, va_list ap) 
    516 { 
    517     const char *warning = "WARNING: message truncated!\n"; 
    518     const int warning_size = 32; 
    519     char msg[MB_BUFFERSIZE]; 
    520  
    521 #ifdef DO_MESSAGE_BUFFER_PRINT 
    522     unsigned int ntries; 
    523     struct timespec wait = {0,50000}; 
    524 #endif 
    525  
    526     /* format the message first, to reduce lock contention */ 
    527     if (vsnprintf(msg, MB_BUFFERSIZE-warning_size, fmt, ap) >= MB_BUFFERSIZE-warning_size) { 
    528         // output a warning if the message was truncated 
    529         snprintf(msg+MB_BUFFERSIZE-warning_size, warning_size, "%s", warning); 
    530     } 
    531  
    532     if (!mb_initialized) { 
    533         /* Unable to print message with realtime safety. 
    534          * Complain and print it anyway. */ 
    535         fprintf(stderr, "ERROR: messagebuffer not initialized: %s", 
    536             msg); 
    537         return; 
    538     } 
    539  
    540 #ifdef DO_MESSAGE_BUFFER_PRINT 
    541     ntries=5; 
    542     while (ntries) { // try a few times 
    543         if (pthread_mutex_trylock(&mb_write_lock) == 0) { 
    544             strncpy(mb_buffers[mb_inbuffer], msg, MB_BUFFERSIZE); 
    545             mb_inbuffer = MB_NEXT(mb_inbuffer); 
    546             pthread_cond_signal(&mb_ready_cond); 
    547             pthread_mutex_unlock(&mb_write_lock); 
    548             break; 
    549         } else { 
    550             nanosleep(&wait, NULL); 
    551             ntries--; 
    552         } 
    553     } 
    554      
    555     if (ntries==0) {  /* lock collision */ 
    556 //         atomic_add(&mb_overruns, 1); 
    557         // FIXME: atomicity 
    558         mb_overruns++; // skip the atomicness for now 
    559     } 
    560 #else 
    561     fprintf(stderr,msg); 
    562 #endif 
    563 } 
    564  
    565487//---------------------------------------- 
    566488 
  • trunk/libffado/src/debugmodule/debugmodule.h

    r690 r693  
    5555#define BACKLOG_MB_BUFFERS      (256) 
    5656#define BACKLOG_MB_NEXT(index)  (((index)+1) & (BACKLOG_MB_BUFFERS-1)) 
    57 #define BACKLOG_MB_BUFFERSIZE   DEBUG_MAX_MESSAGE_LENGTH 
    5857#define BACKLOG_MIN_LEVEL       DEBUG_LEVEL_VERY_VERBOSE 
    5958 
     
    237236    bool init(); 
    238237 
    239     void print(const char *fmt, ...); 
    240     void va_print(const char *fmt, va_list); 
    241  
    242     void backlog_print(const char *fmt, ...); 
    243     void backlog_va_print(const char *fmt, va_list); 
     238    void print(const char *msg); 
     239    void backlog_print(const char *msg); 
    244240 
    245241private: 
     
    263259 
    264260    // the backlog 
    265     char bl_mb_buffers[BACKLOG_MB_BUFFERS][BACKLOG_MB_BUFFERSIZE]; 
     261    char bl_mb_buffers[BACKLOG_MB_BUFFERS][MB_BUFFERSIZE]; 
    266262    unsigned int bl_mb_inbuffer; 
    267263    pthread_mutex_t bl_mb_write_lock;