dlls/winecrt0/debug.c

   1 /*
   2  * Fallbacks for debugging functions when running on Windows
   3  *
   4  * Copyright 2019 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifdef __WINE_PE_BUILD
  22
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30
  31 WINE_DECLARE_DEBUG_CHANNEL(pid);
  32 WINE_DECLARE_DEBUG_CHANNEL(timestamp);
  33
  34 static const char * (__cdecl *p__wine_dbg_strdup)( const char *str );
  35 static int (__cdecl *p__wine_dbg_output)( const char *str );
  36 static unsigned char (__cdecl *p__wine_dbg_get_channel_flags)( struct __wine_debug_channel *channel );
  37 static int (__cdecl *p__wine_dbg_header)( enum __wine_debug_class cls,
  38                                           struct __wine_debug_channel *channel,
  39                                           const char *function );
  40
  41 static const char * const debug_classes[] = { "fixme", "err", "warn", "trace" };
  42
  43 static unsigned char default_flags = (1 << __WINE_DBCL_ERR) | (1 << __WINE_DBCL_FIXME);
  44 static int nb_debug_options = -1;
  45 static int options_size;
  46 static struct __wine_debug_channel *debug_options;
  47 static DWORD partial_line_tid;  /* id of the last thread to output a partial line */
  48
  49 static void load_func( void **func, const char *name, void *def )
  50 {
  51     if (!*func)
  52     {
  53         DWORD err = GetLastError();
  54         HMODULE module = GetModuleHandleW( L"ntdll.dll" );
  55         void *proc = GetProcAddress( module, name );
  56         InterlockedExchangePointer( func, proc ? proc : def );
  57         SetLastError( err );
  58     }
  59 }
  60 #define LOAD_FUNC(name) load_func( (void **)&p ## name, #name, fallback ## name )
  61
  62
  63 /* add a new debug option at the end of the option list */
  64 static void add_option( const char *name, unsigned char set, unsigned char clear )
  65 {
  66     int min = 0, max = nb_debug_options - 1, pos, res;
  67
  68     if (!name[0])  /* "all" option */
  69     {
  70         default_flags = (default_flags & ~clear) | set;
  71         return;
  72     }
  73     if (strlen(name) >= sizeof(debug_options[0].name)) return;
  74
  75     while (min <= max)
  76     {
  77         pos = (min + max) / 2;
  78         res = strcmp( name, debug_options[pos].name );
  79         if (!res)
  80         {
  81             debug_options[pos].flags = (debug_options[pos].flags & ~clear) | set;
  82             return;
  83         }
  84         if (res < 0) max = pos - 1;
  85         else min = pos + 1;
  86     }
  87     if (nb_debug_options >= options_size)
  88     {
  89         options_size = max( options_size * 2, 16 );
  90         debug_options = heap_realloc( debug_options, options_size * sizeof(debug_options[0]) );
  91     }
  92
  93     pos = min;
  94     if (pos < nb_debug_options) memmove( &debug_options[pos + 1], &debug_options[pos],
  95                                          (nb_debug_options - pos) * sizeof(debug_options[0]) );
  96     strcpy( debug_options[pos].name, name );
  97     debug_options[pos].flags = (default_flags & ~clear) | set;
  98     nb_debug_options++;
  99 }
 100
 101 /* parse a set of debugging option specifications and add them to the option list */
 102 static void parse_options( const char *str )
 103 {
 104     char *opt, *next, *options;
 105     unsigned int i;
 106
 107     if (!(options = _strdup(str))) return;
 108     for (opt = options; opt; opt = next)
 109     {
 110         const char *p;
 111         unsigned char set = 0, clear = 0;
 112
 113         if ((next = strchr( opt, ',' ))) *next++ = 0;
 114
 115         p = opt + strcspn( opt, "+-" );
 116         if (!p[0]) p = opt;  /* assume it's a debug channel name */
 117
 118         if (p > opt)
 119         {
 120             for (i = 0; i < ARRAY_SIZE(debug_classes); i++)
 121             {
 122                 int len = strlen(debug_classes[i]);
 123                 if (len != (p - opt)) continue;
 124                 if (!memcmp( opt, debug_classes[i], len ))  /* found it */
 125                 {
 126                     if (*p == '+') set |= 1 << i;
 127                     else clear |= 1 << i;
 128                     break;
 129                 }
 130             }
 131             if (i == ARRAY_SIZE(debug_classes)) /* bad class name, skip it */
 132                 continue;
 133         }
 134         else
 135         {
 136             if (*p == '-') clear = ~0;
 137             else set = ~0;
 138         }
 139         if (*p == '+' || *p == '-') p++;
 140         if (!p[0]) continue;
 141
 142         if (!strcmp( p, "all" ))
 143             default_flags = (default_flags & ~clear) | set;
 144         else
 145             add_option( p, set, clear );
 146     }
 147     free( options );
 148 }
 149
 150 /* initialize all options at startup */
 151 static void init_options(void)
 152 {
 153     char *wine_debug = getenv("WINEDEBUG");
 154
 155     nb_debug_options = 0;
 156     if (wine_debug) parse_options( wine_debug );
 157 }
 158
 159 /* FIXME: this is not 100% thread-safe */
 160 static const char * __cdecl fallback__wine_dbg_strdup( const char *str )
 161 {
 162     static char *list[32];
 163     static LONG pos;
 164     char *ret = strdup( str );
 165     int idx;
 166
 167     idx = InterlockedIncrement( &pos ) % ARRAY_SIZE(list);
 168     free( InterlockedExchangePointer( (void **)&list[idx], ret ));
 169     return ret;
 170 }
 171
 172 static int __cdecl fallback__wine_dbg_output( const char *str )
 173 {
 174     size_t len = strlen( str );
 175
 176     if (!len) return 0;
 177     InterlockedExchange( (LONG *)&partial_line_tid, str[len - 1] != '\n' ? GetCurrentThreadId() : 0 );
 178     return fwrite( str, 1, len, stderr );
 179 }
 180
 181 static int __cdecl fallback__wine_dbg_header( enum __wine_debug_class cls,
 182                                               struct __wine_debug_channel *channel,
 183                                               const char *function )
 184 {
 185     char buffer[200], *pos = buffer;
 186
 187     if (!(__wine_dbg_get_channel_flags( channel ) & (1 << cls))) return -1;
 188
 189     /* skip header if partial line and no other thread came in between */
 190     if (partial_line_tid == GetCurrentThreadId()) return 0;
 191
 192     if (TRACE_ON(timestamp))
 193     {
 194         UINT ticks = GetTickCount();
 195         pos += sprintf( pos, "%3u.%03u:", ticks / 1000, ticks % 1000 );
 196     }
 197     if (TRACE_ON(pid)) pos += sprintf( pos, "%04x:", (UINT)GetCurrentProcessId() );
 198     pos += sprintf( pos, "%04x:", (UINT)GetCurrentThreadId() );
 199     if (function && cls < ARRAY_SIZE( debug_classes ))
 200         snprintf( pos, sizeof(buffer) - (pos - buffer), "%s:%s:%s ",
 201                   debug_classes[cls], channel->name, function );
 202
 203     return fwrite( buffer, 1, strlen(buffer), stderr );
 204 }
 205
 206 static unsigned char __cdecl fallback__wine_dbg_get_channel_flags( struct __wine_debug_channel *channel )
 207 {
 208     int min, max, pos, res;
 209
 210     if (nb_debug_options == -1) init_options();
 211
 212     min = 0;
 213     max = nb_debug_options - 1;
 214     while (min <= max)
 215     {
 216         pos = (min + max) / 2;
 217         res = strcmp( channel->name, debug_options[pos].name );
 218         if (!res) return debug_options[pos].flags;
 219         if (res < 0) max = pos - 1;
 220         else min = pos + 1;
 221     }
 222     /* no option for this channel */
 223     if (channel->flags & (1 << __WINE_DBCL_INIT)) channel->flags = default_flags;
 224     return default_flags;
 225 }
 226
 227 const char * __cdecl __wine_dbg_strdup( const char *str )
 228 {
 229     LOAD_FUNC( __wine_dbg_strdup );
 230     return p__wine_dbg_strdup( str );
 231 }
 232
 233 int __cdecl __wine_dbg_output( const char *str )
 234 {
 235     LOAD_FUNC( __wine_dbg_output );
 236     return p__wine_dbg_output( str );
 237 }
 238
 239 unsigned char __cdecl __wine_dbg_get_channel_flags( struct __wine_debug_channel *channel )
 240 {
 241     LOAD_FUNC( __wine_dbg_get_channel_flags );
 242     return p__wine_dbg_get_channel_flags( channel );
 243 }
 244
 245 int __cdecl __wine_dbg_header( enum __wine_debug_class cls, struct __wine_debug_channel *channel,
 246                                const char *function )
 247 {
 248     LOAD_FUNC( __wine_dbg_header );
 249     return p__wine_dbg_header( cls, channel, function );
 250 }
 251
 252 #endif  /* __WINE_PE_BUILD */