Changeset 7312 for trunk/src


Ignore:
Timestamp:
Nov 9, 2001, 8:41:09 AM (24 years ago)
Author:
bird
Message:

Logging. (+ New prototypes?)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/win32k/kKrnlLib/testcase/Fake.c

    r6822 r7312  
    1 /* $Id: Fake.c,v 1.2 2001-09-26 03:58:37 bird Exp $
     1/* $Id: Fake.c,v 1.3 2001-11-09 07:41:09 bird Exp $
    22 *
    33 * Fake stubs for the ldr and kernel functions we imports or overloads.
    … …  
    88 *
    99 */
     10#ifndef NOFILEID
     11static const char szFileId[] = "$Id: Fake.c,v 1.3 2001-11-09 07:41:09 bird Exp $";
     12#endif
    1013
    1114/*******************************************************************************
    … …  
    1316*******************************************************************************/
    1417#define INCL_BASE
     18#define INCL_KKL_LOG
     19#define INCL_KKL_PRINTF
     20#define INCL_OS2KRNL_ALL
    1521#define FOR_EXEHDR 1                    /* To make all object flags OBJ???. */
    16 #define INCL_OS2KRNL_ALL
    1722#define DWORD  ULONG
    1823#define WORD   USHORT
    … …  
    3136#include "devSegDf.h"                   /* kKrnlLib segment definitions. */
    3237
    33 #include "kKLlog.h"
    34 #include "OS2Krnl.h"
     38#include <kKrnlLib.h>
     39#include <OS2Krnl.h>
    3540#include "dev32.h"
    3641#include "testcase.h"
    … …  
    172177void  workersinit(void)
    173178{
     179    KLOGENTRY0("void");
    174180    APIRET rc;
    175181
    … …  
    219225
    220226    rc = rc;
     227    KLOGEXITVOID();
    221228}
    222229
    … …  
    232239ULONG LDRCALL fakeldrClose(SFN hFile)
    233240{
     241    KLOGENTRY1("ULONG LDRCALL","SFN hFile", hFile);
    234242    APIRET  rc;
    235243    BOOL    f32Stack = ((int)&hFile > 0x10000);
    … …  
    243251    printf("fakeldrClose:                   hFile = 0x%04x, rc = %d\n", hFile, rc);
    244252
     253    KLOGEXIT(rc);
    245254    return rc;
    246255}
    … …  
    259268ULONG LDRCALL fakeldrOpen(PSFN phFile, PSZ pszFilename, PULONG pfl)
    260269{
     270    KLOGENTRY3("ULONG LDRCALL","PSFN phFile, PSZ pszFilename, PULONG pfl", phFile, pszFilename, pfl);
    261271    ULONG   ulAction;
    262272    HFILE   hFile;
    … …  
    286296           phFile, *phFile, pszFilename, pfl, rc);
    287297
     298    KLOGEXIT(rc);
    288299    return rc;
    289300}
    … …  
    308319ULONG LDRCALL fakeldrRead(SFN hFile, ULONG ulOffset, PVOID pvBuffer, ULONG fpBuffer, ULONG cbToRead, PMTE pMTE)
    309320{
     321    KLOGENTRY6("ULONG LDRCALL","SFN hFile, ULONG ulOffset, PVOID pvBuffer, ULONG fpBuffer, ULONG cbToRead, PMTE pMTE", hFile, ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE);
    310322    ULONG   cbRead,
    311323            ulMoved;
    … …  
    319331        rc = DosRead(hFile, pvBuffer, cbToRead, &cbRead);
    320332    else
    321         kprintf(("fakeldrRead: DosSetFilePtr(hfile, 0x%08x(%d),..) failed with rc = %d.\n",
     333        kprintf(("DosSetFilePtr(hfile, 0x%08x(%d),..) failed with rc = %d.\n",
    322334                 ulOffset, ulOffset, rc));
    323335
    … …  
    327339           hFile, ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE, rc);
    328340
     341    KLOGEXIT(rc);
    329342    return rc;
    330343}
    … …  
    343356ULONG LDRCALL fakeLDRQAppType(PSZ pszFilename, PULONG pul)
    344357{
     358    KLOGENTRY2("ULONG LDRCALL","PSZ pszFilename, PULONG pul", pszFilename, pul);
    345359    DUMMY();
    346360    printf("fakeLDRQAppType:                pszFilename = %s, pul = %p, rc = 0\n", pszFilename, pul);
     361    KLOGEXIT(NO_ERROR);
    347362    return NO_ERROR;
    348363}
    … …  
    368383    )
    369384{
     385    KLOGENTRY6("ULONG LDRCALL","PMTE pMTE, ULONG iObject, ULONG iPageTable, PVOID pvPage, ULONG ulPageAddress, PVOID pvPTDA", pMTE, iObject, iPageTable, pvPage, ulPageAddress, pvPTDA);
    370386    DUMMY();
    371387    printf("fakeldrEnum32bitRelRecs:        pMTE = %p, iObject = 0x%08x, iPageTable = 0x%08x, pvPage = 0x%08x, ulPageAddress = 0x%08x, pvPTDA = %p\n",
    372388           pMTE, iObject, iPageTable, pvPage, ulPageAddress, pvPTDA);
    373389
     390    KLOGEXIT(NO_ERROR);
    374391    return NO_ERROR;
    375392}
    … …  
    391408    )
    392409{
     410    KLOGENTRY4("ULONG LDRCALL","PMTE pMTE, ULONG flObj, PULONG pflFlags1, PULONG pflFlags2", pMTE, flObj, pflFlags1, pflFlags2);
    393411    *pflFlags1 = 0;
    394412    *pflFlags2 = 0;
    395413    flObj = flObj;
    396414    pMTE = pMTE;
     415    KLOGEXIT(0);
    397416    return 0;
    398417}
    … …  
    415434    )
    416435{
     436    KLOGENTRY5("APIRET KRNLCALL","PSZ pszFilename, ULONG flOpenFlags, ULONG fsOpenMode, PSFN phFile, PULONG pulsomething", pszFilename, flOpenFlags, fsOpenMode, phFile, pulsomething);
    417437    ULONG   ulAction;
    418438    HFILE   hFile;
    … …  
    436456           pszFilename, flOpenFlags, fsOpenMode, phFile, *phFile, pulsomething, rc);
    437457
     458    KLOGEXIT(rc);
    438459    return rc;
    439460}
    … …  
    449470    )
    450471{
     472    KLOGENTRY1("APIRET KRNLCALL","SFN hFile", hFile);
    451473    APIRET  rc;
    452474    BOOL    f32Stack = ((int)&hFile > 0x10000);
    … …  
    461483           hFile, rc);
    462484
     485    KLOGEXIT(rc);
    463486    return rc;
    464487}
    … …  
    477500    )
    478501{
     502    KLOGENTRY1("APIRET KRNLCALL","PSZ pszPath", pszPath);
    479503    char    szBuffer[CCHMAXPATH];
    480504    APIRET  rc;
    … …  
    494518    if (!f32Stack) ThunkStack32To16();
    495519
     520    KLOGEXIT(rc);
    496521    return rc;
    497522}
    … …  
    516541    )
    517542{
     543    KLOGENTRY5("APIRET KRNLCALL","SFN hFile, PULONG pcbActual, PVOID pvBuffer, ULONG fpBuffer, ULONG ulOffset", hFile, pcbActual, pvBuffer, fpBuffer, ulOffset);
    518544    ULONG   ulMoved;
    519545    APIRET  rc;
    … …  
    534560           hFile, pcbActual, pvBuffer, fpBuffer, ulOffset, rc);
    535561
     562    KLOGEXIT(rc);
    536563    return rc;
    537564}
    … …  
    556583    )
    557584{
     585    KLOGENTRY5("APIRET KRNLCALL","SFN hFile, PULONG pcbActual, PVOID pvBuffer, ULONG fpBuffer, ULONG ulOffset", hFile, pcbActual, pvBuffer, fpBuffer, ulOffset);
    558586    ULONG   ulMoved;
    559587    APIRET  rc;
    … …  
    574602           hFile, pcbActual, pvBuffer, fpBuffer, ulOffset, rc);
    575603
     604    KLOGEXIT(rc);
    576605    return rc;
    577606}
    … …  
    589618    )
    590619{
     620    KLOGENTRY2("APIRET KRNLCALL","SFN hFile, PULONG pcbFile", hFile, pcbFile);
    591621    FILESTATUS3     fsts3;
    592622    APIRET          rc;
    … …  
    609639           hFile, pcbFile, *pcbFile, rc);
    610640
     641    KLOGEXIT(rc);
    611642    return rc;
    612643}
    … …  
    620651    ULONG ulEIP)
    621652{
     653    KLOGENTRY2("HMTE KRNLCALL","ULONG ulCS, ULONG ulEIP", ulCS, ulEIP);
    622654    DUMMY();
    623655
    … …  
    625657           ulCS, ulEIP, 0);
    626658
     659    KLOGEXIT(0);
    627660    return 0;
    628661}
    … …  
    643676    PVMAC   pvmac)
    644677{
     678    KLOGENTRY9("APIRET KRNLCALL","ULONG cbSize, ULONG cbCommit, ULONG flFlags1, HPTDA hPTDA, USHORT usVMOwnerId, HMTE hMTE, ULONG flFlags2, ULONG SomeArg2, PVMAC pvmac", cbSize, cbCommit, flFlags1, hPTDA, usVMOwnerId, hMTE, flFlags2, SomeArg2, pvmac);
    645679    DUMMY();
    646680    printf("fakeVMAllocMem:                 cbSize = 0x%08x, cbCommit = 0x%08x, flFlags1 = 0x%08x, hPTDA = 0x%04x, usVMOwnerId = 0x%04x, hMTE = 0x%04x, flFlags2 = 0x%08x, SomeArg2 = 0x%08x, pvmac = %p, rc = %d\n",
    647681           cbSize, cbCommit, flFlags1, hPTDA, usVMOwnerId, hMTE, flFlags2, SomeArg2, pvmac, ERROR_NOT_SUPPORTED);
    648682
     683    KLOGEXIT(ERROR_NOT_SUPPORTED);
    649684    return ERROR_NOT_SUPPORTED;
    650685}
    … …  
    660695    )
    661696{
     697    KLOGENTRY3("APIRET KRNLCALL","PVOID pv, USHORT hPTDA, ULONG flFlags", pv, hPTDA, flFlags);
    662698    DUMMY();
    663699    printf("fakeVMFreeMem:                  pv = %p, hPTDA = 0x%04x, flFlags = %08x, rc = %d\n",
    664700           pv, hPTDA, flFlags, ERROR_NOT_SUPPORTED);
    665701
     702    KLOGEXIT(ERROR_NOT_SUPPORTED);
    666703    return ERROR_NOT_SUPPORTED;
    667704}
    … …  
    677714    PUSHORT pushPTDA)
    678715{
     716    KLOGENTRY3("APIRET KRNLCALL","USHORT usHob, PULONG pulAddr, PUSHORT pushPTDA", usHob, pulAddr, pushPTDA);
    679717    APIRET          rc = NO_ERROR;
    680718    BOOL            f32Stack = ((int)&usHob > 0x10000);
    … …  
    703741    printf("fakeVMObjHandleInfo:            usHob = 0x%04x, pulAddr = %p, pushPTDA = %p, rc = %d\n",
    704742           usHob, pulAddr, pushPTDA, rc);
     743    KLOGEXIT(rc);
    705744    return rc;
    706745}
    … …  
    714753    PVMAC   pvmac)
    715754{
     755    KLOGENTRY5("APIRET KRNLCALL","ULONG flVMFlags, ULONG ulAddress, ULONG cbSize, HPTDA hPTDA, PVMAC pvmac", flVMFlags, ulAddress, cbSize, hPTDA, pvmac);
    716756    printf("fakeVMMapDebugAlias:            flVMFlags = 0x%08x, ulAddress = 0x%08, cbSize = 0x%08x, hPTDA = 0x%04x, pvmac = %p - not implemented\n",
    717757           flVMFlags,
    … …  
    721761           pvmac);
    722762
     763    KLOGEXIT(ERROR_NOT_SUPPORTED);
    723764    return ERROR_NOT_SUPPORTED;
    724765}
    … …  
    740781    PVMHOB  phob)
    741782{
     783    KLOGENTRY3("APIRET KRNLCALL","PVOID pvData, VMHOB usOwner, PVMHOB phob", pvData, usOwner, phob);
    742784    DUMMY();
    743785    printf("fakeVMCreatePseudoHandle:              - not implemented\n");
     786    KLOGEXIT(ERROR_NOT_SUPPORTED);
    744787    return ERROR_NOT_SUPPORTED;
    745788}
    … …  
    755798    VMHOB   hob)
    756799{
     800    KLOGENTRY1("APIRET KRNLCALL","VMHOB hob", hob);
    757801    DUMMY();
    758802    printf("fakeVMFreePseudoHandle:                - not implemented\n");
     803    KLOGEXIT(ERROR_NOT_SUPPORTED);
    759804    return ERROR_NOT_SUPPORTED;
    760805}
    … …  
    791836    )
    792837 {
     838     KLOGENTRY5("ULONG LDRCALL","PCHAR pachFilename, USHORT cchFilename, ldrlv_t * plv, PULONG pful, ULONG lLibPath", pachFilename, cchFilename, plv, pful, lLibPath);
    793839     KNOREF(lLibPath);
     840     KLOGEXIT(fakeldrOpenPath_old(pachFilename, cchFilename, plv, pful));
    794841     return fakeldrOpenPath_old(pachFilename, cchFilename, plv, pful);
    795842 }
    … …  
    810857ULONG LDRCALL fakeldrOpenPath_old(PCHAR pachFilename, USHORT cchFilename, ldrlv_t *plv, PULONG pful)
    811858{
     859    KLOGENTRY4("ULONG LDRCALL","PCHAR pachFilename, USHORT cchFilename, ldrlv_t * plv, PULONG pful", pachFilename, cchFilename, plv, pful);
    812860    static char     szPath[1024];       /* Path buffer. Used to store pathlists. 1024 should be enough */
    813861                                        /* for LIBPATH (which at had a limit of ca. 750 chars). */
    … …  
    864912                    break;
    865913                default: /* !internalerror! */
     914                    KLOGEXIT(ERROR_FILE_NOT_FOUND);
    866915                    return ERROR_FILE_NOT_FOUND;
    867916            }
    … …  
    933982                 */
    934983                printf("fakeldrOpenPath:        *exit*  plv->lv_sfn = 0x%04x, rc = %d\n", plv->lv_sfn, rc);
     984                KLOGEXIT(rc);
    935985                return rc;
    936986            }
    … …  
    940990    printf("fakeldrOpenPath:        *exit*  plv->lv_sfn = 0x%04x, rc = %d\n", plv->lv_sfn, rc);
    941991
     992    KLOGEXIT(rc);
    942993    return rc;
    943994}
    … …  
    9531004ULONG LDRCALL fakeLDRClearSem(void)
    9541005{
     1006    KLOGENTRY0("ULONG LDRCALL");
     1007    KLOGEXIT(fakeKSEMReleaseMutex(&fakeLdrSem));
    9551008    return fakeKSEMReleaseMutex(&fakeLdrSem);
    9561009}
    … …  
    9661019ULONG KRNLCALL fakeKSEMRequestMutex(HKSEMMTX hkmtx, ULONG ulTimeout)
    9671020{
     1021    KLOGENTRY2("ULONG KRNLCALL","HKSEMMTX hkmtx, ULONG ulTimeout", hkmtx, ulTimeout);
    9681022    unsigned short usSlot = getSlot();
    9691023    ULONG          rc = NO_ERROR;
    … …  
    9721026    {
    9731027        printf("fakeKSEMQueryMutex:             hkmtx = %p, invalid signature (%.4s)\n", hkmtx, hkmtx->debug.ksem_achSignature);
     1028        KLOGEXIT(FALSE);
    9741029        return FALSE;
    9751030    }
    … …  
    9881043           hkmtx, ulTimeout, hkmtx->debug.ksem_cusNest, hkmtx->debug.ksem_Owner, ERROR_SEM_BUSY);
    9891044
     1045    KLOGEXIT(rc);
    9901046    return rc;
    9911047}
    … …  
    10021058ULONG KRNLCALL fakeKSEMReleaseMutex(HKSEMMTX hkmtx)
    10031059{
     1060    KLOGENTRY1("ULONG KRNLCALL","HKSEMMTX hkmtx", hkmtx);
    10041061    unsigned int    usSlot = getSlot();
    10051062    int rc = NO_ERROR;
    … …  
    10081065    {
    10091066        printf("fakeKSEMQueryMutex:             hkmtx = %p, invalid signature (%.4s)\n", hkmtx, hkmtx->debug.ksem_achSignature);
     1067        KLOGEXIT(FALSE);
    10101068        return FALSE;
    10111069    }
    … …  
    10221080           hkmtx, hkmtx->debug.ksem_cusNest, hkmtx->debug.ksem_Owner, rc);
    10231081
     1082    KLOGEXIT(rc);
    10241083    return rc;
    10251084}
    … …  
    10391098BOOL KRNLCALL  fakeKSEMQueryMutex(HKSEMMTX hkmtx, PUSHORT pcusNest)
    10401099{
     1100    KLOGENTRY2("BOOL KRNLCALL","HKSEMMTX hkmtx, PUSHORT pcusNest", hkmtx, pcusNest);
    10411101    unsigned int    usSlot = getSlot();
    10421102    BOOL            fRc = TRUE;
    … …  
    10451105    {
    10461106        printf("fakeKSEMQueryMutex:             hkmtx = %p, invalid signature (%.4s)\n", hkmtx, hkmtx->debug.ksem_achSignature);
     1107        KLOGEXIT(FALSE);
    10471108        return FALSE;
    10481109    }
    … …  
    10641125           hkmtx, hkmtx->debug.ksem_cusNest, hkmtx->debug.ksem_Owner, pcusNest ? *pcusNest : -1, fRc);
    10651126
     1127    KLOGEXIT(fRc);
    10661128    return fRc;
    10671129}
    … …  
    10781140VOID  KRNLCALL  fakeKSEMInit(PKSEM pksem, ULONG fulType, ULONG fulFlags)
    10791141{
     1142    KLOGENTRY3("VOID KRNLCALL","PKSEM pksem, ULONG fulType, ULONG fulFlags", pksem, fulType, fulFlags);
    10801143    if (fulType != KSEM_MUTEX)
    10811144    {
    10821145        printf("fakeKSEMInit:                   Invalid fulType parameter (%d).\n", fulType);
     1146        KLOGEXITVOID();
    10831147        return; /*ERROR_INVALID_PARAMETER;*/
    10841148    }
    … …  
    10921156
    10931157    printf("fakeKSEMInit:                   pksem=%p, fulType=%d, fulFlags=0x%x.\n", pksem, fulType, fulFlags);
     1158    KLOGEXITVOID();
     1159}
     1160
     1161
     1162ULONG KRNLCALL  fakeKSEMRequestExclusive(HKSEMSHR hkshr, ULONG ulTimeout)
     1163{
     1164    KLOGENTRY2("ULONG","HKSEMSHR hkshr, ULONG ulTimeout", hkshr, ulTimeout);
     1165    KNOREF(hkshr);
     1166    KNOREF(ulTimeout);
     1167    KLOGEXIT(-1);
     1168    return -1;
     1169}
     1170
     1171
     1172ULONG KRNLCALL  fakeKSEMRequestShared(HKSEMSHR hkshr, ULONG ulTimeout)
     1173{
     1174    KLOGENTRY2("ULONG","HKSEMSHR hkshr, ULONG ulTimeout", hkshr, ulTimeout);
     1175    DUMMY();
     1176    KNOREF(hkshr);
     1177    KNOREF(ulTimeout);
     1178    KLOGEXIT(-1);
     1179    return -1;
     1180}
     1181
     1182
     1183VOID  KRNLCALL  fakeKSEMRelease(HKSEM hksem)
     1184{
     1185    KLOGENTRY1("VOID","HKSEM hksem", hksem);
     1186    DUMMY();
     1187    KNOREF(hksem);
     1188    KLOGEXITVOID();
     1189}
     1190
     1191
     1192VOID  KRNLCALL  fakeKSEMQuery(HKSEM hksem, PULONG pul)
     1193{
     1194    KLOGENTRY2("VOID","HKSEM hksem, PULONG pul", hksem, pul);
     1195    DUMMY();
     1196    KNOREF(hksem);
     1197    KNOREF(pul);
     1198    KLOGEXITVOID();
     1199}
     1200
     1201
     1202VOID  KRNLCALL  fakeKSEMResetEvent(HKSEMEVT hkev)
     1203{
     1204    KLOGENTRY1("VOID","HKSEMEVT hkev", hkev);
     1205    DUMMY();
     1206    KNOREF(hkev);
     1207    KLOGEXITVOID();
     1208}
     1209
     1210
     1211VOID  KRNLCALL  fakeKSEMPostEvent(HKSEMEVT hkev)
     1212{
     1213    KLOGENTRY1("VOID KRNLCALL","HKSEMEVT hkev", hkev);
     1214    DUMMY();
     1215    KNOREF(hkev);
     1216    KLOGEXITVOID();
     1217}
     1218
     1219
     1220ULONG KRNLCALL  fakeKSEMWaitEvent(HKSEMEVT hkev, ULONG ulTimeout)
     1221{
     1222    KLOGENTRY2("ULONG","HKSEMEVT hkev, ULONG ulTimeout", hkev, ulTimeout);
     1223    DUMMY();
     1224    KNOREF(hkev);
     1225    KNOREF(ulTimeout);
     1226    KLOGEXIT(-1);
     1227    return -1;
    10941228}
    10951229
    … …  
    11031237unsigned short getSlot(void)
    11041238{
     1239    KLOGENTRY0("unsigned short");
    11051240    PPIB ppib;
    11061241    PTIB ptib;
    … …  
    11131248    if (!f32Stack) ThunkStack32To16();
    11141249
     1250    KLOGEXIT((unsigned short)ptib->tib_ordinal);
    11151251    return (unsigned short)ptib->tib_ordinal;
    11161252}
    … …  
    11291265ULONG KRNLCALL   fakeTKFuBuff(PVOID pv, PVOID pvUsr, ULONG cb, ULONG fl)
    11301266{
     1267    KLOGENTRY4("ULONG KRNLCALL","PVOID pv, PVOID pvUsr, ULONG cb, ULONG fl", pv, pvUsr, cb, fl);
    11311268    memcpy(pv, pvUsr, cb);
    11321269
    … …  
    11341271           pv, pvUsr, cb, fl, NO_ERROR);
    11351272
     1273    KLOGEXIT(NO_ERROR);
    11361274    return NO_ERROR;
    11371275}
    … …  
    11501288ULONG KRNLCALL   fakeTKSuBuff(PVOID pvUsr, PVOID pv, ULONG cb, ULONG fl)
    11511289{
     1290    KLOGENTRY4("ULONG KRNLCALL","PVOID pvUsr, PVOID pv, ULONG cb, ULONG fl", pvUsr, pv, cb, fl);
    11521291    memcpy(pvUsr, pv, cb);
    11531292
    … …  
    11551294           pvUsr, pv, cb, fl, NO_ERROR);
    11561295
     1296    KLOGEXIT(NO_ERROR);
    11571297    return NO_ERROR;
    11581298}
    … …  
    11741314ULONG KRNLCALL   fakeTKFuBufLen(PLONG pcch, PVOID pvUsr, ULONG cchMax, ULONG fl, BOOL fDblNULL)
    11751315{
     1316    KLOGENTRY5("ULONG KRNLCALL","PLONG pcch, PVOID pvUsr, ULONG cchMax, ULONG fl, BOOL fDblNULL", pcch, pvUsr, cchMax, fl, fDblNULL);
    11761317    ULONG   rc;
    11771318    PSZ     psz = pvUsr;
    … …  
    11971338           pcch, *pcch, pvUsr, cchMax, fl, fDblNULL, NO_ERROR);
    11981339
     1340    KLOGEXIT(rc);
    11991341    return rc;
    12001342}
    … …  
    12131355ULONG KRNLCALL   fakeTKSuFuBuff(PVOID pvTarget, PVOID pvSource, ULONG cb, ULONG fl)
    12141356{
     1357    KLOGENTRY4("ULONG KRNLCALL","PVOID pvTarget, PVOID pvSource, ULONG cb, ULONG fl", pvTarget, pvSource, cb, fl);
    12151358    memcpy(pvTarget, pvSource, cb);
    12161359
    … …  
    12181361           pvTarget, pvSource, cb, fl, NO_ERROR);
    12191362
     1363    KLOGEXIT(NO_ERROR);
    12201364    return NO_ERROR;
    12211365}
    … …  
    12331377PMTE LDRCALL fakeldrValidateMteHandle(HMTE hMTE)
    12341378{
     1379    KLOGENTRY1("PMTE LDRCALL","HMTE hMTE", hMTE);
    12351380    DUMMY();
    12361381
    … …  
    12381383           hMTE, NULL);
    12391384
     1385    KLOGEXIT(NULL);
    12401386    return NULL;
    12411387}
    … …  
    12561402ULONG _Optlink tkExecPgmWorker(ULONG execFlag, PSZ pArg, PSZ pEnv, PSZ pszFilename)
    12571403{
     1404    KLOGENTRY4("ULONG","ULONG execFlag, PSZ pArg, PSZ pEnv, PSZ pszFilename", execFlag, pArg, pEnv, pszFilename);
    12581405    APIRET      rc;
    12591406    ldrrei_t    rei;
    … …  
    12671414    if (rc != NO_ERROR)
    12681415    {
     1416        KLOGEXIT(rc);
    12691417        return rc;
    12701418    }
    … …  
    12791427    KNOREF(execFlag);
    12801428
     1429    KLOGEXIT(rc);
    12811430    return rc;
    12821431}
    … …  
    12971446ULONG LDRCALL fakeLDRLoadExe(PSZ pszFilename, ldrrei_t *pEI)
    12981447{
     1448    KLOGENTRY2("ULONG LDRCALL","PSZ pszFilename, ldrrei_t * pEI", pszFilename, pEI);
    12991449    APIRET  rc;
    13001450    int     cchFilename = strlen(pszFilename);
    … …  
    13081458           pszFilename, pEI, rc);
    13091459
     1460    KLOGEXIT(rc);
    13101461    return rc;
    13111462}
    … …  
    13391490ULONG LDRCALL fakeldrGetModule(PSZ pszFilename, ULONG ul)
    13401491{
     1492    KLOGENTRY2("ULONG LDRCALL","PSZ pszFilename, ULONG ul", pszFilename, ul);
    13411493    APIRET  rc;
    13421494    PMTE    pmte = NULL;
    … …  
    13541506           pszFilename, ul, rc);
    13551507
     1508    KLOGEXIT(rc);
    13561509    return rc;
    13571510}
    … …  
    14481601ULONG LDRCALL   fakeldrGetMte(PCHAR pachFilename, USHORT cchFilename, UCHAR fchType, UCHAR fchClass, PPMTE ppmte)
    14491602{
     1603    KLOGENTRY5("ULONG LDRCALL","PCHAR pachFilename, USHORT cchFilename, UCHAR fchType, UCHAR fchClass, PPMTE ppmte", pachFilename, cchFilename, fchType, fchClass, ppmte);
    14501604    ldrlv_t         lv;
    14511605    APIRET          rc;
    … …  
    14761630        printf("fakeldrGetMte:          *exit*  pachFilename = %.*s, ppmte = %p; *ppmte = %p, rc = %d\n",
    14771631               cchFilename, pachFilename, ppmte, *ppmte, rc);
     1632        KLOGEXIT(rc);
    14781633        return rc;
    14791634    }
    … …  
    14951650           cchFilename, pachFilename, ppmte, *ppmte, rc);
    14961651
     1652    KLOGEXIT(rc);
    14971653    return rc;
    14981654}
    … …  
    15741730ULONG LDRCALL   fakeldrOpenNewExe(PCHAR pachFilename, USHORT cchFilename, ldrlv_t *plv, PUSHORT pus)
    15751731{
     1732    KLOGENTRY4("ULONG LDRCALL","PCHAR pachFilename, USHORT cchFilename, ldrlv_t * plv, PUSHORT pus", pachFilename, cchFilename, plv, pus);
    15761733    APIRET  rc;
    15771734    ULONG   ful;
    … …  
    15861743        printf("fakeldrOpenNewExe:      *exit*  pachFilename = %.*s, plv->lv_sfn = %#4x, rc = %d\n",
    15871744               cchFilename, pachFilename, plv->lv_sfn, rc);
     1745        KLOGEXIT(rc);
    15881746        return rc;
    15891747    }
    … …  
    15971755        printf("fakeldrOpenNewExe:      *exit*  pachFilename = %.*s, plv->lv_sfn = %#4x, rc = %d\n",
    15981756               cchFilename, pachFilename, plv->lv_sfn, rc);
     1757        KLOGEXIT(rc);
    15991758        return rc;
    16001759    }
    … …  
    16121771        printf("fakeldrOpenNewExe:      *exit*  pachFilename = %.*s, plv->lv_sfn = %#4x, rc = %d\n",
    16131772               cchFilename, pachFilename, plv->lv_sfn, rc);
     1773        KLOGEXIT(rc);
    16141774        return rc;
    16151775    }
    … …  
    16211781        printf("fakeldrOpenNewExe:      *exit*  pachFilename = %.*s, plv->lv_sfn = %#4x, rc = %d\n",
    16221782               cchFilename, pachFilename, plv->lv_sfn, rc);
     1783        KLOGEXIT(rc);
    16231784        return rc;
    16241785    }
    … …  
    16271788           cchFilename, pachFilename, plv->lv_sfn, rc);
    16281789
     1790    KLOGEXIT(NO_ERROR);
    16291791    return NO_ERROR;
    16301792}
    … …  
    16591821ULONG LDRCALL   fakeldrCreateMte(struct e32_exe *pe32, ldrlv_t *plv)
    16601822{
     1823    KLOGENTRY2("ULONG LDRCALL","struct e32_exe * pe32, ldrlv_t * plv", pe32, plv);
    16611824    ULONG   rc;
    16621825    PMTE    pMte;
    … …  
    18031966           pe32, plv, rc);
    18041967
     1968    KLOGEXIT(rc);
    18051969    return rc;
    18061970}
    … …  
    18432007ULONG LDRCALL   fakeldrLoadImports(PMTE pmte)
    18442008{
     2009    KLOGENTRY1("ULONG LDRCALL","PMTE pmte", pmte);
    18452010    int     i;                          /* Module index. */
    18462011    PSZ     psz;                        /* Module name pointer. (really pointer to pascal strings...) */
    … …  
    18572022    {
    18582023        kprintf(("fakeldrLoadImports: !ASSERTION! pmte == NULL\n"));
     2024        KLOGEXIT(ERROR_INVALID_PARAMETER);
    18592025        return ERROR_INVALID_PARAMETER;
    18602026    }
    … …  
    18622028    {
    18632029        kprintf(("fakeldrLoadImports: !ASSERTION! pmte->mte_swapmte == NULL\n"));
     2030        KLOGEXIT(ERROR_INVALID_PARAMETER);
    18642031        return ERROR_INVALID_PARAMETER;
    18652032    }
    … …  
    18722039        printf("fakeldrLoadImport:      *exit*  pmte = %p, rc = %d\n",
    18732040               pmte, rc);
     2041        KLOGEXIT(NO_ERROR);
    18742042        return NO_ERROR;
    18752043    }
    … …  
    18942062           pmte, rc);
    18952063
     2064    KLOGEXIT(rc);
    18962065    return rc;
    18972066}
    … …  
    19082077ULONG LDRCALL   fakeldrCheckInternalName(PMTE pMTE)
    19092078{
     2079    KLOGENTRY1("ULONG LDRCALL","PMTE pMTE", pMTE);
    19102080    PCHAR   pachName;                   /* Pointer to the name part of pachFilename. */
    19112081    int     cchName;                    /* Length of the name part of pachFilename.
    … …  
    19182088    /* Return successfully if not library module. */
    19192089    if (!(pMTE->mte_flags1 & LIBRARYMOD))
     2090    {
     2091        KLOGEXIT(NO_ERROR);
    19202092        return NO_ERROR;
     2093    }
    19212094
    19222095    /* Uppercase and parse filename in ldrpFileNameBuf */
    … …  
    19262099
    19272100    /* Compare the internal name with the filename and return accordingly. */
     2101    KLOGEXIT((    cchName <= 8
     2102            &&  !memcmp(pMTE->mte_modname, pachName, cchName)
     2103            &&  (cchName == 8 || pMTE->mte_modname[cchName] == '\0')
     2104            )
     2105            ? NO_ERROR
     2106            : ERROR_INVALID_NAME);
    19282107    return (    cchName <= 8
    19292108            &&  !memcmp(pMTE->mte_modname, pachName, cchName)
    … …  
    19432122ULONG LDRCALL   fakeldrTransPath(PSZ pszFilename)
    19442123{
     2124    KLOGENTRY1("ULONG LDRCALL","PSZ pszFilename", pszFilename);
     2125    KLOGEXIT(fakeIOSftTransPath(pszFilename));
    19452126    return  fakeIOSftTransPath(pszFilename);
    19462127}
    … …  
    19562137ULONG LDRCALL   fakeldrGetFileName(PSZ pszFilename, PCHAR *ppchName, PCHAR *ppchExt)
    19572138{
     2139    KLOGENTRY3("ULONG LDRCALL","PSZ pszFilename, PCHAR * ppchName, PCHAR * ppchExt", pszFilename, ppchName, ppchExt);
    19582140    int     cchName;
    19592141    PSZ     pchName;
    … …  
    19732155    *ppchName = pchName;
    19742156
     2157    KLOGEXIT(cchName);
    19752158    return cchName;
    19762159}
    … …  
    19882171VOID LDRCALL    fakeldrUCaseString(PCHAR pachString, unsigned cchString)
    19892172{
     2173    KLOGENTRY2("VOID LDRCALL","PCHAR pachString, unsigned cchString", pachString, cchString);
    19902174    printf("fakeldrUCaseString:             pachString = %.*s, cchString = %#8x\n",
    19912175           cchString, pachString, cchString);
    … …  
    19972181        pachString++;
    19982182    }
     2183    KLOGEXITVOID();
    19992184}
    20002185
    … …  
    20222207ULONG LDRCALL   fakeldrMTEValidatePtrs(PSMTE psmte, ULONG ulMaxAddr, ULONG off)
    20232208{
     2209    KLOGENTRY3("ULONG LDRCALL","PSMTE psmte, ULONG ulMaxAddr, ULONG off", psmte, ulMaxAddr, off);
    20242210    int     i;
    20252211
    … …  
    20372223                printf("fakeldrMTEValidatePtrs: *exit*  psmte = %p, ulMaxAddr = %p, off = %p, rc = %d\n",
    20382224                       psmte, ulMaxAddr, off, ERROR_BAD_EXE_FORMAT);
     2225                KLOGEXIT(ERROR_BAD_EXE_FORMAT);
    20392226                return ERROR_BAD_EXE_FORMAT;
    20402227            }
    … …  
    20442231    printf("fakeldrMTEValidatePtrs: *exit*  psmte = %p, ulMaxAddr = %p, off = %p, rc = %d\n",
    20452232           psmte, ulMaxAddr, off, NO_ERROR);
     2233    KLOGEXIT(NO_ERROR);
    20462234    return NO_ERROR;
    20472235}
    … …  
    20502238PMTE KRNLCALL fakeldrASMpMTEFromHandle(HMTE  hMTE)
    20512239{
     2240    KLOGENTRY1("PMTE KRNLCALL","HMTE hMTE", hMTE);
    20522241    PMTE pMte = (PMTE)hMTE;
    20532242
    20542243    pMte += 10; //just do something!
    20552244
     2245    KLOGEXIT(NULL);
    20562246    return NULL;
    20572247}
    … …  
    20592249ULONG LDRCALL   fakeldrFindModule(PCHAR pachFilename, USHORT cchFilename, USHORT usClass, PPMTE ppMTE)
    20602250{
     2251    KLOGENTRY4("ULONG LDRCALL","PCHAR pachFilename, USHORT cchFilename, USHORT usClass, PPMTE ppMTE", pachFilename, cchFilename, usClass, ppMTE);
    20612252    APIRET rc = NO_ERROR;
    20622253    usClass = usClass;
    … …  
    20642255    pachFilename = pachFilename;
    20652256    *ppMTE = NULL;
     2257    KLOGEXIT(rc);
    20662258    return rc;
    20672259}
    … …  
    20752267PSZ SECCALL fakeSecPathFromSFN(SFN hFile)
    20762268{
     2269    KLOGENTRY1("PSZ SECCALL","SFN hFile", hFile);
    20772270    BOOL    f32Stack = ((int)&hFile > 0x10000);
    20782271
    … …  
    20842277    printf("fakeSecPathFromSFN:                    - not implemented - hFile = 0x%04x\n", hFile);
    20852278
     2279    KLOGEXIT(NULL);
    20862280    return NULL;
    20872281}
    … …  
    20962290ULONG KRNLCALL  fakeTKPidToPTDA(PID pid, PPPTDA ppPTDA)
    20972291{
     2292    KLOGENTRY2("ULONG KRNLCALL","PID pid, PPPTDA ppPTDA", pid, ppPTDA);
    20982293    DUMMY();
    20992294    printf("fakeTKPidToPTDA:                       - not implemented - pid = 0x%04x, ppPTDA=%p\n", pid, ppPTDA);
     2295    KLOGEXIT(ERROR_NOT_SUPPORTED);
    21002296    return ERROR_NOT_SUPPORTED;
    21012297}
    … …  
    21102306ULONG KRNLCALL   fakeTKScanTasks(ULONG flFlags, ULONG id, PTKSCANTASKWORKER pfnWorker, ULONG ulArg)
    21112307{
     2308    KLOGENTRY4("ULONG KRNLCALL","ULONG flFlags, ULONG id, PTKSCANTASKWORKER pfnWorker, ULONG ulArg", flFlags, id, pfnWorker, ulArg);
    21122309    DUMMY();
    21132310    printf("fakeTKScanTasks:                       - not implemented\n");
     2311    KLOGEXIT(ERROR_NOT_SUPPORTED);
    21142312    return ERROR_NOT_SUPPORTED;
    21152313}
    … …  
    21222320void KRNLCALL fakeTKForceThread(ULONG flFlag, PTCB pTCB)
    21232321{
     2322    KLOGENTRY2("void KRNLCALL","ULONG flFlag, PTCB pTCB", flFlag, pTCB);
    21242323    DUMMY();
    21252324    printf("fakeTKForceThread:                     - not implemented\n");
     2325    KLOGEXITVOID();
    21262326}
    21272327
    … …  
    21352335void KRNLCALL  fakeTKForceTask(ULONG flFlag, PPTDA pPTDA, BOOL fForce)
    21362336{
     2337    KLOGENTRY3("void KRNLCALL","ULONG flFlag, PPTDA pPTDA, BOOL fForce", flFlag, pPTDA, fForce);
    21372338    DUMMY();
    21382339    printf("fakeTKForceTask:                       - not implemented\n");
     2340    KLOGEXITVOID();
    21392341}
    21402342
    … …  
    21462348ULONG KRNLCALL fakeTKGetPriority(PTCB pTCB)
    21472349{
     2350    KLOGENTRY1("ULONG KRNLCALL","PTCB pTCB", pTCB);
    21482351    DUMMY();
    21492352    printf("fakeTKGetPriority:                     - not implemented\n");
     2353    KLOGEXIT(-1);
    21502354    return -1;
    21512355}
    … …  
    21652369ULONG KRNLCALL fakeTKSleep(ULONG ulSleepId, ULONG ulTimeout, ULONG fUnInterruptable, ULONG flWakeupType)
    21662370{
     2371    KLOGENTRY4("ULONG KRNLCALL","ULONG ulSleepId, ULONG ulTimeout, ULONG fUnInterruptable, ULONG flWakeupType", ulSleepId, ulTimeout, fUnInterruptable, flWakeupType);
    21672372    DUMMY();
    21682373    printf("fakeTKSleep:                           - not implemented\n");
     2374    KLOGEXIT(ERROR_NOT_SUPPORTED);
    21692375    return ERROR_NOT_SUPPORTED;
    21702376}
    … …  
    21812387ULONG KRNLCALL fakeTKWakeup(ULONG ulSleepId, ULONG flWakeupType, PULONG cWakedUp)
    21822388{
     2389    KLOGENTRY3("ULONG KRNLCALL","ULONG ulSleepId, ULONG flWakeupType, PULONG cWakedUp", ulSleepId, flWakeupType, cWakedUp);
    21832390    DUMMY();
    21842391    printf("fakeTKWakeup:                          - not implemented\n");
     2392    KLOGEXIT(ERROR_NOT_SUPPORTED);
    21852393    return ERROR_NOT_SUPPORTED;
    21862394}
    … …  
    21952403ULONG KRNLCALL fakeTKWakeThread(PTCB pTCB)
    21962404{
     2405    KLOGENTRY1("ULONG KRNLCALL","PTCB pTCB", pTCB);
    21972406    DUMMY();
    21982407    printf("fakeTKWakeThread:                      - not implemented\n");
     2408    KLOGEXIT(ERROR_NOT_SUPPORTED);
    21992409    return ERROR_NOT_SUPPORTED;
    22002410}
    … …  
    22092419PTCB  KRNLCALL fakeTKQueryWakeup(ULONG ulSleepId, ULONG flWakeupType)
    22102420{
     2421    KLOGENTRY2("PTCB KRNLCALL","ULONG ulSleepId, ULONG flWakeupType", ulSleepId, flWakeupType);
    22112422    DUMMY();
    22122423    printf("fakeTKQueryWakeup:                     - not implemented\n");
     2424    KLOGEXIT(NULL);
    22132425    return NULL;
    22142426}
    … …  
    22192431ULONG KRNLCALL fakePGPhysAvail(void)
    22202432{
     2433    KLOGENTRY0("ULONG KRNLCALL");
    22212434    DUMMY();
    22222435    printf("fakePGPhysAvail                        - returns 0x234563\n");
     2436    KLOGEXIT(0x234563);
    22232437    return 0x234563;
    22242438}
    … …  
    22302444ULONG KRNLCALL fakePGPhysPresent(void)
    22312445{
     2446    KLOGENTRY0("ULONG KRNLCALL");
    22322447    DUMMY();
    22332448    printf("fakePGPhysPresent                      - returns 0x123534\n");
     2449    KLOGEXIT(0x123534);
    22342450    return 0x123534;
    22352451}
    … …  
    22512467    PULONG  pulSentinelAddress)
    22522468{
     2469    KLOGENTRY2("VOID KRNLCALL","ULONG flFlags, PULONG pulSentinelAddress", flFlags, pulSentinelAddress);
    22532470    ULONG ulRet;
    22542471    DUMMY();
    … …  
    22712488           ulRet, flFlags, pulSentinelAddress);
    22722489
    2273     return;
     2490    KLOGEXITVOID();
    22742491}
    22752492
    … …  
    22862503ULONG LDRCALL   fakeldrGetOrdNum(PMTE pMTE, PSZ pszExportName, PUSHORT pusOrdinal)
    22872504{
     2505    KLOGENTRY3("ULONG LDRCALL","PMTE pMTE, PSZ pszExportName, PUSHORT pusOrdinal", pMTE, pszExportName, pusOrdinal);
    22882506    DUMMY();
    22892507    printf("fakeldrGetOrdNum:                      - not implemented\n");
     2508    KLOGEXIT(ERROR_NOT_SUPPORTED);
    22902509    return ERROR_NOT_SUPPORTED;
    22912510}
    … …  
    23052524ULONG LDRCALL   fakeldrWasLoadModuled(HMTE hmte, PPTDA pptda, PULONG pcUsage)
    23062525{
     2526    KLOGENTRY3("ULONG LDRCALL","HMTE hmte, PPTDA pptda, PULONG pcUsage", hmte, pptda, pcUsage);
    23072527    DUMMY();
    23082528    printf("fakeldrWasLoadModuled:                 - not implemented\n");
     2529    KLOGEXIT(ERROR_NOT_SUPPORTED);
    23092530    return ERROR_NOT_SUPPORTED;
    23102531}
    … …  
    23282549ULONG LDRCALL fakeLDRGetProcAddr(HMTE hmte, ULONG ulOrdinal, PCSZ pszName, PULONG pulAddress, BOOL fFlat, PULONG pulProcType)
    23292550{
     2551    KLOGENTRY6("ULONG LDRCALL","HMTE hmte, ULONG ulOrdinal, PCSZ pszName, PULONG pulAddress, BOOL fFlat, PULONG pulProcType", hmte, ulOrdinal, pszName, pulAddress, fFlat, pulProcType);
    23302552    DUMMY();
    23312553    printf("fakeLDRGetProcAddr:                    - not implemented\n");
     2554    KLOGEXIT(ERROR_NOT_SUPPORTED);
    23322555    return ERROR_NOT_SUPPORTED;
    23332556}
    … …  
    23402563void KRNLCALL fakeLDRFreeTask(PPTDA pPTDA)
    23412564{
     2565    KLOGENTRY1("void KRNLCALL","PPTDA pPTDA", pPTDA);
    23422566    DUMMY();
    23432567    printf("fakeLDRFreeTask:                       - not implemented\n");
     2568    KLOGEXITVOID();
    23442569}
    23452570
    … …  
    23532578PVOID KRNLCALL   fakeSELVirtToLin(ULONG ulOffset, USHORT usSel)
    23542579{
     2580    KLOGENTRY2("PVOID KRNLCALL","ULONG ulOffset, USHORT usSel", ulOffset, usSel);
    23552581    DUMMY();
    23562582    printf("fakeSELVirtToLin:                      - not implemented\n");
     2583    KLOGEXIT((void*)-1);
    23572584    return (void*)-1;
    23582585}
    … …  
    23662593PVOID KRNLCALL   fakeSELConvertToLinear(USHORT usSel, PPTDA pPTDA)
    23672594{
     2595    KLOGENTRY2("PVOID KRNLCALL","USHORT usSel, PPTDA pPTDA", usSel, pPTDA);
    23682596    DUMMY();
    23692597    printf("fakeSELConvertToLinear:                - not implemented\n");
     2598    KLOGEXIT((void*)-1);
    23702599    return (void*)-1;
    23712600}
    … …  
    23802609USHORT KRNLCALL  fakeSELConvertToSelector(PVOID pv, ULONG ulRPL, HPTDA hPTDA)
    23812610{
     2611    KLOGENTRY3("USHORT KRNLCALL","PVOID pv, ULONG ulRPL, HPTDA hPTDA", pv, ulRPL, hPTDA);
    23822612    DUMMY();
    23832613    printf("fakeSELConvertToSelector:              - not implemented\n");
     2614    KLOGEXIT(ERROR_NOT_SUPPORTED);
    23842615    return ERROR_NOT_SUPPORTED;
    23852616}
    … …  
    23922623ULONG  KRNLCALL  fakeSELAllocGDT(PUSHORT pusSel)
    23932624{
     2625    KLOGENTRY1("ULONG KRNLCALL","PUSHORT pusSel", pusSel);
    23942626    DUMMY();
    23952627    printf("fakeSELAllocGDT:                       - not implemented\n");
     2628    KLOGEXIT(ERROR_NOT_SUPPORTED);
    23962629    return ERROR_NOT_SUPPORTED;
    23972630}
Note: See TracChangeset for help on using the changeset viewer.