Ignore:
Timestamp:
Dec 18, 2011, 10:28:22 PM (14 years ago)
Author:
dmik
Message:

Merge branch gcc-kmk to trunk.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk

    • Property svn:ignore

      •  

        old new  
        1 bin
        2 Makefile.inc
         1env.cmd
         2LocalConfig.kmk
    • Property svn:mergeinfo set to
      /branches/gcc-kmkmergedeligible

  • trunk/src/kernel32/_ras.cpp

    r21342 r21916  
    77#include <_ras.h>
    88#include <umalloc.h>
     9#include <process.h>
    910
    1011#include <custombuild.h>
    1112#include <odincrt.h>
     13#ifdef __GNUC__
     14#include <float.h>
     15#else
    1216#include <libc/float.h>
     17#endif
    1318
    1419#include "initterm.h"
    … …  
    1823
    1924/* RAS functions to isolate all RAS related services:
    20  * 
     25 *
    2126 * - Common statistic functions to track objects allocations/deallocations.
    2227 *
    … …  
    2934 * Note: RAS subsystem does not use any other Odin subsystem, and IMO must not.
    3035 *       That is RAS has its own heap, serialization, logging.
    31  *       External stuff that is used: 
     36 *       External stuff that is used:
    3237 *           - from Odin: asm helpers from interlock.asm
    3338 *           - from libc: uheap functions
    34  *       
     39 *
    3540 *       The following has been borrowed from other Odin parts and adapted:
    3641 *           - critical section
    … …  
    4853typedef struct _RAS_TRACK RAS_TRACK;
    4954
    50 typedef struct _RAS_OBJECT_INFO 
     55typedef struct _RAS_OBJECT_INFO
    5156{
    5257    struct _RAS_OBJECT_INFO *next;
    5358    struct _RAS_OBJECT_INFO *prev;
    54    
     59
    5560    RAS_TRACK_HANDLE h;
    56    
     61
    5762    ULONG objident;
    5863    ULONG usecount;
    59    
     64
    6065    ULONG objhandle;
    61    
     66
    6267    void *objdata;
    6368    ULONG cbobjdata;
    64    
     69
    6570    char userdata[1];
    6671} RAS_OBJECT_INFO;
    … …  
    7378    RAS_OBJECT_INFO *objfirst;
    7479    RAS_OBJECT_INFO *objlast;
    75    
     80
    7681    char objname[80];
    77    
     82
    7883    ULONG cbuserdata;
    79    
     84
    8085    ULONG fLogObjectContent: 1;
    8186    ULONG fMemory: 1;
    8287    ULONG fLogAtExit: 1;
    8388    ULONG fLogObjectsAtExit: 1;
    84    
     89
    8590    FNLOC *pfnLogObjectContent;
    8691    FNCOC *pfnCompareObjectContent;
    87    
     92
    8893    /* Used when fMemory = 1 for RasTrackAlloc, Realloc and Free calls */
    8994    ULONG cAllocs;
    9095    ULONG cFrees;
    9196    ULONG cbTotalAllocated;
    92    
     97
    9398};
    9499
    … …  
    119124
    120125    ULONG hlogfile;         // filehandle if default logging functions are used
    121    
     126
    122127    HMODULE hmod;
    123128} RasLogChannel;
    … …  
    126131{
    127132    HMODULE hmod;           // handle of this dll
    128    
     133
    129134    RasLogChannel rlc;
    130    
     135
    131136    Heap_t rasheap;
    132137    void *pHeapMem;
    133138    ULONG ulRefCount;
    134139    ULONG flAllocMem;
    135    
     140
    136141    HMODULE hmodPlugin;
    137    
     142
    138143    RasEntryTable ret;
    139144    RasPluginEntryTable pet;
    … …  
    163168} RASCONTEXT_I;
    164169
     170extern "C" {
     171
    165172void rasSaveContext(RASCONTEXT_I *pcontext)
    166173{
    … …  
    181188
    182189    DosGetInfoBlocks(&ptib, &ppib);
    183    
     190
    184191    return ppib->pib_ulpid << 16 | ptib->tib_ptib2->tib2_ultid;
    185192}
    … …  
    188195{
    189196    int rc = NO_ERROR;
    190    
     197
    191198    rc = DosCreateEventSem (NULL, &crit->hevLock, DC_SEM_SHARED, 0);
    192        
     199
    193200    if (rc != NO_ERROR)
    194201    {
    195202        crit->hevLock = 0;
    196203    }
    197    
     204
    198205    return rc;
    199206}
    … …  
    207214{
    208215    APIRET rc = NO_ERROR;
    209            
     216
    210217    ULONG threadid = rasGetCurrentThreadId ();
    211            
     218
    212219    // We want to acquire the section, count the entering
    213220    DosInterlockedIncrement (&crit->LockCount);
    214    
     221
    215222    if (crit->OwningThread == threadid)
    216223    {
    … …  
    228235            break;
    229236        }
    230        
     237
    231238        rc = DosWaitEventSem (crit->hevLock, ulTimeout);
    232        
    233         if (rc != NO_ERROR) 
     239
     240        if (rc != NO_ERROR)
    234241        {
    235242            // We fail, deregister itself
    … …  
    238245        }
    239246    }
    240    
     247
    241248    // the section was successfully aquired
    242249    crit->RecursionCount = 1;
    243    
     250
    244251    return NO_ERROR;
    245252}
    … …  
    256263    {
    257264        DosInterlockedDecrement (&crit->LockCount);
    258        
     265
    259266        return NO_ERROR;
    260267    }
    261    
     268
    262269    crit->OwningThread = 0;
    263270
    … …  
    270277        DosResetEventSem (crit->hevLock, &ulnrposts);
    271278    }
    272    
     279
    273280    return NO_ERROR;
    274281}
    … …  
    287294void ulong2string (unsigned long number, char *string, int n, int base)
    288295{
    289     static char *digits = "0123456789ABCDEF";
    290    
     296    static const char *digits = "0123456789ABCDEF";
     297
    291298    unsigned long tmp = number;
    292299    char *s = string;
    … …  
    294301    int l = 0;
    295302    int i;
    296    
     303
    297304    if (n <= 0)
    298305    {
    299306        return;
    300307    }
    301    
     308
    302309    if (tmp == 0)
    303310    {
    304311        s[l++] = digits[0];
    305312    }
    306    
     313
    307314    while (tmp != 0)
    308315    {
    … …  
    319326        s[l++] = '\0';
    320327    }
    321    
     328
    322329    s = string;
    323    
     330
    324331    for (i = 0; i < len/2; i++)
    325332    {
    … …  
    338345        return;
    339346    }
    340    
     347
    341348    if (number < 0)
    342349    {
    … …  
    345352        n--;
    346353    }
    347    
     354
    348355    ulong2string (number, string, n, base);
    349356}
    350  
     357
    351358int string2ulong (const char *string, char **pstring2, unsigned long *pvalue, int base)
    352359{
    353360    unsigned long value = 0;
    354361    int sign = 1;
    355    
     362
    356363    const char *p = string;
    357    
     364
    358365    if (p[0] == '-')
    359366    {
    … …  
    361368        p++;
    362369    }
    363    
     370
    364371    if (base == 0)
    365372    {
    … …  
    379386        }
    380387    }
    381            
     388
    382389    while (*p)
    383390    {
    384391        int digit = 0;
    385        
     392
    386393        if ('0' <= *p && *p <= '9')
    387394        {
    … …  
    400407            break;
    401408        }
    402        
     409
    403410        if (digit >= base)
    404411        {
    405412            break;
    406413        }
    407        
     414
    408415        value = value*base + digit;
    409        
     416
    410417        p++;
    411418    }
    412    
     419
    413420    if (pstring2)
    414421    {
    415422        *pstring2 = (char *)p;
    416423    }
    417    
     424
    418425    *pvalue = sign*value;
    419    
     426
    420427    return 1;
    421428}
     429
     430#ifndef __GNUC__
    422431
    423432int vsnprintf (char *buf, int n, const char *fmt, va_list args)
    … …  
    426435    char *s = (char *)fmt;
    427436    char *d = buf;
    428    
     437
    429438    if (n <= 0)
    430439    {
    431440        return 0;
    432441    }
    433    
     442
    434443    n--;
    435    
     444
    436445    while (*s && count < n)
    437446    {
    438447        char tmpstr[16];
    439      
     448
    440449        char *str = NULL;
    441        
     450
    442451        int width = 0;
    443452        int precision = 0;
    444            
     453
    445454        if (*s == '%')
    446455        {
    447456            s++;
    448            
     457
    449458            if ('0' <= *s && *s <= '9' || *s == '-')
    450459            {
    … …  
    462471                string2ulong (s, &s, (unsigned long *)&precision, 10);
    463472            }
    464            
     473
    465474            if (*s == 's')
    466475            {
    … …  
    480489            {
    481490                int num = va_arg(args, int);
    482            
     491
    483492                ulong2string (num, tmpstr, sizeof (tmpstr), 16);
    484                
     493
    485494                str = &tmpstr[0];
    486495                s++;
    … …  
    494503                    s++;
    495504                }
    496                
     505
    497506                if (*s == 'd' || *s == 'i')
    498507                {
    499508                    int num = va_arg(args, int);
    500                
     509
    501510                    long2string (num, tmpstr, sizeof (tmpstr), 10);
    502                
     511
    503512                    str = &tmpstr[0];
    504513                    s++;
    … …  
    507516                {
    508517                    int num = va_arg(args, int);
    509                
     518
    510519                    ulong2string (num, tmpstr, sizeof (tmpstr), 10);
    511                
     520
    512521                    str = &tmpstr[0];
    513522                    s++;
    … …  
    516525                {
    517526                    int num = va_arg(args, int);
    518                
     527
    519528                    ulong2string (num, tmpstr, sizeof (tmpstr), 16);
    520                
     529
    521530                    str = &tmpstr[0];
    522531                    s++;
    … …  
    524533            }
    525534        }
    526        
     535
    527536        if (str != NULL)
    528537        {
    … …  
    531540            int len = strlen (str);
    532541            int leftalign = 0;
    533            
     542
    534543            if (width < 0)
    535544            {
    … …  
    537546                leftalign = 1;
    538547            }
    539            
     548
    540549            if (precision)
    541550            {
    … …  
    546555                    precision--;
    547556                }
    548                
     557
    549558                memcpy (&numstr[i], str, len);
    550                
     559
    551560                str = &numstr[0];
    552561                len += i;
    553562            }
    554            
     563
    555564            if (len < width && !leftalign)
    556565            {
    … …  
    561570                    count++;
    562571                }
    563                
     572
    564573                if (count >= n)
    565574                {
    … …  
    567576                }
    568577            }
    569            
     578
    570579            i = 0;
    571580            while (i < len && count < n)
    … …  
    574583                count++;
    575584            }
    576                
     585
    577586            if (count >= n)
    578587            {
    579588                break;
    580589            }
    581            
     590
    582591            if (len < width && leftalign)
    583592            {
    … …  
    588597                    count++;
    589598                }
    590                
     599
    591600                if (count >= n)
    592601                {
    … …  
    601610        }
    602611    }
    603    
     612
    604613    *d = '\0';
    605    
     614
    606615    return count + 1;
    607616}
    608617
     618#endif // ifndef __GNUC__
     619
     620#ifdef __GNUC__
     621int WIN32API_VA ras_snprintf (char *buf, int n, const char *fmt, ...)
     622#else
    609623int WIN32API snprintf (char *buf, int n, const char *fmt, ...)
     624#endif
    610625{
    611626    va_list args;
    612    
     627
    613628    int rc = 0;
    614629
    615630    va_start (args, fmt);
    616    
     631
    617632    rc = vsnprintf (buf, n, fmt, args);
    618633
    619634    va_end (args);
    620    
     635
    621636    return rc;
    622637}
    … …  
    625640{
    626641    ULONG ulAction = 0;
    627    
     642
    628643    int rc = DosOpen (logfilename, ph, &ulAction, 0L, FILE_ARCHIVED,
    629644                      OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
    630645                      OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE |
    631646                      OPEN_ACCESS_READWRITE, 0L);
    632                          
     647
    633648    if (rc == ERROR_TOO_MANY_OPEN_FILES)
    634649    {
    635650        LONG lReqCount = 10l;
    636651        ULONG ulCurMaxFH = 0ul;
    637          
     652
    638653        DosSetRelMaxFH (&lReqCount, &ulCurMaxFH);
    639            
     654
    640655        rc = DosOpen (logfilename, ph, &ulAction, 0L, FILE_ARCHIVED,
    641656                      OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
    … …  
    643658                      OPEN_ACCESS_READWRITE, 0L);
    644659    }
    645        
     660
    646661    if (rc != NO_ERROR)
    647662    {
    648663        *ph = -1;
    649664    }
    650    
     665
    651666    return rc;
    652667}
    … …  
    660675{
    661676    ULONG ulActual = 0;
    662            
     677
    663678    DosWrite ((HFILE)h, msg, len, &ulActual);
    664679}
    … …  
    671686        prlc->hlogfile = -1;
    672687    }
    673    
     688
    674689    if (prlc->hmod)
    675690    {
    … …  
    677692        prlc->hmod            = NULLHANDLE;
    678693    }
    679    
     694
    680695    prlc->pfnWriteLog     = NULL;
    681696    prlc->pfnOpenLogFile  = NULL;
    … …  
    687702{
    688703    int rc = NO_ERROR;
    689    
     704
    690705    const char *env = NULL;
    691        
     706
    692707    DosScanEnv (env_loghandler, &env);
    693    
     708
    694709    HMODULE hmod = NULLHANDLE;
    695        
     710
    696711    PFN popenlogfile = NULL;
    697712    PFN pcloselogfile = NULL;
    698713    PFN pwritelog = NULL;
    699          
     714
    700715    if (env)
    701716    {
    702717        rc = DosLoadModule (NULL, 0, env, &hmod);
    703            
     718
    704719        if (rc == NO_ERROR)
    705720        {
    706721            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_OPENLOGFILE", &popenlogfile);
    707722        }
    708            
     723
    709724        if (rc == NO_ERROR)
    710725        {
    711726            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_CLOSELOGFILE", &pcloselogfile);
    712727        }
    713            
     728
    714729        if (rc == NO_ERROR)
    715730        {
    716731            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_WRITELOG", &pwritelog);
    717732        }
    718            
     733
    719734        if (rc != NO_ERROR && hmod)
    720735        {
    … …  
    723738        }
    724739    }
    725        
     740
    726741    if (rc == NO_ERROR && hmod && popenlogfile && pcloselogfile && pwritelog)
    727742    {
    … …  
    739754        prlc->hlogfile        = -1;
    740755        prlc->hmod            = NULLHANDLE;
    741        
     756
    742757        rc = NO_ERROR;
    743758    }
    744        
     759
    745760    rc = prlc->pfnOpenLogFile (&prlc->hlogfile, filename);
    746    
     761
    747762    if (rc != NO_ERROR)
    748763    {
    … …  
    750765        rasCloseLogChannel (prlc);
    751766    }
    752        
     767
    753768    return rc;
    754769}
    … …  
    757772{
    758773    int rc = NO_ERROR;
    759    
     774
    760775    const char *filename = "win32ras.log";
    761    
     776
    762777    const char *env = NULL;
    763    
     778
    764779    DosScanEnv ("WIN32RAS_LOG_FILENAME", &env);
    765        
     780
    766781    if (env)
    767782    {
    768783        filename = env;
    769784    }
    770        
     785
    771786    char uniqueLogFileName[260];
    772        
     787
    773788    snprintf (uniqueLogFileName, sizeof(uniqueLogFileName),
    774               "%s.%d", filename, loadNr);
    775        
     789              "%s.%d", filename, getpid());
     790
    776791    if (rasdata.rlc.hlogfile == -1)
    777792    {
    778793        rc = rasOpenLogChannel ("WIN32RAS_LOGHANDLER", &rasdata.rlc, uniqueLogFileName);
    779794    }
    780    
     795
    781796    return rc;
    782797}
    … …  
    787802}
    788803
    789 void rasLogInternalV (RAS_LOG_CHANNEL_H hchannel, char *fmt, va_list args)
     804void rasLogInternalV (RAS_LOG_CHANNEL_H hchannel, const char *fmt, va_list args)
    790805{
    791806    static char szOutMsg[4096];
    792807
    793808    ULONG ulHdrLen = snprintf (szOutMsg, sizeof (szOutMsg), "%s", "");
    794    
     809
    795810    ulHdrLen -= 1;
    796    
     811
    797812    ULONG ulMsgLen = vsnprintf (&szOutMsg[ulHdrLen], sizeof (szOutMsg) - ulHdrLen, fmt, args);
    798813
    799814    ulMsgLen -= 1;
    800    
     815
    801816    if (ulMsgLen > 0)
    802817    {
    … …  
    810825            }
    811826        }
    812        
     827
    813828        RasLogChannel *prlc = hchannel? (RasLogChannel *)hchannel: &rasdata.rlc;
    814      
     829
    815830        prlc->pfnWriteLog (prlc->hlogfile, szOutMsg, ulMsgLen + ulHdrLen);
    816831    }
    817832}
    818833
    819 void rasLog (char *fmt, ...)
     834void rasLog (const char *fmt, ...)
    820835{
    821836    va_list args;
    822837
    823838    va_start (args, fmt);
    824    
     839
    825840    rasLogInternalV (NULL, fmt, args);
    826    
     841
    827842    va_end (args);
    828843}
    829844
    830 void rasLogInternal (char *fmt, ...)
     845void rasLogInternal (const char *fmt, ...)
    831846{
    832847    va_list args;
    833848
    834849    va_start (args, fmt);
    835    
     850
    836851    rasLogInternalV (NULL, fmt, args);
    837    
     852
    838853    va_end (args);
    839854}
    840855
    841 void WIN32API rasLogExternal (char *fmt, ...)
     856void WIN32API_VA rasLogExternal (const char *fmt, ...)
    842857{
    843858    va_list args;
    … …  
    846861
    847862    va_start (args, fmt);
    848    
     863
    849864    rasLogInternalV (NULL, fmt, args);
    850    
     865
    851866    va_end (args);
    852    
     867
    853868    SetFS (sel);
    854869}
    … …  
    876891
    877892    *clean = _BLOCK_CLEAN;
    878    
     893
    879894    rc = DosAllocSharedMem (&p, NULL, *size, rasdata.flAllocMem | OBJ_GETTABLE);
    880    
     895
    881896    if (rc != NO_ERROR)
    882897    {
    883898        rasLog ("RAS heap: getmore_fn: DosAllocSharedMem failed, rc = %d\n", rc);
    884899    }
    885    
     900
    886901    return p;
    887902}
    … …  
    906921    {
    907922        rasdata.flAllocMem = PAG_READ | PAG_WRITE | PAG_COMMIT;
    908    
     923
    909924        if (rascfg.fUseHighMem)
    910925        {
    911926            ULONG ulSysinfo = 0;
    912        
     927
    913928            rc = DosQuerySysInfo (QSV_VIRTUALADDRESSLIMIT, QSV_VIRTUALADDRESSLIMIT, &ulSysinfo, sizeof (ulSysinfo));
    914    
     929
    915930            if (rc == NO_ERROR && ulSysinfo > 512)   // VirtualAddresslimit is in MB
    916931            {
    917932                rasdata.flAllocMem |= PAG_ANY;
    918            
     933
    919934                rasLog ("RAS heap initialization: will use high memory\n");
    920935            }
    921936        }
    922937
    923         rc = DosAllocSharedMem (&rasdata.pHeapMem, NULL, rascfg.ulInitHeapSize, 
     938        rc = DosAllocSharedMem (&rasdata.pHeapMem, NULL, rascfg.ulInitHeapSize,
    924939                                rasdata.flAllocMem | OBJ_GETTABLE);
    925940        if (rc != NO_ERROR)
    … …  
    928943            return NO_ERROR;
    929944        }
    930        
    931         rasdata.rasheap = _ucreate (rasdata.pHeapMem, rascfg.ulInitHeapSize, 
     945
     946        rasdata.rasheap = _ucreate (rasdata.pHeapMem, rascfg.ulInitHeapSize,
    932947                                    _BLOCK_CLEAN, _HEAP_REGULAR | _HEAP_SHARED,
    933948                                    getmore_fn, release_fn);
    … …  
    936951        {
    937952            rasLog ("RAS heap initialization: _ucreate failed\n");
    938            
     953
    939954            DosFreeMem (rasdata.pHeapMem);
    940955            rasdata.pHeapMem = NULL;
    941            
     956
    942957            return ERROR_NOT_ENOUGH_MEMORY;
    943958        }
    … …  
    949964         */
    950965        rc = DosGetSharedMem (rasdata.pHeapMem, rasdata.flAllocMem);
    951        
     966
    952967        if (rc != NO_ERROR)
    953968        {
    954969            rasLog ("RAS heap initialization: DosGetSharedMem failed %d\n", rc);
    955            
     970
    956971            return rc;
    957972        }
    … …  
    960975        {
    961976            rasLog ("RAS heap initialization: _uopen failed\n");
    962            
     977
    963978            DosFreeMem (rasdata.pHeapMem);
    964            
     979
    965980            return ERROR_NOT_ENOUGH_MEMORY;
    966981        }
    967982    }
    968    
     983
    969984    rasdata.ulRefCount++;
    970    
     985
    971986    return NO_ERROR;
    972987}
    … …  
    980995       return 1;
    981996    }
    982    
    983     if (useflag == _USEDENTRY) 
     997
     998    if (useflag == _USEDENTRY)
    984999    {
    9851000        if (filename)
    … …  
    10011016    {
    10021017        rasLog ("RAS heap uninitialization: privateRefCount = %d\n", privateRefCount);
    1003    
     1018
    10041019        return;
    10051020    }
    … …  
    10171032
    10181033            _uclose (rasdata.rasheap);
    1019            
     1034
    10201035            _udestroy (rasdata.rasheap, _FORCE);
    10211036            rasdata.rasheap = NULL;
    10221037        }
    1023        
     1038
    10241039        if (rasdata.pHeapMem)
    10251040        {
    … …  
    10281043        }
    10291044    }
    1030     else 
     1045    else
    10311046    {
    10321047        _uclose (rasdata.rasheap);
    … …  
    10371052{
    10381053    void *p = _umalloc(rasdata.rasheap, size);
    1039    
     1054
    10401055    if (p)
    10411056    {
    … …  
    10461061        rasLog ("RAS heap: allocation failed, %d bytes\n", size);
    10471062    }
    1048    
     1063
    10491064    return p;
    10501065}
    … …  
    10601075{
    10611076    RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1062    
     1077
    10631078    while (iter)
    10641079    {
    … …  
    10671082            break;
    10681083        }
    1069        
     1084
    10701085        iter = iter->next;
    10711086    }
    1072    
     1087
    10731088    return iter;
    10741089}
    … …  
    10761091ULONG rasGenObjIdent (void)
    10771092{
    1078     static objident = 0;
    1079    
     1093    static ULONG objident = 0;
     1094
    10801095    objident++;
    1081    
     1096
    10821097    if (objident == 0)
    10831098    {
    10841099        objident++;
    10851100    }
    1086    
     1101
    10871102    return objident;
    10881103}
    … …  
    11001115        h->objlast = h->objfirst = pinfo;
    11011116    }
    1102    
     1117
    11031118    return NO_ERROR;
    11041119}
    1105      
     1120
    11061121void rasRemoveObjectInfo (RAS_OBJECT_INFO *pinfo)
    11071122{
    … …  
    11151130        pinfo->h->objlast = pinfo->prev;
    11161131    }
    1117    
     1132
    11181133    if (pinfo->prev)
    11191134    {
    … …  
    11311146{
    11321147    pinfo->objhandle = objhandle;
    1133    
     1148
    11341149    pinfo->h = h;
    1135    
     1150
    11361151    pinfo->usecount = 1;
    1137    
     1152
    11381153    pinfo->objident = rasGenObjIdent ();
    11391154
    … …  
    11461161        }
    11471162    }
    1148    
     1163
    11491164    pinfo->cbobjdata = cbobjdata;
    11501165}
    … …  
    11521167struct _RAS_OBJECT_INFO *rasSearchObject2 (RAS_TRACK_HANDLE h, ULONG objident)
    11531168{
    1154     if (!h) 
     1169    if (!h)
    11551170    {
    11561171        return NULL;
    … …  
    11581173
    11591174    RAS_OBJECT_INFO *iter = h->objfirst;
    1160    
     1175
    11611176    while (iter)
    11621177    {
    … …  
    11671182        iter = iter->next;
    11681183    }
    1169    
     1184
    11701185    return iter;
    11711186}
    … …  
    11811196struct _RAS_OBJECT_INFO *rasSearchObject (RAS_TRACK_HANDLE h, ULONG objhandle, RAS_OBJECT_INFO **ppinfo_next)
    11821197{
    1183     if (!h) 
     1198    if (!h)
    11841199    {
    11851200        return NULL;
    … …  
    11871202
    11881203    RAS_OBJECT_INFO *iter = h->objfirst;
    1189    
     1204
    11901205    while (iter)
    11911206    {
    … …  
    11941209            break;
    11951210        }
    1196        
     1211
    11971212        iter = iter->next;
    11981213    }
    1199    
     1214
    12001215    if (iter && ppinfo_next)
    12011216    {
    12021217        *ppinfo_next = iter->next;
    12031218    }
    1204    
     1219
    12051220    return iter;
    12061221}
    … …  
    12141229{
    12151230    pinfo->usecount--;
    1216    
     1231
    12171232    return pinfo->usecount;
    12181233}
    … …  
    12231238    char buf[128];
    12241239    char *p = &buf[0];
    1225    
     1240
    12261241    if (!objdata)
    12271242    {
    12281243        return NO_ERROR;
    12291244    }
    1230    
     1245
    12311246    for (i = 0; i < cbobjdata; i++)
    12321247    {
    … …  
    12381253                 p = &buf[0];
    12391254             }
    1240              
     1255
    12411256             snprintf (p, sizeof(buf) - (p - &buf[0]), "%8.8x:", i / 16);
    12421257             p += strlen (p);
    12431258        }
    1244        
     1259
    12451260        snprintf (p, sizeof(buf) - (p - &buf[0]), " %2.2x", ((char *)objdata)[i]);
    12461261        p += strlen (p);
    12471262    }
    1248    
     1263
    12491264    pRasLog ("%s\n", buf);
    1250    
     1265
    12511266    return NO_ERROR;
    12521267}
    … …  
    12581273        return 1;
    12591274    }
    1260    
     1275
    12611276    if (objdata1 == NULL || objdata2 == NULL)
    12621277    {
    … …  
    12641279        return 1;
    12651280    }
    1266    
     1281
    12671282    return memcmp (objdata1, objdata2, cbobjdata1);
    12681283}
    12691284
    1270 ULONG rasCallLogObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx, 
    1271                                ULONG objident, ULONG objhandle, 
     1285ULONG rasCallLogObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx,
     1286                               ULONG objident, ULONG objhandle,
    12721287                               void *objdata, ULONG cbobjdata, FNRASLOG_EXTERNAL *rasLogExternal)
    12731288{
    12741289    rasRestoreContext (pctx);
    1275    
     1290
    12761291    ULONG rc = h->pfnLogObjectContent (objident, objhandle, objdata, cbobjdata, rasLogExternal);
    1277    
     1292
    12781293    rasSaveContext (pctx);
    1279    
     1294
    12801295    return rc;
    12811296}
    12821297
    1283 ULONG WIN32API rasCallCompareObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx, 
     1298ULONG WIN32API rasCallCompareObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx,
    12841299                                            ULONG objhandle, void *objdata1, ULONG cbobjdata1, void *objdata2, ULONG cbobjdata2)
    12851300{
    12861301    rasRestoreContext (pctx);
    1287    
     1302
    12881303    ULONG rc = h->pfnCompareObjectContent (objhandle, objdata1, cbobjdata1, objdata2, cbobjdata2);
    1289    
     1304
    12901305    rasSaveContext (pctx);
    1291    
     1306
    12921307    return rc;
    12931308}
    … …  
    13011316{
    13021317   const char *env = NULL;
    1303    
     1318
    13041319   DosScanEnv (name, &env);
    1305        
     1320
    13061321   if (env)
    13071322   {
    13081323       ULONG ul = 0;
    13091324       char *e = NULL;
    1310        
     1325
    13111326       string2ulong (env, &e, &ul, 10);
    1312            
     1327
    13131328       if (e && *e == '\0')
    13141329       {
    … …  
    13241339{
    13251340    int rc = NO_ERROR;
    1326    
     1341
    13271342    if (!rasdata.hmodPlugin)
    13281343    {
    13291344        rasdata.ret.cb = sizeof (RasEntryTable);
    1330                
     1345
    13311346        rasdata.ret.RasRegisterObjectTracking   = RasRegisterObjectTracking;
    13321347        rasdata.ret.RasDeregisterObjectTracking = RasDeregisterObjectTracking;
    … …  
    13431358        rasdata.ret.RasLogNoEOL                 = RasLogNoEOL2;
    13441359        rasdata.ret.RasLogMsg                   = RasLogMsg2;
     1360#ifdef __GNUC__
     1361        rasdata.ret.snprintf                    = ras_snprintf;
     1362#else
    13451363        rasdata.ret.snprintf                    = snprintf;
     1364#endif
    13461365        rasdata.ret.RasSaveContext              = RasSaveContext;
    13471366        rasdata.ret.RasRestoreContext           = RasRestoreContext;
    … …  
    13531372        rasdata.ret.RasTrackMemFree             = RasTrackMemFree;
    13541373        rasdata.ret.RasGetTrackHandle           = RasGetTrackHandle;
    1355        
     1374
    13561375        rasdata.pet.cb = sizeof (RasPluginEntryTable);
    1357          
     1376
    13581377        rasdata.pet.RasEntry                    = _RasEntry;
    13591378
    13601379        const char *env = NULL;
    1361        
     1380
    13621381        DosScanEnv ("WIN32RAS_PLUGIN", &env);
    1363          
     1382
    13641383        if (env)
    13651384        {
    13661385            HMODULE hmod = NULLHANDLE;
    13671386            FNPI *pfnPluginInit  = NULL;
    1368          
     1387
    13691388            rc = DosLoadModule (NULL, 0, env, &hmod);
    1370            
     1389
    13711390            if (rc == NO_ERROR)
    13721391            {
    13731392                rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_PLUGIN_INIT", (PFN *)&pfnPluginInit);
    13741393            }
    1375            
     1394
    13761395            if (rc != NO_ERROR)
    13771396            {
    13781397                rasLogInternal ("Could not load RAS plugin %s rc = %d", env, rc);
    13791398            }
    1380            
     1399
    13811400            if (rc != NO_ERROR && hmod)
    13821401            {
    … …  
    13861405            {
    13871406                rasdata.hmodPlugin = hmod;
    1388                
     1407
    13891408                pfnPluginInit (rasdata.hmod, &rasdata.ret, &rasdata.pet);
    13901409            }
    13911410        }
    13921411    }
    1393    
     1412
    13941413    return rc;
    13951414}
    … …  
    13981417{
    13991418    int rc = NO_ERROR;
    1400    
     1419
    14011420    if (rasdata.hmodPlugin)
    14021421    {
    14031422        HMODULE hmod = rasdata.hmodPlugin;
    14041423        FNPE *pfnPluginExit  = NULL;
    1405        
     1424
    14061425        rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_PLUGIN_EXIT", (PFN *)&pfnPluginExit);
    1407            
     1426
    14081427        if (rc == NO_ERROR)
    14091428        {
    14101429            pfnPluginExit (rasdata.hmod);
    14111430        }
    1412        
     1431
    14131432        DosFreeModule (hmod);
    14141433    }
    1415    
     1434
    14161435    return rc;
    14171436}
    … …  
    14631482{
    14641483   int rc = NO_ERROR;
    1465    
     1484
    14661485   if (!rasInitialized)
    14671486   {
    14681487       rasInitialized = 1;
    1469        
     1488
    14701489       memset (&rascfg, 0, sizeof (rascfg));
    1471        
     1490
    14721491       rascfg.ulTimeout = 60000; // default 1 minute
    14731492       rasQueryEnvUlong ("WIN32RAS_TIMEOUT", &rascfg.ulTimeout, 1, 3600, 1000);
    1474        
     1493
    14751494       rascfg.ulInitHeapSize = 128*1024;
    14761495       rasQueryEnvUlong ("WIN32RAS_INITHEAPSIZE", &rascfg.ulInitHeapSize, 64, 16*1024, 1024);
    1477        
     1496
    14781497       ULONG ul = 0;
    14791498       rasQueryEnvUlong ("WIN32RAS_DUMPHEAPOBJECTS", &ul, 0, 1, 1);
    14801499       rascfg.fDumpHeapObjects = ul;
    1481        
     1500
    14821501       ul = 1;
    14831502       rasQueryEnvUlong ("WIN32RAS_USEHIGHMEM", &ul, 0, 1, 1);
    14841503       rascfg.fUseHighMem = ul;
    1485        
     1504
    14861505       ul = 0;
    14871506       rasQueryEnvUlong ("WIN32RAS_ENABLE", &ul, 0, 1, 1);
    14881507       rascfg.fRasEnable = ul;
    1489        
     1508
    14901509       ul = 0;
    14911510       rasQueryEnvUlong ("WIN32RAS_BREAKPOINT", &ul, 0, 1, 1);
    14921511       rascfg.fRasBreakPoint = ul;
    1493        
     1512
    14941513       memset (&rasdata, 0, sizeof (rasdata));
    14951514       rasdata.rlc.hlogfile = -1;
    14961515       rasdata.hmod = hmod;
    1497        
     1516
    14981517       rc = NO_ERROR;
    14991518   }
    1500    
     1519
    15011520   if (!rascfg.fRasEnable)
    15021521   {
    … …  
    15101529
    15111530   rc = rasInitializeLog ();
    1512    
     1531
    15131532   if (rc == NO_ERROR)
    15141533   {
    15151534       rc = rasInitializeCriticalSection (&csras);
    15161535   }
    1517    
     1536
    15181537   if (rc == NO_ERROR)
    15191538   {
    15201539       rc = rasInitializeHeap ();
    15211540   }
    1522    
     1541
    15231542   if (rc == NO_ERROR)
    15241543   {
    15251544       rc = rasInitializePlugin ();
    15261545   }
    1527    
     1546
    15281547   return rc;
    15291548}
    … …  
    15321551{
    15331552    ENTER_RAS(NO_HANDLE);
    1534    
     1553
    15351554    /* Deregister all objects */
    15361555    while (rasdata.firsttrack)
    15371556    {
    15381557        RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1539        
     1558
    15401559        if (iter->fLogAtExit)
    15411560        {
    15421561            RasLogObjects (iter, iter->fLogObjectsAtExit? RAS_FLAG_LOG_OBJECTS: 0);
    15431562        }
    1544        
     1563
    15451564        RasDeregisterObjectTracking (iter);
    1546        
     1565
    15471566        rasFree (iter);
    15481567    }
    1549    
     1568
    15501569    rasUninitializePlugin ();
    1551    
     1570
    15521571    rasUninitializeHeap ();
    1553    
     1572
    15541573    EXIT_RAS();
    1555    
     1574
    15561575    rasUninitializeCriticalSection (&csras);
    1557    
    1558     rasUninitializeLog (); 
     1576
     1577    rasUninitializeLog ();
    15591578}
    15601579
    … …  
    15621581{
    15631582    ENTER_RAS_RET(NO_HANDLE, NULL);
    1564    
     1583
    15651584    RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1566    
     1585
    15671586    while (iter)
    15681587    {
    … …  
    15711590            break;
    15721591        }
    1573        
     1592
    15741593        iter = iter->next;
    15751594    }
    1576    
     1595
    15771596    EXIT_RAS();
    1578    
     1597
    15791598    return iter;
    15801599}
    15811600
    1582 void WIN32API RasRegisterObjectTracking (RAS_TRACK_HANDLE *ph, char *objname,
     1601void WIN32API RasRegisterObjectTracking (RAS_TRACK_HANDLE *ph, const char *objname,
    15831602                                         ULONG cbuserdata,
    15841603                                         ULONG flags,
    … …  
    15871606{
    15881607    ENTER_RAS(NO_HANDLE);
    1589    
     1608
    15901609    RAS_TRACK *prt = (RAS_TRACK *)rasAlloc (sizeof (RAS_TRACK));
    1591    
     1610
    15921611    if (prt)
    15931612    {
    15941613        strcpy (prt->objname, objname);
    1595        
     1614
    15961615        prt->cbuserdata = cbuserdata;
    1597    
     1616
    15981617        if (flags & RAS_TRACK_FLAG_LOGOBJECTCONTENT)
    15991618        {
    16001619            prt->fLogObjectContent = 1;
    16011620        }
    1602    
     1621
    16031622        if (flags & RAS_TRACK_FLAG_MEMORY)
    16041623        {
    16051624            prt->fMemory = 1;
    16061625        }
    1607        
     1626
    16081627        if (flags & RAS_TRACK_FLAG_LOG_AT_EXIT)
    16091628        {
    16101629            prt->fLogAtExit = 1;
    16111630        }
    1612    
     1631
    16131632        if (flags & RAS_TRACK_FLAG_LOG_OBJECTS_AT_EXIT)
    16141633        {
    16151634            prt->fLogObjectsAtExit = 1;
    16161635        }
    1617    
     1636
    16181637        if (pfnLogObjectContent)
    16191638        {
    … …  
    16241643            prt->pfnLogObjectContent = rasLogObjectContent;
    16251644        }
    1626        
     1645
    16271646        if (pfnCompareObjectContent)
    16281647        {
    … …  
    16331652            prt->pfnCompareObjectContent = pfnCompareObjectContent;
    16341653        }
    1635        
     1654
    16361655        /* Insert the new tracking record in the list */
    16371656        if (rasdata.firsttrack)
    … …  
    16451664            rasdata.lasttrack = rasdata.firsttrack = prt;
    16461665        }
    1647        
     1666
    16481667        *ph = prt;
    16491668    }
    … …  
    16571676
    16581677    h = rasVerifyTrackHandle (h);
    1659    
     1678
    16601679    if (h)
    16611680    {
    … …  
    16641683        {
    16651684            RAS_OBJECT_INFO *iter = h->objfirst;
    1666            
     1685
    16671686            rasRemoveObjectInfo (iter);
    1668            
     1687
    16691688            rasFree (iter);
    16701689        }
    1671        
     1690
    16721691        /* Remove the track record */
    16731692        if (h->next)
    … …  
    16801699            rasdata.lasttrack = h->prev;
    16811700        }
    1682    
     1701
    16831702        if (h->prev)
    16841703        {
    … …  
    16911710        }
    16921711    }
    1693    
     1712
    16941713    EXIT_RAS ();
    16951714}
    … …  
    17001719{
    17011720    ENTER_RAS_RET (h, 0);
    1702    
     1721
    17031722    struct _RAS_OBJECT_INFO *pinfo_next = NULL;
    1704    
     1723
    17051724    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject (h, objhandle, &pinfo_next);
    1706    
     1725
    17071726//    rasLog ("Object added: handle = %8.8X\n", objhandle);
    1708    
     1727
    17091728    if (pinfo != NULL)
    17101729    {
    … …  
    17151734         */
    17161735        rasIncUseCount (pinfo);
    1717        
     1736
    17181737        /* log this event */
    17191738        rasLog ("Dublicate object added: handle = %8.8X\n", objhandle);
    … …  
    17221741            rasLogInternal ("Added object content:\n");
    17231742            rasCallLogObjectContent (h, &ctx, pinfo->objident, objhandle, objdata, cbobjdata, rasLogExternal);
    1724            
     1743
    17251744            rasLogInternal ("Existing object content:\n");
    17261745            rasCallLogObjectContent (h, &ctx, pinfo->objident, objhandle, pinfo->objdata, pinfo->cbobjdata, rasLogExternal);
    1727            
     1746
    17281747            if (rasCallCompareObjectContent (h, &ctx, objhandle, objdata, cbobjdata, pinfo->objdata, pinfo->cbobjdata) != 0)
    17291748            {
    … …  
    17341753    else
    17351754    {
    1736         pinfo = (RAS_OBJECT_INFO *)rasAlloc (sizeof (RAS_OBJECT_INFO) - sizeof (RAS_OBJECT_INFO::userdata) 
    1737                                              + h->cbuserdata 
     1755        pinfo = (RAS_OBJECT_INFO *)rasAlloc (sizeof (RAS_OBJECT_INFO) - sizeof (RAS_OBJECT_INFO::userdata)
     1756                                             + h->cbuserdata
    17381757                                             + (objdata? cbobjdata: 0));
    17391758        if (pinfo)
    17401759        {
    17411760            rasInitObjectInfo (pinfo, h, objhandle, objdata, cbobjdata);
    1742    
     1761
    17431762            int rc = rasAddObjectInfo (pinfo, h, pinfo_next);
    1744            
     1763
    17451764            if (rc != NO_ERROR)
    17461765            {
    1747                 rasFree (pinfo); 
     1766                rasFree (pinfo);
    17481767                pinfo = NULL;
    17491768            }
    … …  
    17521771
    17531772    EXIT_RAS ();
    1754    
     1773
    17551774    if (pinfo)
    17561775    {
    17571776        return pinfo->objident;
    17581777    }
    1759    
     1778
    17601779    return 0;
    17611780}
    … …  
    17641783{
    17651784    ENTER_RAS (h);
    1766    
     1785
    17671786//    rasLog ("Object to remove: handle = %8.8X\n", objhandle);
    1768    
     1787
    17691788    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject (h, objhandle, NULL);
    1770    
     1789
    17711790//    rasLog ("Objects pinfo = %8.8X\n", pinfo);
    1772    
     1791
    17731792    if (pinfo != NULL)
    17741793    {
    … …  
    17761795        {
    17771796            rasRemoveObjectInfo (pinfo);
    1778            
     1797
    17791798            rasFree (pinfo);
    17801799        }
    17811800    }
    1782    
     1801
    17831802    EXIT_RAS ();
    17841803}
    1785              
     1804
    17861805
    17871806void WIN32API RasQueryObjectUserData (RAS_TRACK_HANDLE h, ULONG objident, void *pdata, ULONG cbdata, ULONG *pcbdataret)
    17881807{
    17891808    ENTER_RAS (h);
    1790    
     1809
    17911810    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject2 (h, objident);
    1792    
     1811
    17931812    if (pinfo)
    17941813    {
    … …  
    17971816            cbdata = pinfo->h->cbuserdata;
    17981817        }
    1799    
     1818
    18001819        memcpy (pdata, &pinfo->userdata, cbdata);
    18011820    }
    … …  
    18041823        cbdata = 0;
    18051824    }
    1806    
     1825
    18071826    EXIT_RAS ();
    1808    
     1827
    18091828    if (pcbdataret)
    18101829    {
    18111830        *pcbdataret = cbdata;
    18121831    }
    1813    
     1832
    18141833    return;
    18151834}
    … …  
    18181837{
    18191838    ENTER_RAS (h);
    1820    
     1839
    18211840    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject2 (h, objident);
    1822    
     1841
    18231842    if (pinfo)
    18241843    {
    … …  
    18271846            cbdata = pinfo->h->cbuserdata;
    18281847        }
    1829    
     1848
    18301849        memcpy (&pinfo->userdata, pdata, cbdata);
    18311850    }
    … …  
    18341853        cbdata = 0;
    18351854    }
    1836    
     1855
    18371856    EXIT_RAS ();
    1838    
     1857
    18391858    if (pcbdataret)
    18401859    {
    18411860        *pcbdataret = cbdata;
    18421861    }
    1843    
     1862
    18441863    return;
    18451864}
    18461865
    18471866
    1848 void WIN32API RasLog (char *fmt, ...)
     1867void WIN32API_VA RasLog (const char *fmt, ...)
    18491868{
    18501869    ENTER_RAS (NO_HANDLE);
    1851    
     1870
    18521871    va_list args;
    18531872
    18541873    va_start (args, fmt);
    1855    
     1874
    18561875    rasLogInternalV (NULL, fmt, args);
    1857    
     1876
    18581877    va_end (args);
    1859    
     1878
    18601879    EXIT_RAS ();
    18611880}
    18621881
    1863 void WIN32API RasLogNoEOL (char *fmt, ...)
     1882void WIN32API_VA RasLogNoEOL (const char *fmt, ...)
    18641883{
    18651884    va_list args;
    1866    
     1885
    18671886    ENTER_RAS (NO_HANDLE);
    1868    
     1887
    18691888    va_start (args, fmt);
    1870    
     1889
    18711890    ULONG noeolstate = rasdata.fNoEOL;
    18721891
    18731892    rasdata.fNoEOL = 1;
    1874    
     1893
    18751894    rasLogInternalV (NULL, fmt, args);
    1876    
     1895
    18771896    rasdata.fNoEOL = noeolstate;
    1878    
     1897
    18791898    va_end (args);
    1880    
     1899
    18811900    EXIT_RAS ();
    18821901}
    … …  
    18851904{
    18861905    ENTER_RAS (NO_HANDLE);
    1887    
     1906
    18881907    EXIT_RAS ();
    18891908}
    1890        
     1909
    18911910void WIN32API RasLogObjects (RAS_TRACK_HANDLE h, ULONG flags)
    18921911{
    18931912    ENTER_RAS (h);
    1894    
     1913
    18951914    rasLogInternal ("[%s] objects", h->objname);
    1896    
     1915
    18971916    if (h->fMemory)
    18981917    {
    … …  
    19041923        }
    19051924    }
    1906    
     1925
    19071926    RAS_OBJECT_INFO *iter = h->objfirst;
    1908    
     1927
    19091928    int count = 0;
    19101929    ULONG cb = 0; // count total memory allocated if fMemory is set
    1911    
     1930
    19121931    while (iter)
    19131932    {
    … …  
    19161935            cb += iter->cbobjdata;
    19171936        }
    1918        
     1937
    19191938        if (flags & RAS_FLAG_LOG_OBJECTS)
    19201939        {
    … …  
    19261945            {
    19271946                rasLogInternal ("  handle = %8.8X\n", iter->objhandle);
    1928        
     1947
    19291948                if (h->fLogObjectContent)
    19301949                {
    … …  
    19331952            }
    19341953        }
    1935        
     1954
    19361955        count++;
    1937        
     1956
    19381957        iter = iter->next;
    19391958    }
    1940    
     1959
    19411960    rasLogInternal ("%d [%s] objects", count, h->objname);
    1942    
     1961
    19431962    if (h->fMemory && count > 0)
    19441963    {
    19451964        rasLogInternal ("%d bytes allocated", cb);
    19461965    }
    1947    
     1966
    19481967    EXIT_RAS ();
    1949    
     1968
    19501969    return;
    19511970}
    … …  
    19541973{
    19551974    ENTER_RAS (h);
    1956    
     1975
    19571976    RAS_OBJECT_INFO *iter = h->objfirst;
    1958    
     1977
    19591978    int count = 0;
    19601979    ULONG cb = 0; // count total memory allocated if fMemory is set
    1961    
     1980
    19621981    while (iter)
    19631982    {
    … …  
    19661985            cb += iter->cbobjdata;
    19671986        }
    1968        
     1987
    19691988        count++;
    1970        
     1989
    19711990        iter = iter->next;
    19721991    }
    1973    
     1992
    19741993    if (h->fMemory)
    19751994    {
    … …  
    19791998        }
    19801999    }
    1981    
     2000
    19822001    if (pcount)
    19832002    {
    19842003        *pcount = count;
    19852004    }
    1986    
     2005
    19872006    EXIT_RAS ();
    1988    
     2007
    19892008    return;
    19902009}
    19912010
    1992 void WIN32API RasLog2 (RAS_LOG_CHANNEL_H hchannel, char *fmt, ...)
     2011void WIN32API_VA RasLog2 (RAS_LOG_CHANNEL_H hchannel, char *fmt, ...)
    19932012{
    19942013    ENTER_RAS (NO_HANDLE);
    1995    
     2014
    19962015    va_list args;
    19972016
    19982017    va_start (args, fmt);
    1999    
     2018
    20002019    rasLogInternalV (hchannel, fmt, args);
    2001    
     2020
    20022021    va_end (args);
    2003    
     2022
    20042023    EXIT_RAS ();
    20052024}
    20062025
    2007 void WIN32API RasLogNoEOL2 (RAS_LOG_CHANNEL_H hchannel, char *fmt, ...)
     2026void WIN32API_VA RasLogNoEOL2 (RAS_LOG_CHANNEL_H hchannel, char *fmt, ...)
    20082027{
    20092028    va_list args;
    2010    
     2029
    20112030    ENTER_RAS (NO_HANDLE);
    2012    
     2031
    20132032    va_start (args, fmt);
    2014    
     2033
    20152034    ULONG noeolstate = rasdata.fNoEOL;
    20162035
    20172036    rasdata.fNoEOL = 1;
    2018    
     2037
    20192038    rasLogInternalV (hchannel, fmt, args);
    2020    
     2039
    20212040    rasdata.fNoEOL = noeolstate;
    2022    
     2041
    20232042    va_end (args);
    2024    
     2043
    20252044    EXIT_RAS ();
    20262045}
    … …  
    20292048{
    20302049    ENTER_RAS (NO_HANDLE);
    2031    
     2050
    20322051    EXIT_RAS ();
    20332052}
    … …  
    20472066{
    20482067    ENTER_RAS_RET (NO_HANDLE, ERROR_GEN_FAILURE);
    2049    
     2068
    20502069    int rc = NO_ERROR;
    2051    
     2070
    20522071    RasLogChannel *prlc = (RasLogChannel *)rasAlloc (sizeof (RasLogChannel));
    2053    
     2072
    20542073    if (!prlc)
    20552074    {
    … …  
    20592078    {
    20602079        rc = rasOpenLogChannel (env_loghandler, prlc, filename);
    2061        
     2080
    20622081        if (rc != NO_ERROR)
    20632082        {
    … …  
    20692088        }
    20702089    }
    2071    
     2090
    20722091    EXIT_RAS ();
    2073    
     2092
    20742093    return rc;
    20752094}
    2076        
     2095
    20772096void WIN32API RasWriteLogChannel (RAS_LOG_CHANNEL_H hchannel, const char *msg, ULONG length)
    20782097{
    20792098    ENTER_RAS (NO_HANDLE);
    2080    
     2099
    20812100    if (length > 0)
    20822101    {
    20832102        RasLogChannel *prlc = (RasLogChannel *)hchannel;
    2084      
     2103
    20852104        prlc->pfnWriteLog (prlc->hlogfile, (char *)msg, length);
    20862105    }
    2087    
     2106
    20882107    EXIT_RAS ();
    20892108}
    2090        
     2109
    20912110void WIN32API RasCloseLogChannel (RAS_LOG_CHANNEL_H hchannel)
    20922111{
    20932112    ENTER_RAS (NO_HANDLE);
    2094    
     2113
    20952114    RasLogChannel *prlc = (RasLogChannel *)hchannel;
    2096        
     2115
    20972116    rasCloseLogChannel (prlc);
    2098    
     2117
    20992118    rasFree (prlc);
    2100    
     2119
    21012120    EXIT_RAS ();
    21022121}
    2103        
     2122
    21042123
    21052124void WIN32API RasEntry (ULONG ulEvent, void *p, ULONG cb)
    21062125{
    21072126    ENTER_RAS (NO_HANDLE);
    2108    
     2127
    21092128    if (rasdata.pet.RasEntry)
    21102129    {
    21112130        rasdata.pet.RasEntry (ulEvent, p, cb);
    21122131    }
    2113    
     2132
    21142133    EXIT_RAS ();
    21152134}
    … …  
    21402159{
    21412160    ENTER_RAS (h);
    2142    
     2161
    21432162    if (h->fMemory && size > 0)
    21442163    {
    … …  
    21462165        h->cbTotalAllocated += size;
    21472166    }
    2148    
     2167
    21492168    EXIT_RAS ();
    21502169}
    2151              
     2170
    21522171void WIN32API RasTrackMemRealloc (RAS_TRACK_HANDLE h, ULONG oldsize, ULONG newsize)
    21532172{
    21542173    ENTER_RAS (h);
    2155    
     2174
    21562175    if (h->fMemory)
    21572176    {
    … …  
    21622181        }
    21632182    }
    2164    
     2183
    21652184    EXIT_RAS ();
    21662185}
    2167              
     2186
    21682187void WIN32API RasTrackMemFree (RAS_TRACK_HANDLE h, ULONG size)
    21692188{
    21702189    ENTER_RAS (h);
    2171    
     2190
    21722191    if (h->fMemory && size > 0)
    21732192    {
    … …  
    21752194        h->cbTotalAllocated -= size;
    21762195    }
    2177    
     2196
    21782197    EXIT_RAS ();
    21792198}
    2180              
     2199
     2200} // extern "C"
     2201
Note: See TracChangeset for help on using the changeset viewer.