Changeset 296


Ignore:
Timestamp:
Jul 23, 2017, 4:22:52 AM (3 years ago)
Author:
Valery V. Sedletski
Message:

fat32.ifs: Add system trace support.

Location:
trunk/src
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ifs/fat32a.c

    r295 r296  
    9797                         unsigned short far * pLen) /* pLen     */
    9898{
    99    if (f32Parms.fMessageActive & LOG_FS)
    100       Message("FS_ATTACH - NOT SUPPORTED");
     99   MessageL(LOG_FS, "FS_ATTACH%m - NOT SUPPORTED", 0x0023);
    101100   usFlag = usFlag;
    102101   pDev = pDev;
     
    150149   _asm push es;
    151150
    152    if (f32Parms.fMessageActive & LOG_FS)
    153       Message("FS_COPY %s to %s, mode %d", pSrc, pDst, usMode);
     151   MessageL(LOG_FS, "FS_COPY%m %s to %s, mode %d", 0x0025, pSrc, pDst, usMode);
    154152
    155153   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    576574#endif
    577575
    578    if (f32Parms.fMessageActive & LOG_FS)
    579       Message("FS_COPY returned %u", rc);
     576   MessageL(LOG_FS, "FS_COPY%m returned %u", 0x8025, rc);
    580577
    581578   _asm pop es;
     
    612609   _asm push es;
    613610
    614    if (f32Parms.fMessageActive & LOG_FS)
    615     Message("FS_DELETE for %s", pFile);
     611   MessageL(LOG_FS, "FS_DELETE%m for %s", 0x0026, pFile);
    616612
    617613   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    808804#endif
    809805
    810    if (f32Parms.fMessageActive & LOG_FS)
    811       Message("FS_DELETE returned %u", rc);
     806   MessageL(LOG_FS, "FS_DELETE%m returned %u", 0x8026, rc);
    812807
    813808   _asm pop es;
     
    831826   _asm push es;
    832827
    833    if (f32Parms.fMessageActive & LOG_FS)
    834       Message("FS_EXIT for PID: %X, PDB %X",
    835          usPid, usPdb);
     828   MessageL(LOG_FS, "FS_EXIT%m for PID: %X, PDB %X",
     829            0x0027, usPid, usPdb);
    836830
    837831   while (pVolInfo)
     
    853847      while (pFindInfo)
    854848         {
    855          if (f32Parms.fMessageActive & LOG_FUNCS)
    856             Message("Still findinfo's allocated");
     849         MessageL(LOG_FUNCS, "Still findinfo's allocated%m", 0x400e);
    857850         rc = MY_PROBEBUF(PB_OPWRITE, (PBYTE)pFindInfo, sizeof (FINFO));
    858851         if (rc)
     
    867860             pFindInfo->ProcInfo.usPdb == usPdb)
    868861            {
    869             if (f32Parms.fMessageActive & LOG_FUNCS)
    870                Message("Removing a FINDINFO");
     862            MessageL(LOG_FUNCS, "Removing a FINDINFO%m", 0x400f);
    871863            if (RemoveFindEntry(pVolInfo, pFindInfo))
    872864               free(pFindInfo);
     
    914906      }
    915907
    916    if (f32Parms.fMessageActive & LOG_FS)
    917       Message("FS_FLUSHBUF, flag = %d", usFlag);
     908   MessageL(LOG_FS, "FS_FLUSHBUF%m, flag = %d", 0x0028, usFlag);
    918909
    919910   if (pVolInfo->fWriteProtected)
     
    941932FS_FLUSHEXIT:
    942933
    943    if (f32Parms.fMessageActive & LOG_FS)
    944       Message("FS_FLUSHBUF returned %u", rc);
     934   MessageL(LOG_FS, "FS_FLUSHBUF%m returned %u", 0x8028, rc);
    945935
    946936   _asm pop es;
     
    970960   _asm push es;
    971961
    972    if (usFunc != FAT32_GETLOGDATA && f32Parms.fMessageActive & LOG_FS)
    973       Message("FS_FSCTL, Func = %Xh", usFunc);
     962   if (usFunc != FAT32_GETLOGDATA)
     963      MessageL(LOG_FS, "FS_FSCTL%m, Func = %x", 0x0029, usFunc);
    974964
    975965   rc = 0;
     
    13291319FS_FSCTLEXIT:
    13301320
    1331    if (usFunc != FAT32_GETLOGDATA && f32Parms.fMessageActive & LOG_FS)
    1332       Message("FS_FSCTL returned %u", rc);
     1321   if (usFunc != FAT32_GETLOGDATA)
     1322      MessageL(LOG_FS, "FS_FSCTL%m returned %u", 0x8029, rc);
    13331323
    13341324   _asm pop es;
     
    13531343   _asm push es;
    13541344
    1355    if (f32Parms.fMessageActive & LOG_FS)
    1356       Message("FS_FSINFO, Flag = %d, Level = %d", usFlag, usLevel);
     1345   MessageL(LOG_FS, "FS_FSINFO, Flag = %d, Level = %d", 0x002a, usFlag, usLevel);
    13571346
    13581347   pVolInfo = GetVolInfo(hVBP);
     
    14211410               pAlloc->cUnitAvail = min(65526L, ulFreeSectors / pAlloc->cSectorUnit);
    14221411
    1423                if (f32Parms.fMessageActive & LOG_FUNCS)
    1424                   Message("DOS Free space: sc: %lu tc: %lu fc: %lu",
    1425                      pAlloc->cSectorUnit, pAlloc->cUnit, pAlloc->cUnitAvail);
     1412               MessageL(LOG_FUNCS, "DOS Free space%m: sc: %lu tc: %lu fc: %lu",
     1413                        0x4010, pAlloc->cSectorUnit, pAlloc->cUnit, pAlloc->cUnitAvail);
    14261414               }
    14271415            else
     
    15081496FS_FSINFOEXIT:
    15091497
    1510    if (f32Parms.fMessageActive & LOG_FS)
    1511       Message("FS_FSINFO returned %u", rc);
     1498   MessageL(LOG_FS, "FS_FSINFO%m returned %u", 0x802a, rc);
    15121499
    15131500   _asm pop es;
     
    22952282   psffsd = psffsd;
    22962283
    2297    if (f32Parms.fMessageActive & LOG_FS)
    2298       Message("FS_IOCTL, Cat %Xh, Func %Xh, File# %u",
    2299          usCat, usFunc, psffsi->sfi_selfsfn);
     2284   MessageL(LOG_FS, "FS_IOCTL%m, Cat %Xh, Func %Xh, File# %u",
     2285            0x002b, usCat, usFunc, psffsi->sfi_selfsfn);
    23002286
    23012287   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    28282814
    28292815FS_IOCTLEXIT:
    2830    if (f32Parms.fMessageActive & LOG_FS)
    2831       Message("FS_IOCTL returned %u", rc);
     2816   MessageL(LOG_FS, "FS_IOCTL%m returned %u", 0x802b, rc);
    28322817
    28332818   _asm pop es;
     
    28442829PSZ   pszFile;
    28452830
    2846    if (f32Parms.fMessageActive & LOG_FUNCS)
    2847       Message("GetSetFileEAS");
     2831   MessageL(LOG_FUNCS, "GetSetFileEAS%m", 0x036);
    28482832
    28492833#ifdef EXFAT
     
    32663250   _asm push es;
    32673251
    3268    if (f32Parms.fMessageActive & LOG_FS)
    3269       Message("FS_MOVE %s to %s", pSrc, pDst);
     3252   MessageL(LOG_FS, "FS_MOVE%m %s to %s", 0x002c, pSrc, pDst);
    32703253
    32713254   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    36983681#endif
    36993682
    3700    if (f32Parms.fMessageActive & LOG_FS)
    3701       Message("FS_MOVE returned %d", rc);
     3683   MessageL(LOG_FS, "FS_MOVE%m returned %d", 0x802c, rc);
    37023684
    37033685   _asm pop es;
     
    37223704     _asm push es;
    37233705
    3724      if (f32Parms.fMessageActive & LOG_FS)
    3725         Message("FS_PROCESSNAME for %s", pNameBuf);
     3706     MessageL(LOG_FS, "FS_PROCESSNAME%m for %s", 0x002d, pNameBuf);
    37263707
    37273708     for( p = pNameBuf; *p; p += usLen )
     
    37353716        }
    37363717     }
    3737 
    3738      if (f32Parms.fMessageActive & LOG_FS)
    3739         Message(" FS_PROCESSNAME returned filename: %s", pNameBuf);
    3740 
    3741      _asm pop es;
    3742 #endif
     3718#endif
     3719   MessageL(LOG_FS, " FS_PROCESSNAME%m returned filename: %s", 0x802d, pNameBuf);
     3720
     3721   _asm pop es;
     3722
    37433723   return 0;
    37443724}
     
    37603740   ulReserved = ulReserved;
    37613741
    3762    if (f32Parms.fMessageActive & LOG_FS)
    3763       Message("FS_SHUTDOWN, Type = %d", usType);
     3742   MessageL(LOG_FS, "FS_SHUTDOWN%m, Type = %d", 0x002e, usType);
    37643743   f32Parms.fInShutDown = TRUE;
    37653744   f32Parms.fLW = FALSE;
     
    37903769//FS_SHUTDOWNEXIT:
    37913770
    3792    if (f32Parms.fMessageActive & LOG_FS)
    3793       Message("FS_SHUTDOWN returned %d", rc);
     3771   MessageL(LOG_FS, "FS_SHUTDOWN%m returned %d", 0x802e, rc);
    37943772
    37953773   _asm pop es;
     
    38083786   _asm push es;
    38093787
    3810    if (f32Parms.fMessageActive & LOG_FS)
    3811       Message("FS_VERIFYUNCNAME - NOT SUPPORTED");
     3788   MessageL(LOG_FS, "FS_VERIFYUNCNAME%m - NOT SUPPORTED", 0x002f);
    38123789   usFlag = usFlag;
    38133790   pName = pName;
     
    38293806PVOID pRet;
    38303807
    3831    if (f32Parms.fMessageActive & LOG_FUNCS)
    3832       Message("gdtAlloc for %lu bytes", tSize);
     3808   MessageL(LOG_FUNCS, "gdtAlloc%m for %lu bytes", 0x0037, tSize);
    38333809
    38343810   if (fSwap)
     
    38593835PVOID pRet;
    38603836
    3861    if (f32Parms.fMessageActive & LOG_FUNCS)
    3862       Message("ldtAlloc for %lu bytes", tSize);
     3837   MessageL(LOG_FUNCS, "ldtAlloc for %D bytes", 0x0038, tSize);
    38633838
    38643839   rc = FSH_SEGALLOC(SA_FLDT | SA_FSWAP| SA_FRING3, tSize, &usSel);
     
    38893864PVOID pv = &ulReserved;
    38903865
    3891    if (f32Parms.fMessageActive & LOG_FUNCS)
    3892       Message("linAlloc");
     3866   MessageL(LOG_FUNCS, "linAlloc%m for %u bytes", 0x0039, tSize);
    38933867
    38943868   ulFlags = VMDHA_FIXED;
     
    39033877   if (rc)
    39043878      {
    3905       if (f32Parms.fMessageActive & LOG_FUNCS)
    3906          Message("ERROR: linalloc failed, rc = %d", rc);
     3879      MessageL(LOG_FUNCS, "ERROR: linalloc failed%m, rc = %d", 0x4015, rc);
    39073880
    39083881      if( !fIgnore )
     
    39233896PVOID pv=NULL;
    39243897
    3925     if (f32Parms.fMessageActive & LOG_FUNCS)
    3926         Message("linAlloc");
     3898    MessageL(LOG_FUNCS, "linAlloc%m for %u bytes", 0x0039, tSize);
    39273899
    39283900    rc = DevHelp_VirtToLin(     SELECTOROF(pulPhysAddr),
     
    39323904    if (rc != NO_ERROR)
    39333905    {
    3934         if (f32Parms.fMessageActive & LOG_FUNCS)
    3935             Message("ERROR: linalloc VirtToLin failed, rc = %d", rc);
     3906        MessageL(LOG_FUNCS, "ERROR: linalloc VirtToLin failed%m, rc = %d", 0x4015, rc);
    39363907
    39373908        if( !fIgnore )
     
    39533924    if (rc)
    39543925    {
    3955         if (f32Parms.fMessageActive & LOG_FUNCS)
    3956             Message("ERROR: linalloc VMAlloc failed, rc = %d", rc);
     3926        MessageL(LOG_FUNCS, "ERROR: linalloc VMAlloc failed%m, rc = %d", 0x4016, rc);
    39573927
    39583928        if( !fIgnore )
     
    39713941USHORT rc;
    39723942
    3973    if (f32Parms.fMessageActive & LOG_FUNCS)
    3974       Message("freeseg");
     3943   MessageL(LOG_FUNCS, "freeseg%m", 0x0040);
    39753944
    39763945   if (!p)
     
    40083977USHORT rc;
    40093978
    4010    if (f32Parms.fMessageActive & LOG_FUNCS)
    4011       Message("ReadBlock %lu", ulCluster);
     3979   MessageL(LOG_FUNCS, "ReadBlock%m %lu", 0x0041, ulCluster);
    40123980
    40133981   if (ulCluster < 2 || ulCluster >= pVolInfo->ulTotalClusters + 2)
     
    40504018USHORT rc;
    40514019
    4052    if (f32Parms.fMessageActive & LOG_FUNCS)
    4053       Message("WriteBlock");
     4020   MessageL(LOG_FUNCS, "WriteBlock%m, %lu", 0x0042, ulCluster);
    40544021
    40554022   if (ulCluster < 2 || ulCluster >= pVolInfo->ulTotalClusters + 2)
     
    40904057USHORT rc;
    40914058
    4092    if (f32Parms.fMessageActive & LOG_FUNCS)
    4093       Message("ReadFatSector");
     4059   MessageL(LOG_FUNCS, "ReadFatSector%m", 0x0043);
    40944060
    40954061   // read multiples of three sectors,
     
    41274093USHORT rc;
    41284094
    4129    if (f32Parms.fMessageActive & LOG_FUNCS)
    4130       Message("WriteFatSector");
     4095   MessageL(LOG_FUNCS, "WriteFatSector%m", 0x0044);
    41314096
    41324097   // write multiples of three sectors,
     
    41754140USHORT rc;
    41764141
    4177    if (f32Parms.fMessageActive & LOG_FUNCS)
    4178       Message("ReadBmpSector");
     4142   MessageL(LOG_FUNCS, "ReadBmpSector%m", 0x0045);
    41794143
    41804144   if (pVolInfo->ulCurBmpSector == ulSector)
     
    42084172USHORT rc;
    42094173
    4210    if (f32Parms.fMessageActive & LOG_FUNCS)
    4211       Message("WriteBmpSector");
     4174   MessageL(LOG_FUNCS, "WriteBmpSector%m", 0x0046);
    42124175
    42134176   if (pVolInfo->ulCurBmpSector != ulSector)
     
    44244387ULONG GetNextCluster(PVOLINFO pVolInfo, PSHOPENINFO pSHInfo, ULONG ulCluster)
    44254388{
    4426    if (f32Parms.fMessageActive & LOG_FUNCS)
    4427       Message("GetNextCluster for %lu", ulCluster);
     4389   MessageL(LOG_FUNCS, "GetNextCluster%m for %lu", 0x0047, ulCluster);
    44284390
    44294391   if (!GetFatAccess(pVolInfo, "GetNextCluster"))
     
    45274489BOOL rc;
    45284490
    4529    if (f32Parms.fMessageActive & LOG_FUNCS)
    4530       Message("ClusterInUse for %lu", ulCluster);
     4491   MessageL(LOG_FUNCS, "ClusterInUse%m for %lu", 0x0048, ulCluster);
    45314492
    45324493   //if (GetFatAccess(pVolInfo, "ClusterInUse"))
     
    45784539ULONG ulBmpSector;
    45794540
    4580    if (f32Parms.fMessageActive & LOG_FUNCS)
    4581       Message("MarkCluster for %lu", ulCluster);
     4541   MessageL(LOG_FUNCS, "MarkCluster%m for %lu", 0x0049, ulCluster);
    45824542
    45834543   if (!GetFatAccess(pVolInfo, "MarkCluster"))
     
    46024562}
    46034563
    4604 /******************************************************************
    4605 *
    4606 ******************************************************************/
    4607 /* BOOL MarkCluster(PVOLINFO pVolInfo, ULONG ulCluster, BOOL fState)
    4608 {
    4609    if (f32Parms.fMessageActive & LOG_FUNCS)
    4610       Message("MarkCluster for %lu", ulCluster);
    4611 
    4612    if (!GetFatAccess(pVolInfo, "MarkCluster"))
    4613       {
    4614       ulCluster = MarkCluster2(pVolInfo, ulCluster, fState);
    4615       ReleaseFat(pVolInfo);
    4616       return TRUE;
    4617       }
    4618 
    4619    return FALSE;
    4620 } */
    4621 
    46224564#endif
    46234565
     
    46324574ULONG ulTotalFree;
    46334575
    4634    if (f32Parms.fMessageActive & LOG_FUNCS)
    4635       Message("GetFreeSpace");
     4576   MessageL(LOG_FUNCS, "GetFreeSpace%m", 0x004a);
    46364577
    46374578   //if (GetFatAccess(pVolInfo, "GetFreeSpace"))
     
    46704611   return ulTotalFree;
    46714612}
    4672 
    4673 /******************************************************************
    4674 *
    4675 ******************************************************************/
    4676 /* ULONG GetFreeSpace(PVOLINFO pVolInfo)
    4677 {
    4678 ULONG rc;
    4679 
    4680    if (f32Parms.fMessageActive & LOG_FUNCS)
    4681       Message("GetFreeSpace");
    4682 
    4683    if (!GetFatAccess(pVolInfo, "GetFreeSpace"))
    4684       {
    4685       rc = GetFreeSpace2(pVolInfo);
    4686       ReleaseFat(pVolInfo);
    4687       }
    4688 
    4689    return rc;
    4690 } */
    46914613
    46924614/******************************************************************
     
    47114633BOOL   fClean;
    47124634
    4713    if (f32Parms.fMessageActive & LOG_FUNCS)
    4714       Message("MakeFatChain, %lu clusters", ulClustersRequested);
     4635   MessageL(LOG_FUNCS, "MakeFatChain%m, %lu clusters", 0x004b, ulClustersRequested);
    47154636
    47164637   if (!ulClustersRequested)
     
    48084729            if (fStartAt2)
    48094730               break;
    4810             if (f32Parms.fMessageActive & LOG_FUNCS)
    4811                Message("No contiguous block found, restarting at cluster 2");
     4731            MessageL(LOG_FUNCS, "No contiguous block found, restarting at cluster 2%m", 0x4023);
    48124732            ulFirstCluster = 2;
    48134733            fStartAt2 = TRUE;
     
    48984818            }
    48994819
    4900          if (f32Parms.fMessageActive & LOG_FUNCS)
    4901             {
    4902             if (fContiguous)
    4903                Message("Contiguous chain returned, first = %lu", ulReturn);
    4904             else
    4905                Message("NON Contiguous chain returned, first = %lu", ulReturn);
    4906             }
     4820         if (fContiguous)
     4821            MessageL(LOG_FUNCS, "Contiguous chain returned, first%m = %lu", 0x4024, ulReturn);
     4822         else
     4823            MessageL(LOG_FUNCS, "NON Contiguous chain returned, first%m = %lu", 0x4025, ulReturn);
    49074824         if (pulLast)
    49084825            *pulLast = ulFirstCluster + ulClustersRequested - 1;
     
    49134830         We get here only if no free chain long enough was found!
    49144831      */
    4915       if (f32Parms.fMessageActive & LOG_FUNCS)
    4916          Message("No contiguous block found, largest found is %lu clusters", ulLargestSize);
     4832      MessageL(LOG_FUNCS, "No contiguous block found, largest found is%m %lu clusters", 0x4026, ulLargestSize);
    49174833      fContiguous = FALSE;
    49184834
     
    49644880USHORT rc;
    49654881
    4966    if (f32Parms.fMessageActive & LOG_FUNCS)
    4967       Message("MakeChain");
     4882   MessageL(LOG_FUNCS, "MakeChain%m", 0x004c);
    49684883
    49694884   ulLastCluster = ulFirstCluster + ulSize - 1;
     
    51205035PBYTE bSector;
    51215036
    5122    if (f32Parms.fMessageActive & LOG_FUNCS)
    5123       Message("UpdateFSInfo");
     5037   MessageL(LOG_FUNCS, "UpdateFSInfo%m", 0x004d);
    51245038
    51255039   if (pVolInfo->fFormatInProgress)
     
    51655079PBYTE pbSector;
    51665080
    5167    if (f32Parms.fMessageActive & LOG_FUNCS)
    5168       Message("MarkDiskStatus, %d", fClean);
     5081   MessageL(LOG_FUNCS, "MarkDiskStatus%m, %d", 0x004e, fClean);
    51695082
    51705083   if (!pVolInfo->fDiskCleanOnMount && fClean)
     
    53045217*
    53055218******************************************************************/
    5306 /* ULONG SetNextCluster(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
    5307 {
    5308    if (f32Parms.fMessageActive & LOG_FUNCS)
    5309       Message("SetNextCluster");
    5310 
    5311 
    5312    if (GetFatAccess(pVolInfo, "SetNextCluster"))
    5313       return pVolInfo->ulFatEof;
    5314 
    5315    ulCluster = SetNextCluster2(pVolInfo, ulCluster, ulNext);
    5316    ReleaseFat(pVolInfo);
    5317    return ulCluster;
    5318 } */
    5319 
    5320 /******************************************************************
    5321 *
    5322 ******************************************************************/
    53235219ULONG SetNextCluster(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
    53245220{
     
    53285224USHORT rc;
    53295225
    5330    if (f32Parms.fMessageActive & LOG_FUNCS)
    5331       Message("SetNextCluster");
    5332 
     5226   MessageL(LOG_FUNCS, "SetNextCluster%m", 0x004f);
    53335227
    53345228   ulReturn = ulNext;
     
    54415335BOOL fStartAt2;
    54425336
    5443    if (f32Parms.fMessageActive & LOG_FUNCS)
    5444       Message("GetFreeCluster");
     5337   MessageL(LOG_FUNCS, "GetFreeCluster%m", 0x0050);
    54455338
    54465339   if (pVolInfo->pBootFSInfo->ulFreeClusters == 0L)
     
    55585451USHORT rc;
    55595452
    5560    if (f32Parms.fMessageActive & LOG_FUNCS)
    5561       Message("RemoveFindEntry");
     5453   MessageL(LOG_FUNCS, "RemoveFindEntry%m", 0x0051);
    55625454
    55635455   if (pVolInfo->pFindInfo == pFindInfo)
     
    57685660            pszBuffer[1] = 0;
    57695661            break;
     5662         case 'm':
     5663            // minor ID of system trace, just skip it
     5664            usValue = va_arg(va, USHORT);
     5665            break;
    57705666         default :
    57715667            strncpy(pszBuffer, pszFormat, p - pszFormat);
     
    59965892                    PDIRENTRY pNew, PDIRENTRY1 pNewStream, PSZ pszName)
    59975893{
    5998    if (f32Parms.fMessageActive & LOG_FUNCS)
    5999       Message("MakeDirEntry %s", pszName);
     5894   MessageL(LOG_FUNCS, "MakeDirEntry%m %s", 0x0052, pszName);
    60005895
    60015896   if (pGI)
     
    60595954USHORT rc;
    60605955
    6061    if (f32Parms.fMessageActive & LOG_FUNCS)
    6062       Message("MakeShortName for %s, dircluster %lu",
    6063          pszLongName, ulDirCluster);
     5956   MessageL(LOG_FUNCS, "MakeShortName%m for %s, dircluster %lu",
     5957            0x0053, pszLongName, ulDirCluster);
    60645958
    60655959   usLongName = LONGNAME_OFF;
     
    63076201   if (ulCluster >= 2 && ulCluster < pVolInfo->ulTotalClusters + 2)
    63086202      {
    6309       if (f32Parms.fMessageActive  & LOG_FUNCS)
    6310          Message("DeleteFatChain for cluster %lu", ulCluster);
     6203      MessageL(LOG_FUNCS, "DeleteFatChain%m for cluster %lu", 0x0054, ulCluster);
    63116204      }
    63126205   else
    63136206      {
    6314       Message("DeleteFatChain for invalid cluster %lu (ERROR)", ulCluster);
     6207      MessageL(LOG_FUNCS, "DeleteFatChain%m for invalid cluster %lu (ERROR)", 0x0055, ulCluster);
    63156208      return FALSE;
    63166209      }
     
    64196312ULONG  ulSector = 0;
    64206313
    6421    if (f32Parms.fMessageActive & LOG_FUNCS)
    6422       Message("SeekToCluster");
     6314   MessageL(LOG_FUNCS, "SeekToCluster%m", 0x0056);
    64236315
    64246316#ifdef EXFAT
     
    64956387ULONG  ulReturn = 0;
    64966388
    6497    if (f32Parms.fMessageActive & LOG_FUNCS)
    6498       Message("GetLastCluster");
     6389   MessageL(LOG_FUNCS, "GetLastCluster%m", 0x0057);
    64996390
    65006391   if (!ulCluster)
     
    65636454
    65646455
    6565    if (f32Parms.fMessageActive & LOG_FUNCS)
    6566       Message("CopyChain, cluster %lu", ulCluster);
     6456   MessageL(LOG_FUNCS, "CopyChain%m, cluster %lu", 0x0058, ulCluster);
    65676457
    65686458   if (!ulCluster)
     
    66406530USHORT usSectorsPerBlock;
    66416531
    6642    if (f32Parms.fMessageActive & LOG_FUNCS)
    6643       Message("GetChainSize");
     6532   MessageL(LOG_FUNCS, "GetChainSize%m", 0x0059);
    66446533
    66456534   if (ulCluster == 1)
  • trunk/src/ifs/fat32b.c

    r294 r296  
    5858PSZ    p;
    5959
    60    if (f32Parms.fMessageActive & LOG_FUNCS)
    61       Message("FindDirCluster for %s, CurDirEnd %u, AttrWanted %u", pDir, usCurDirEnd, usAttrWanted );
     60   MessageL(LOG_FUNCS, "FindDirCluster%m for %s, CurDirEnd %u, AttrWanted %u",
     61            0x0031, pDir, usCurDirEnd, usAttrWanted );
    6262
    6363   if (pcdfsi &&
     
    124124   if (ulCluster == pVolInfo->ulFatEof)
    125125      {
    126       if (f32Parms.fMessageActive & LOG_FUNCS)
    127          Message("FindDirCluster for '%s', not found", szDir);
     126      MessageL(LOG_FUNCS, "FindDirCluster%m for '%s', not found", 0x4002, szDir);
    128127      free(szDir);
    129128      free(pDirEntry);
     
    138137#endif
    139138      {
    140       if (f32Parms.fMessageActive & LOG_FUNCS)
    141          Message("FindDirCluster for '%s', not a directory", szDir);
     139      MessageL(LOG_FUNCS, "FindDirCluster%m for '%s', not a directory", 0x4003, szDir);
    142140      free(szDir);
    143141      free(pDirEntry);
     
    206204      USHORT usSectorsPerBlock;
    207205
    208       if (f32Parms.fMessageActive & LOG_FUNCS)
    209          Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
     206      MessageL(LOG_FUNCS, "FindPathCluster%m for %s, dircluster %lu", 0x0032, pszPath, ulCluster);
    210207
    211208      if (ulCluster == 1)
     
    414411      free(pDirStart);
    415412      free(pszLongName);
    416       if (f32Parms.fMessageActive & LOG_FUNCS)
    417          {
    418          if (ulCluster != pVolInfo->ulFatEof)
    419             Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
    420          else
    421             Message("FindPathCluster for %s returned EOF", pszPath);
    422          }
     413      if (ulCluster != pVolInfo->ulFatEof)
     414         MessageL(LOG_FUNCS, "FindPathCluster%m for %s found cluster %ld", 0x8032, pszPath, ulCluster);
     415      else
     416         MessageL(LOG_FUNCS, "FindPathCluster%m for %s returned EOF", 0x8033, pszPath);
    423417      return ulCluster;
    424418      }
     
    436430      USHORT usFileAttr;
    437431
    438       if (f32Parms.fMessageActive & LOG_FUNCS)
    439          Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
     432      MessageL(LOG_FUNCS, "FindPathCluster%m for %s, dircluster %lu", 0x0032, pszPath, ulCluster);
    440433
    441434      if (pDirEntry1)
     
    642635      free(pDirStart);
    643636      free(pszLongName);
    644       if (f32Parms.fMessageActive & LOG_FUNCS)
    645          {
    646          if (ulCluster != pVolInfo->ulFatEof)
    647             Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
    648          else
    649             Message("FindPathCluster for %s returned EOF", pszPath);
    650          }
     637      if (ulCluster != pVolInfo->ulFatEof)
     638         MessageL(LOG_FUNCS, "FindPathCluster%m for %s found cluster %ld", 0x8032, pszPath, ulCluster);
     639      else
     640         MessageL(LOG_FUNCS, "FindPathCluster%m for %s returned EOF", 0x8033, pszPath);
    651641      return ulCluster;
    652642      }
     
    676666ULONG  ulDirEntries = 0;
    677667
    678    if (f32Parms.fMessageActive & LOG_FUNCS)
    679       Message("TranslateName: %s", pszPath);
     668   MessageL(LOG_FUNCS, "TranslateName%m: %s", 0x0034, pszPath);
    680669
    681670   memset(pszTarget, 0, FAT32MAXPATH);
     
    968957      PDIRENTRY pLNStart;
    969958
    970       if (f32Parms.fMessageActive & LOG_FUNCS)
    971          Message("ModifyDirectory DirCluster %ld, Mode = %d",
    972             ulDirCluster, usMode);
     959      MessageL(LOG_FUNCS, "ModifyDirectory%m DirCluster %ld, Mode = %d",
     960               0x0035, ulDirCluster, usMode);
    973961
    974962      pDirNew = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     
    11501138                        {
    11511139                        case MODIFY_DIR_UPDATE:
    1152                            if (f32Parms.fMessageActive & LOG_FUNCS)
    1153                               Message(" Updating cluster");
     1140                           MessageL(LOG_FUNCS, " Updating cluster%m", 0x4009);
    11541141                           memcpy(pWork, pNew, sizeof (DIRENTRY));
    11551142                           if (ulCluster == 1)
     
    11691156                        case MODIFY_DIR_DELETE:
    11701157                        case MODIFY_DIR_RENAME:
    1171                            if (f32Parms.fMessageActive & LOG_FUNCS)
    1172                               Message(" Removing entry from cluster");
     1158                           MessageL(LOG_FUNCS, " Removing entry from cluster%m", 0x400a);
    11731159                           pWork2 = pLNStart;
    11741160                           while (pWork2 < pWork)
    11751161                              {
    1176                               if (f32Parms.fMessageActive & LOG_FUNCS)
    1177                                  Message("Deleting Longname entry.");
     1162                              MessageL(LOG_FUNCS, "Deleting Longname entry.%m", 0x400b);
    11781163                              pWork2->bFileName[0] = DELETED_ENTRY;
    11791164                              pWork2++;
     
    12401225                     BYTE bCheck = GetVFATCheckSum(pDirNew);
    12411226
    1242                      if (f32Parms.fMessageActive & LOG_FUNCS)
    1243                         Message(" Inserting entry into 2 clusters");
     1227                     MessageL(LOG_FUNCS, " Inserting entry into 2 clusters%m", 0x400c);
    12441228
    12451229                     pWork = CompactDir(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
     
    12791263                     BYTE bCheck = GetVFATCheckSum(pDirNew);
    12801264
    1281                      if (f32Parms.fMessageActive & LOG_FUNCS)
    1282                         Message(" Inserting entry into 1 cluster");
     1265                     MessageL(LOG_FUNCS, " Inserting entry into 1 cluster%m", 0x400d);
    12831266
    12841267                     pWork = CompactDir(pDir2, ulBytesToRead, usEntriesNeeded);
     
    14351418      BOOL      fFound;
    14361419
    1437       if (f32Parms.fMessageActive & LOG_FUNCS)
    1438          Message("ModifyDirectory DirCluster %ld, Mode = %d",
    1439             ulDirCluster, usMode);
     1420      MessageL(LOG_FUNCS, "ModifyDirectory%m DirCluster %ld, Mode = %d",
     1421               0x0035, ulDirCluster, usMode);
    14401422
    14411423      pDirNew = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     
    16341616                        {
    16351617                        case MODIFY_DIR_UPDATE:
    1636                            if (f32Parms.fMessageActive & LOG_FUNCS)
    1637                               Message(" Updating cluster");
     1618                           MessageL(LOG_FUNCS, " Updating cluster%m", 0x4009);
    16381619                           memcpy(pWorkFile, pNew, sizeof (DIRENTRY1));
    16391620                           if (pStreamNew)
     
    16591640                        case MODIFY_DIR_DELETE:
    16601641                        case MODIFY_DIR_RENAME:
    1661                            if (f32Parms.fMessageActive & LOG_FUNCS)
    1662                               Message(" Removing entry from cluster");
     1642                           MessageL(LOG_FUNCS, " Removing entry from cluster%m", 0x400a);
    16631643                           pWork2 = pLNStart;
    16641644                           //while (pWork2 < pWork)
    16651645                           for (usIndex = 0; usIndex < usNumSecondary - 1; usIndex++)
    16661646                              {
    1667                               if (f32Parms.fMessageActive & LOG_FUNCS)
    1668                                  Message("Deleting Longname entry.");
     1647                              MessageL(LOG_FUNCS, "Deleting Longname entry.%m", 0x400b);
    16691648                              //pWork2->bFileName[0] = DELETED_ENTRY;
    16701649                              pWork2->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
     
    17371716                     //BYTE bCheck = GetVFATCheckSum(pDirNew);
    17381717
    1739                      if (f32Parms.fMessageActive & LOG_FUNCS)
    1740                         Message(" Inserting entry into 2 clusters");
     1718                     MessageL(LOG_FUNCS, " Inserting entry into 2 clusters%m", 0x400c);
    17411719
    17421720                     pWork = CompactDir1(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
     
    17851763                     //BYTE bCheck = GetVFATCheckSum(pDirNew);
    17861764
    1787                      if (f32Parms.fMessageActive & LOG_FUNCS)
    1788                         Message(" Inserting entry into 1 cluster");
     1765                     MessageL(LOG_FUNCS, " Inserting entry into 1 cluster%m", 0x400d);
    17891766
    17901767                     pWork = CompactDir1(pDir2, ulBytesToRead, usEntriesNeeded);
  • trunk/src/ifs/ifsattr.c

    r291 r296  
    3737   _asm push es;
    3838
    39    if (f32Parms.fMessageActive & LOG_FS)
    40       Message("FS_FILEATTRIBUTE, Flag = %X for %s", usFlag, pName);
     39   MessageL(LOG_FS, "FS_FILEATTRIBUTE%m, Flag = %X for %s", 0x000d, usFlag, pName);
    4140
    4241   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    230229#endif
    231230
    232    if (f32Parms.fMessageActive & LOG_FS)
    233       Message("FS_FILEATTRIBUTE returned %d", rc);
     231   MessageL(LOG_FS, "FS_FILEATTRIBUTE%m returned %d", 0x800d, rc);
    234232
    235233   _asm pop es;
     
    266264   _asm push es;
    267265
    268    if (f32Parms.fMessageActive & LOG_FS)
    269       Message("FS_PATHINFO Flag = %d, Level = %d called for %s, cbData = %u",
    270           usFlag, usLevel, pName, cbData);
     266   MessageL(LOG_FS, "FS_PATHINFO%m Flag = %d, Level = %d called for %s, cbData = %u",
     267            0x000e, usFlag, usLevel, pName, cbData);
    271268
    272269   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    11361133#endif
    11371134
    1138    if (f32Parms.fMessageActive & LOG_FS)
    1139       Message("FS_PATHINFO returned %u", rc);
     1135   MessageL(LOG_FS, "FS_PATHINFO%m returned %u", 0x800e, rc);
    11401136
    11411137   _asm pop es;
  • trunk/src/ifs/ifscache.c

    r295 r296  
    243243
    244244#if 0
    245    if (f32Parms.fMessageActive & LOG_CACHE)
    246       {
    247       if (ulSector > pVolInfo->ulStartOfData)
    248          Message("Cluster %lu not found in cache!",
    249             (ulSector - pVolInfo->ulStartOfData) / pVolInfo->SectorsPerCluster + 2);
    250       }
     245   if (ulSector > pVolInfo->ulStartOfData)
     246      MessageL(LOG_CACHE, "Cluster%m %lu not found in cache!", 0x4062,
     247               (ulSector - pVolInfo->ulStartOfData) / pVolInfo->SectorsPerCluster + 2);
    251248#endif
    252249   pbSectors = NULL;
     
    389386   if (!f32Parms.fLW || (usIOMode & DVIO_OPWRTHRU) || (usIOMode & DVIO_OPNCACHE))
    390387      {
    391       if (f32Parms.fLW && f32Parms.fMessageActive & LOG_CACHE)
    392          Message("WriteSector: Writing sector thru");
     388      MessageL(LOG_CACHE, "WriteSector%m: Writing sector thru", 0x4063);
    393389      pVolInfo->ulLastDiskTime = GetCurTime();
    394390      rc = FSH_DOVOLIO(DVIO_OPWRITE | usIOMode | VerifyOn(), DVIO_ALLACK, pVolInfo->hVBP, pbData, &usSectors, ulSector);
     
    574570
    575571#ifdef WAIT_THRESHOLD
    576                 if (f32Parms.fMessageActive & LOG_CACHE ||
    577                     f32Parms.fMessageActive & LOG_WAIT)
    578                     Message("waiting for dirty sectors to be less than threshold...");
     572                MessageL(LOG_CACHE | LOG_WAIT, "waiting for dirty sectors to be less than threshold%m...", 0x4064);
    579573
    580574                FSH_SEMSET(&ulSemEmergencyDone);
     
    963957         usCBIndex = usCBIndexNew;
    964958         }
    965       if (f32Parms.fMessageActive & LOG_CACHE && usCount > 0)
    966          Message("%u sectors LAZY flushed, still %u dirty", usCount, f32Parms.usDirtySectors);
     959      if (usCount > 0)
     960         MessageL(LOG_CACHE, "%m%u sectors LAZY flushed, still %u dirty", 0x8065, usCount, f32Parms.usDirtySectors);
    967961
    968962      return 0;
    969963      }
    970964
    971    if (f32Parms.fMessageActive & LOG_CACHE)
    972       Message("usFlushVolume ALL");
     965   MessageL(LOG_CACHE, "usFlushVolume%m ALL", 0x4066);
    973966
    974967   usCBIndex = 0;
     
    998991      }
    999992
    1000    if (f32Parms.fMessageActive & LOG_CACHE)
    1001       Message("%u sectors flushed, still %u dirty", usCount, f32Parms.usDirtySectors);
     993   MessageL(LOG_CACHE, "%m%u sectors flushed, still %u dirty", 0x8167, usCount, f32Parms.usDirtySectors);
    1002994   return 0;
    1003995}
     
    10781070   pVolInfo->ulLastDiskTime = GetCurTime();
    10791071
    1080    if (f32Parms.fMessageActive & LOG_CACHE)
    1081       Message("usEmergencyFlush: %u sectors flushed, still %u dirty", usCount, f32Parms.usDirtySectors);
     1072   MessageL(LOG_CACHE, "usEmergencyFlush%m: %u sectors flushed, still %u dirty", 0x8168, usCount, f32Parms.usDirtySectors);
    10821073
    10831074   return 0;
  • trunk/src/ifs/ifsdir.c

    r290 r296  
    3131   _asm push es;
    3232
    33    if (f32Parms.fMessageActive & LOG_FS)
    34       Message("FS_CHDIR, flag %u", usFlag);
     33   MessageL(LOG_FS, "FS_CHDIR%m, flag %u", 0x000f, usFlag);
    3534
    3635   szDirLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     
    159158      free(szDirLongName);
    160159
    161    if (f32Parms.fMessageActive & LOG_FS)
    162       Message("FS_CHDIR returned %u", rc);
     160   MessageL(LOG_FS, "FS_CHDIR%m returned %u", 0x800f, rc);
    163161
    164162   _asm pop es;
     
    195193   usFlags = usFlags;
    196194
    197    if (f32Parms.fMessageActive & LOG_FS)
    198       Message("FS_MKDIR - %s", pName);
     195   MessageL(LOG_FS, "FS_MKDIR%m - %s", 0x0010, pName);
    199196
    200197   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    400397#endif
    401398
    402    if (f32Parms.fMessageActive & LOG_FS)
    403       Message("FS_MKDIR returned %u", rc);
     399   MessageL(LOG_FS, "FS_MKDIR%m returned %u", 0x8010, rc);
    404400
    405401   _asm pop es;
     
    433429   _asm push es;
    434430
    435    if (f32Parms.fMessageActive & LOG_FS)
    436       Message("FS_RMDIR %s", pName);
     431   MessageL(LOG_FS, "FS_RMDIR%m %s", 0x0011, pName);
    437432
    438433   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    706701      free(szLongName);
    707702
    708    if (f32Parms.fMessageActive & LOG_FS)
    709       Message("FS_RMDIR returned %u", rc);
     703   MessageL(LOG_FS, "FS_RMDIR%m returned %u", 0x8011, rc);
    710704
    711705   _asm pop es;
  • trunk/src/ifs/ifsea.c

    r284 r296  
    3535PFEA pTarFea;
    3636
    37    if (f32Parms.fMessageActive & LOG_EAS)
    38       Message("usModifyEAS for %s", pszFileName);
     37   MessageL(LOG_EAS, "usModifyEAS%m for %s", 0x005a, pszFileName);
    3938
    4039   /*
     
    6968      return rc;
    7069
    71    if (f32Parms.fMessageActive & LOG_EAS)
    72       Message("cbList before = %lu", pTarFeal->cbList);
     70   MessageL(LOG_EAS, "cbList before%m = %lu", 0x4036, pTarFeal->cbList);
    7371
    7472   pSrcMax = (PBYTE)pSrcFeal + pSrcFeal->cbList;
     
    111109         pTarFeal->cbList += usNewSize;
    112110
    113          if (f32Parms.fMessageActive & LOG_EAS)
    114             Message("Inserting EA '%s' (%u,%u)", pName,
    115                pSrcFea->cbName, pSrcFea->cbValue);
     111         MessageL(LOG_EAS, "Inserting EA%m '%s' (%u,%u)", 0x4037, pName,
     112                  pSrcFea->cbName, pSrcFea->cbValue);
    116113         }
    117114      else
     
    136133         pTarFeal->cbList += usNewSize;
    137134
    138          if (f32Parms.fMessageActive & LOG_EAS)
    139             Message("Updating EA '%s' (%u,%u)", pName,
    140                pSrcFea->cbName, pSrcFea->cbValue);
     135         MessageL(LOG_EAS, "Updating EA%m '%s' (%u,%u)", 0x4038, pName,
     136                  pSrcFea->cbName, pSrcFea->cbValue);
    141137         }
    142138
     
    145141      }
    146142
    147    if (f32Parms.fMessageActive & LOG_EAS)
    148       Message("cbList after = %lu", pTarFeal->cbList);
     143   MessageL(LOG_EAS, "cbList after%m = %lu", 0x4039, pTarFeal->cbList);
    149144
    150145   if (pTarFeal->cbList > 4)
     
    156151   free(pTarFeal);
    157152
    158    if (f32Parms.fMessageActive & LOG_EAS)
    159       Message("usModifyEAS for %s returned %d",
    160          pszFileName, rc);
     153   MessageL(LOG_EAS, "usModifyEAS%m for %s returned %d",
     154            0x805a, pszFileName, rc);
    161155
    162156   return rc;
     
    174168ULONG    ulCluster;
    175169
    176    if (f32Parms.fMessageActive & LOG_EAS)
    177       Message("usGetEASSize for %s", pszFileName);
     170   MessageL(LOG_EAS, "usGetEASSize%m for %s", 0x005b, pszFileName);
    178171
    179172   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     
    230223#endif
    231224
    232    if (f32Parms.fMessageActive & LOG_EAS)
    233       Message("usGetEASize for %s returned %d (%u bytes large)",
    234          pszFileName, rc, *pulSize);
     225   MessageL(LOG_EAS, "usGetEASize%m for %s returned %d (%u bytes large)",
     226            0x805b, pszFileName, rc, *pulSize);
    235227
    236228   return rc;
     
    250242USHORT   usMaxSize;
    251243
    252    if (f32Parms.fMessageActive & LOG_EAS)
    253       Message("usGetEAS for %s Level %d", pszFileName, usLevel);
     244   MessageL(LOG_EAS, "usGetEAS%m for %s Level %d", 0x005c, pszFileName, usLevel);
    254245
    255246   /*
     
    345336               goto usGetEASExit;
    346337               }
    347             if (f32Parms.fMessageActive & LOG_EAS)
    348                Message("Found %s", pSrcFea + 1);
     338            MessageL(LOG_EAS, "Found%m %s", 0x403c, pSrcFea + 1);
    349339            memcpy(pTarFea, pSrcFea, usFeaSize);
    350340            }
     
    362352               }
    363353
    364             if (f32Parms.fMessageActive & LOG_EAS)
    365                Message("usGetEAS: %s not found!", pGea->szName);
     354            MessageL(LOG_EAS, "usGetEAS%m: %s not found!", 0x403d, pGea->szName);
    366355
    367356            pTarFea->fEA = 0x00;
     
    392381            goto usGetEASExit;
    393382            }
    394          if (f32Parms.fMessageActive & LOG_EAS)
    395             Message("Found %s (%u,%u)", pSrcFea + 1, (USHORT)pSrcFea->cbName, pSrcFea->cbValue);
     383         MessageL(LOG_EAS, "Found%m %s (%u,%u)", 0x403e, pSrcFea + 1, (USHORT)pSrcFea->cbName, pSrcFea->cbValue);
    396384         memcpy(pTarFea, pSrcFea, usFeaSize);
    397385         pTarFea = (PFEA)((PBYTE)pTarFea + usFeaSize);
     
    409397      free(pSrcFeal);
    410398
    411    if (f32Parms.fMessageActive & LOG_EAS)
    412       Message("usGetEAS for %s returned %d (%lu bytes in EAS)",
    413          pszFileName, rc, pTarFeal->cbList);
     399   MessageL(LOG_EAS, "usGetEAS%m for %s returned %d (%lu bytes in EAS)",
     400            0x805c, pszFileName, rc, pTarFeal->cbList);
    414401
    415402   return rc;
     
    532519#endif
    533520
    534    if (f32Parms.fMessageActive & LOG_EAS)
    535       Message("usCopyEAS for returned %d", rc);
     521   MessageL(LOG_EAS, "usCopyEAS%m for returned %d", 0x805d, rc);
    536522
    537523   return rc;
     
    632618#endif
    633619
    634    if (f32Parms.fMessageActive & LOG_EAS)
    635       Message("usMoveEAS for returned %d", rc);
     620   MessageL(LOG_EAS, "usMoveEAS%m for returned %d", 0x805e, rc);
    636621
    637622   return rc;
     
    779764
    780765   pRead = (PBYTE)pFEAL;
    781    if (f32Parms.fMessageActive & LOG_EAS)
    782       Message("usReadEAS: Reading (1) cluster %lu", ulCluster);
     766   MessageL(LOG_EAS, "usReadEAS%m: Reading (1) cluster %lu", 0x4041, ulCluster);
    783767
    784768   rc = ReadBlock(pVolInfo, ulCluster, 0, pRead, 0);
     
    807791      Optimalisatie?
    808792   */
    809    if (f32Parms.fMessageActive & LOG_EAS)
    810       Message("usReadEAS: %u clusters used", usClustersUsed);
     793   MessageL(LOG_EAS, "usReadEAS%m: %u clusters used", 0x4042, usClustersUsed);
    811794
    812795   usBlocksUsed--;
     
    847830         Optimalisatie?
    848831      */
    849          if (f32Parms.fMessageActive & LOG_EAS)
    850             Message("usReadEAS: Reading (2) cluster %lu, block %lu", ulCluster, ulBlock);
     832         MessageL(LOG_EAS, "usReadEAS%m: Reading (2) cluster %lu, block %lu", 0x4043, ulCluster, ulBlock);
    851833
    852834         rc = ReadBlock(pVolInfo, ulCluster, ulBlock, pRead, 0);
     
    932914#endif
    933915
    934    if (f32Parms.fMessageActive & LOG_EAS)
    935       Message("usDeleteEAS for %s returned %d",
    936          pszFileName, rc);
     916   MessageL(LOG_EAS, "usDeleteEAS%m for %s returned %d",
     917            0x805f, pszFileName, rc);
    937918
    938919   return rc;
     
    12391220         return NULL;
    12401221#if 0
    1241       if (f32Parms.fMessageActive & LOG_EAS)
    1242          Message("FindEA: '%s'", pName);
     1222      MessageL(LOG_EAS, "FindEA%m: '%s'", 0x0060, pName);
    12431223#endif
    12441224      if (pFea->cbName == (BYTE)usMaxName && !memicmp(pName, pszName, usMaxName))
     
    12941274   ULONG    ulCurrGeaLen;
    12951275
    1296    if (f32Parms.fMessageActive & LOG_EAS)
    1297       Message("usGetEmptyEAS for %s with pEAOP %lX", pszFileName,pEAOP);
     1276   MessageL(LOG_EAS, "usGetEmptyEAS%m for %s with pEAOP %lX", 0x0061, pszFileName,pEAOP);
    12981277
    12991278   /*
  • trunk/src/ifs/ifsfile.c

    r295 r296  
    7878      usIOMode |= DVIO_OPWRTHRU;
    7979
    80    if (f32Parms.fMessageActive & LOG_FS)
    81       {
    82       Message("FS_OPENCREATE for %s mode %lX, Flag %X, IOMode %X, selfsfn=%u",
    83          pName, ulOpenMode, usOpenFlag, usIOMode, psffsi->sfi_selfsfn);
    84       Message("              attribute %X, pEABuf %lX", usAttr, pEABuf);
    85       }
     80   MessageL(LOG_FS, "FS_OPENCREATE%m for %s mode %lX, Flag %X, IOMode %X, selfsfn=%u",
     81            0x0012, pName, ulOpenMode, usOpenFlag, usIOMode, psffsi->sfi_selfsfn);
     82   MessageL(LOG_FS, "%m              attribute %X, pEABuf %lX", 0x0013, usAttr, pEABuf);
    8683
    8784   pVolInfo = GetVolInfo(pcdfsi->cdi_hVPB);
     
    10191016      }
    10201017
    1021    if (f32Parms.fMessageActive & LOG_FS)
    1022       Message("FS_OPENCREATE returned %u (Action = %u, OI=%lX)", rc, *pAction, pOpenInfo);
     1018   MessageL(LOG_FS, "FS_OPENCREATE%m returned %u (Action = %u, OI=%lX)",
     1019            0x8012, rc, *pAction, pOpenInfo);
    10231020
    10241021   _asm pop es;
     
    11821179      }
    11831180
    1184    if (f32Parms.fMessageActive & LOG_FS)
    1185       {
    1186       if (psffsi->sfi_mode & OPEN_FLAGS_DASD)
    1187          Message("FS_CLOSE (DASD) type %u:", usType);
    1188       else
    1189          Message("FS_CLOSE of %s, type = %u OI=%lX",
    1190             pOpenInfo->pSHInfo->szFileName,
    1191             usType,
    1192             pOpenInfo);
    1193       }
     1181   if (psffsi->sfi_mode & OPEN_FLAGS_DASD)
     1182      MessageL(LOG_FS, "FS_CLOSE%m (DASD) type %u:", 0x0014, usType);
     1183   else
     1184      MessageL(LOG_FS, "FS_CLOSE%m of %s, type = %u OI=%lX",
     1185               0x0015, pOpenInfo->pSHInfo->szFileName,
     1186               usType,
     1187               pOpenInfo);
    11941188
    11951189   if (IsDriveLocked(pVolInfo))
     
    12261220
    12271221FS_CLOSEEXIT:
    1228    if (f32Parms.fMessageActive & LOG_FS)
    1229       Message("FS_CLOSE returned %u", rc);
     1222   MessageL(LOG_FS, "FS_CLOSE%m returned %u", 0x8014, rc);
    12301223
    12311224   _asm pop es;
     
    12881281#endif
    12891282
    1290    if (f32Parms.fMessageActive & LOG_FS)
    1291       Message("FS_READ, %u bytes at offset %lld",
    1292          usBytesToRead, pos);
     1283   MessageL(LOG_FS, "FS_READ%m, %u bytes at offset %lld",
     1284            0x0016, usBytesToRead, pos);
    12931285
    12941286   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    18491841        free( pbCluster );
    18501842
    1851     if (f32Parms.fMessageActive & LOG_FS)
    1852         Message("FS_READ returned %u (%u bytes read)", rc, *pLen);
     1843   MessageL(LOG_FS, "FS_READ%m returned %u (%u bytes read)", 0x8016, rc, *pLen);
    18531844
    18541845   _asm pop es;
     
    19111902#endif
    19121903
    1913    if (f32Parms.fMessageActive & LOG_FS)
    1914       Message("FS_WRITE, %u bytes at offset %lld, pData=%lx, Len=%u, ioflag %X, size = %llu",
    1915       usBytesToWrite, pos, pData, *pLen, usIOFlag, size);
     1904   MessageL(LOG_FS, "FS_WRITE%m, %u bytes at offset %lld, pData=%lx, Len=%u, ioflag %X, size = %llu",
     1905            0x0017, usBytesToWrite, pos, pData, *pLen, usIOFlag, size);
    19161906
    19171907   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    26522642      free( pbCluster );
    26532643
    2654    if (f32Parms.fMessageActive & LOG_FS)
    2655       Message("FS_WRITE returned %u (%u bytes written)", rc, *pLen);
     2644   MessageL(LOG_FS, "FS_WRITE%m returned %u (%u bytes written)", 0x8017, rc, *pLen);
    26562645
    26572646   _asm pop es;
     
    26902679)
    26912680{
    2692    if (f32Parms.fMessageActive & LOG_FS)
    2693       Message("FS_CANCELLOCKREQUESTL - NOT SUPPORTED");
     2681   MessageL(LOG_FS, "FS_CANCELLOCKREQUESTL%m - NOT SUPPORTED", 0x0018);
    26942682   return ERROR_NOT_SUPPORTED;
    26952683
     
    27082696)
    27092697{
    2710    if (f32Parms.fMessageActive & LOG_FS)
    2711       Message("FS_CANCELLOCKREQUEST");
     2698   MessageL(LOG_FS, "FS_CANCELLOCKREQUEST%m", 0x0019);
    27122699
    27132700   return FS_CANCELLOCKREQUESTL(psffsi, psffsd, pLockRang);
     
    27602747#endif
    27612748
    2762    if (f32Parms.fMessageActive & LOG_FS)
    2763       Message("FS_CHGFILEPTRL, Mode %d - offset %lld, current offset=%lld",
    2764       usType, llOffset, pos);
     2749   MessageL(LOG_FS, "FS_CHGFILEPTRL%m, Mode %d - offset %lld, current offset=%lld",
     2750            0x001a, usType, llOffset, pos);
    27652751
    27662752   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    28632849#endif
    28642850
    2865    if (f32Parms.fMessageActive & LOG_FS)
    2866       Message("FS_CHGFILEPTRL returned %u", rc);
     2851   MessageL(LOG_FS, "FS_CHGFILEPTRL%m returned %u", 0x801a, rc);
    28672852
    28682853   _asm pop es;
     
    29052890#endif
    29062891
    2907    if (f32Parms.fMessageActive & LOG_FS)
    2908       Message("FS_CHGFILEPTR, Mode %d - offset %ld, current offset=%lld",
    2909       usType, lOffset, pos);
     2892   MessageL(LOG_FS, "FS_CHGFILEPTR%m, Mode %d - offset %ld, current offset=%lld",
     2893            0x001b, usType, lOffset, pos);
    29102894
    29112895   rc = FS_CHGFILEPTRL(psffsi, psffsd,
     
    29132897                       IOFlag);
    29142898
    2915    if (f32Parms.fMessageActive & LOG_FS)
    2916       Message("FS_CHGFILEPTR returned %u", rc);
     2899   MessageL(LOG_FS, "FS_CHGFILEPTR%m returned %u", 0x801b, rc);
    29172900
    29182901   return rc;
     
    29342917   _asm push es;
    29352918
    2936    if (f32Parms.fMessageActive & LOG_FS)
    2937       Message("FS_COMMIT, type %d", usType);
     2919   MessageL(LOG_FS, "FS_COMMIT%m, type %d", 0x001c, usType);
    29382920
    29392921#ifdef INCL_LONGLONG
     
    31813163FS_COMMITEXIT:
    31823164
    3183    if (f32Parms.fMessageActive & LOG_FS)
    3184       Message("FS_COMMIT returned %u", rc);
     3165   MessageL(LOG_FS, "FS_COMMIT%m returned %u", 0x801c, rc);
    31853166
    31863167   _asm pop es;
     
    32013182)
    32023183{
    3203    if (f32Parms.fMessageActive & LOG_FS)
    3204       Message("FS_FILELOCKSL");
     3184   MessageL(LOG_FS, "FS_FILELOCKSL%m - NOT SUPPORTED", 0x001d);
    32053185   return ERROR_NOT_SUPPORTED;
    32063186
     
    32253205)
    32263206{
    3227    if (f32Parms.fMessageActive & LOG_FS)
    3228       Message("FS_FILELOCKS");
     3207   MessageL(LOG_FS, "FS_FILELOCKS%m", 0x001e);
    32293208
    32303209   return FS_FILELOCKSL(psffsi, psffsd,
     
    32533232   pOpenInfo->pSHInfo->fMustCommit = TRUE;
    32543233
    3255    if (f32Parms.fMessageActive & LOG_FS)
    3256       Message("FS_NEWSIZEL newsize = %llu", ullLen);
     3234   MessageL(LOG_FS, "FS_NEWSIZEL%m newsize = %llu", 0x001f, ullLen);
    32573235
    32583236   if (psffsi->sfi_mode & OPEN_FLAGS_DASD)
     
    32893267      psffsi->sfi_tstamp |= ST_SWRITE | ST_PWRITE;
    32903268
    3291    if (f32Parms.fMessageActive & LOG_FS)
    3292       Message("FS_NEWSIZEL returned %u", rc);
    3293 
    32943269FS_NEWSIZELEXIT:
     3270   MessageL(LOG_FS, "FS_NEWSIZEL%m returned %u", 0x801f, rc);
     3271
    32953272   _asm pop es;
    32963273
     
    33173294#endif
    33183295
    3319    if (f32Parms.fMessageActive & LOG_FS)
    3320       Message("FS_NEWSIZEL newsize = %lu", ulLen);
     3296   MessageL(LOG_FS, "FS_NEWSIZE%m newsize = %lu", 0x0020, ulLen);
    33213297
    33223298   rc = FS_NEWSIZEL(psffsi, psffsd,
    33233299                    ullLen, usIOFlag);
    33243300
    3325    if (f32Parms.fMessageActive & LOG_FS)
    3326       Message("FS_NEWSIZEL returned %u", rc);
     3301   MessageL(LOG_FS, "FS_NEWSIZE%m returned %u", 0x8020, rc);
    33273302
    33283303   return rc;
     
    35513526#endif
    35523527
    3553    if (f32Parms.fMessageActive & LOG_FS)
    3554       Message("FS_FILEINFO for %s, usFlag = %X, level %d",
    3555          pOpenInfo->pSHInfo->szFileName,
    3556          usFlag, usLevel);
     3528   MessageL(LOG_FS, "FS_FILEINFO%m for %s, usFlag = %X, level %d",
     3529            0x0021,
     3530            pOpenInfo->pSHInfo->szFileName,
     3531            usFlag, usLevel);
    35573532
    35583533   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    40604035
    40614036FS_FILEINFOEXIT:
    4062    if (f32Parms.fMessageActive & LOG_FS)
    4063       Message("FS_FILEINFO returned %u", rc);
     4037   MessageL(LOG_FS, "FS_FILEINFO%m returned %u", 0x8021, rc);
    40644038
    40654039   _asm pop es;
     
    40954069   _asm push es;
    40964070
    4097    if (f32Parms.fMessageActive & LOG_FS)
    4098       Message("FS_FILEIO");
     4071   MessageL(LOG_FS, "FS_FILEIO%m", 0x0022);
    40994072
    41004073   //if (cbCmdList > 256)
     
    42274200
    42284201//FS_FILEIO_EXIT:
    4229    if (f32Parms.fMessageActive & LOG_FS)
    4230       Message("FS_FILEIO returned %u", rc);
     4202   MessageL(LOG_FS, "FS_FILEIO%m returned %u", 0x8022, rc);
    42314203
    42324204   _asm pop es;
     
    42484220)
    42494221{
    4250    if (f32Parms.fMessageActive & LOG_FS)
    4251       Message("FS_NMPIPE - NOT SUPPORTED");
     4222   MessageL(LOG_FS, "FS_NMPIPE%m - NOT SUPPORTED", 0x0023);
    42524223   return ERROR_NOT_SUPPORTED;
    42534224
  • trunk/src/ifs/ifsfind.c

    r291 r296  
    2828   _asm push es;
    2929
    30    if (f32Parms.fMessageActive & LOG_FS)
    31       Message("FS_FINDCLOSE");
     30   MessageL(LOG_FS, "FS_FINDCLOSE%m", 0x0005);
    3231
    3332   pVolInfo = GetVolInfo(pfsfsi->fsi_hVPB);
     
    9998   _asm push es;
    10099
    101    if (f32Parms.fMessageActive & LOG_FS)
    102       Message("FS_FINDFIRST for %s attr %X, Level %d, cbData %u, MaxEntries %u", pName, usAttr, usLevel, cbData, *pcMatch);
     100   MessageL(LOG_FS, "FS_FINDFIRST%m for %s attr %X, Level %d, cbData %u, MaxEntries %u",
     101            0x0006, pName, usAttr, usLevel, cbData, *pcMatch);
    103102
    104103   usEntriesWanted = *pcMatch;
     
    295294      (PDIRENTRY)(&pFindInfo->pInfo->rgClusters[usNumClusters]);
    296295
    297    if (f32Parms.fMessageActive & LOG_FIND)
    298       Message("pInfo at %lX, pDirEntries at %lX",
    299          pFindInfo->pInfo, pFindInfo->pInfo->pDirEntries);
     296   MessageL(LOG_FIND, "pInfo%m at %lX, pDirEntries at %lX",
     297            0x406d, pFindInfo->pInfo, pFindInfo->pInfo->pDirEntries);
    300298
    301299   pFindInfo->pInfo->pNextEntry = NULL;
     
    394392      }
    395393
    396    if (f32Parms.fMessageActive & LOG_FS)
    397       Message("FS_FINDFIRST returned %d (%d entries)",
    398          rc, *pcMatch);
     394   MessageL(LOG_FS, "FS_FINDFIRST%m returned %d (%d entries)",
     395            0x8006, rc, *pcMatch);
    399396
    400397   _asm pop es;
     
    423420   pName = pName;
    424421
    425    if (f32Parms.fMessageActive & LOG_FS)
    426       Message("FS_FINDFROMNAME, curpos = %lu, requested %lu",
    427          pFindInfo->pInfo->ulCurEntry, ulPosition);
     422   MessageL(LOG_FS, "FS_FINDFROMNAME%m, curpos = %lu, requested %lu",
     423            0x0009, pFindInfo->pInfo->ulCurEntry, ulPosition);
    428424
    429425   pFindInfo->pInfo->ulCurEntry = ulPosition + 1;
     
    453449   _asm push es;
    454450
    455    if (f32Parms.fMessageActive & LOG_FS)
    456       Message("FS_FINDNEXT, level %u, cbData %u, MaxEntries %u", usLevel, cbData, *pcMatch);
     451   MessageL(LOG_FS, "FS_FINDNEXT%m, level %u, cbData %u, MaxEntries %u",
     452            0x0008, usLevel, cbData, *pcMatch);
    457453
    458454   usEntriesWanted = *pcMatch;
     
    596592FS_FINDNEXTEXIT:
    597593
    598    if (f32Parms.fMessageActive & LOG_FS)
    599       Message("FS_FINDNEXT returned %d (%d entries)",
    600          rc, *pcMatch);
     594   MessageL(LOG_FS, "FS_FINDNEXT%m returned %d (%d entries)",
     595            0x8008, rc, *pcMatch);
    601596
    602597   _asm pop es;
     
    682677                        rc = 1;
    683678
    684                   if (f32Parms.fMessageActive & LOG_FIND)
    685                      {
    686                      if (bCheck2 != bCheck1 && strlen(szLongName))
    687                         Message("Invalid LFN entry found: %s", szLongName);
    688                      }
     679                  if (bCheck2 != bCheck1 && strlen(szLongName))
     680                     MessageL(LOG_FIND, "Invalid LFN entry found%m: %s", 0x406e, szLongName);
    689681
    690682                  if (bCheck2 != bCheck1 ||
     
    739731                        rc = FSH_WILDMATCH(pFindInfo->pInfo->szSearch, szShortName);
    740732                     }
    741                   if (!rc && f32Parms.fMessageActive & LOG_FIND)
    742                      Message("%lu : %s, %s", pFindInfo->pInfo->ulCurEntry, szLongName, szShortName );
     733                  if (!rc)
     734                     MessageL(LOG_FIND, "%m %lu : %s, %s", 0x406f, pFindInfo->pInfo->ulCurEntry, szLongName, szShortName );
    743735
    744736                  if (!rc && usLevel == FIL_STANDARD)
     
    18431835int far pascal _loadds FS_FINDNOTIFYCLOSE( unsigned short usHandle)
    18441836{
    1845    if (f32Parms.fMessageActive & LOG_FS)
    1846       Message("FS_FINDNOTIFYCLOSE - NOT SUPPORTED");
     1837   MessageL(LOG_FS, "FS_FINDNOTIFYCLOSE%m - NOT SUPPORTED", 0x000a);
    18471838   return ERROR_NOT_SUPPORTED;
    18481839
     
    18671858)
    18681859{
    1869    if (f32Parms.fMessageActive & LOG_FS)
    1870       Message("FS_FINDNOTIFYFIRST - NOT SUPPORTED");
     1860   MessageL(LOG_FS, "FS_FINDNOTIFYFIRST%m - NOT SUPPORTED", 0x000b);
    18711861
    18721862   return ERROR_NOT_SUPPORTED;
     
    18971887)
    18981888{
    1899    if (f32Parms.fMessageActive & LOG_FS)
    1900       Message("FS_FINDNOTIFYNEXT - NOT SUPPORTED");
     1889   MessageL(LOG_FS, "FS_FINDNOTIFYNEXT%m - NOT SUPPORTED", 0x000c);
    19011890
    19021891   return ERROR_NOT_SUPPORTED;
  • trunk/src/ifs/ifslog.c

    r260 r296  
    1414#include "fat32ifs.h"
    1515
     16#include "infoseg.h"
     17
    1618#define LOGBUF_SIZE 8192
    1719
    1820#define serial_hw_port 0x3f8
     21
     22#define TRACE_MAJOR 254
     23
     24extern PGINFOSEG pGI;
    1925
    2026void serout(unsigned short port, char *s);
     
    2531static BYTE szLost[]="(information lost)\r\n";
    2632static ULONG ulLogSem = 0UL;
     33
     34APIRET trace(const char *fmt, va_list va);
    2735
    2836void (_far _cdecl *LogPrint)(char _far *fmt,...) = 0;
     
    6169static BOOL fWriteLogging(PSZ pszMessage);
    6270
    63 VOID cdecl _loadds Message(PSZ pszMessage, ...)
    64 {
    65 static char LogPrintInitted = 0;
     71VOID message(USHORT usLevel, PSZ pszMessage, va_list va)
     72{
     73static BOOL fLogPrintInitted = FALSE;
     74static BOOL fTraceInitted = FALSE;
     75static BOOL fTraceEnabled;
    6676static BYTE szMessage[512];
    67 va_list va;
     77va_list va2;
    6878PROCINFO Proc;
    6979ULONG ulmSecs = *pGITicks;
     
    7282   _asm push es;
    7383
    74    if (!f32Parms.fMessageActive)
    75       {
     84   if (! fTraceInitted)
     85      {
     86      fTraceEnabled = pGI->amecRAS[TRACE_MAJOR / 8] & (0x80 >> (TRACE_MAJOR % 8));
     87      }
     88   fTraceInitted = TRUE;
     89
     90   if (fTraceEnabled)
     91      {
     92      // output to trace buffer
     93      va_copy(va2, va);
     94      trace(pszMessage, va2);
     95      va_end(va2);
     96      }
     97
     98   if (!(f32Parms.fMessageActive & usLevel))
     99      {
     100      va_end(va);
    76101      _asm pop es;
    77102      return;
    78103      }
    79104
    80    if (! LogPrintInitted)
     105   if (! fLogPrintInitted)
    81106      {
    82107      LogPrintInit();
    83       LogPrintInitted = 1;
    84       }
    85 
    86    va_start(va, pszMessage);
     108      fLogPrintInitted = 1;
     109      }
    87110
    88111   FSH_QSYSINFO(2, (PBYTE)&Proc, sizeof Proc);
     
    98121   vsprintf(szMessage + strlen(szMessage), pszMessage, va);
    99122
    100    va_end(va);
    101 
    102123   // output to FAT32 log buffer
    103124   fWriteLogging(szMessage);
     
    109130
    110131   _asm pop es;
     132}
     133
     134VOID cdecl _loadds Message(PSZ pszMessage, ...)
     135{
     136va_list va;
     137
     138   va_start(va, pszMessage);
     139   message(0xffff, pszMessage, va);
     140   va_end(va);
     141}
     142
     143VOID cdecl _loadds MessageL(USHORT usLevel, PSZ pszMessage, ...)
     144{
     145va_list va;
     146
     147   va_start(va, pszMessage);
     148   message(usLevel, pszMessage, va);
     149   va_end(va);
    111150}
    112151
     
    259298  comout(port, '\n');
    260299}
     300
     301// accessing the system trace
     302APIRET trace(const char *fmt, va_list va)
     303{
     304static BOOL fInitted = FALSE;
     305static BOOL fTraceEnabled;
     306static char pData[512];
     307USHORT cbData = 0;
     308BOOL fLong, fLongLong;
     309USHORT minor = 0;
     310BYTE bToken;
     311char *p = (char *)fmt;
     312char *pBuf = pData;
     313char *pszValue;
     314APIRET rc;
     315
     316   if (! fInitted)
     317      {
     318      // check if tracing with TRACE_MAJOR is enabled
     319      fTraceEnabled = pGI->amecRAS[TRACE_MAJOR / 8] & (0x80 >> (TRACE_MAJOR % 8));
     320      }
     321   fInitted = TRUE;
     322
     323   if (! fTraceEnabled)
     324      return 0;
     325
     326   while (*p)
     327      {
     328      p = strchr(p, '%');
     329      if (!p)
     330         break;
     331      fLong = FALSE;
     332      fLongLong = FALSE;
     333      p++;
     334      if (*p == 'l')
     335         {
     336         if (p[1] == 'l')
     337            {
     338            fLongLong = TRUE;
     339            p += 2;
     340            }
     341         else
     342            {
     343            fLong = TRUE;
     344            p++;
     345            }
     346         }
     347      bToken = *p;
     348      if (*p)
     349         p++;
     350      switch (bToken)
     351         {
     352         case '%':
     353            *pBuf = '%';
     354            pBuf += sizeof(char);
     355            cbData += sizeof(char);
     356            break;
     357
     358         case 'c':
     359            *pBuf = (char)va_arg(va, USHORT);
     360            pBuf += sizeof(char);
     361            cbData += sizeof(char);
     362            break;
     363
     364         case 'm':
     365            // system trace minor ID
     366            minor = va_arg(va, USHORT);
     367            break;
     368
     369         case 's':
     370            pszValue = va_arg(va, char *);
     371            if (pszValue)
     372               {
     373               if (MY_PROBEBUF(PB_OPREAD, pszValue, 1))
     374                  pszValue = "(bad address)";
     375               }
     376            else
     377               pszValue = "(null)";
     378            strcpy(pBuf, pszValue);
     379            pBuf += strlen(pszValue) + 1;
     380            cbData += strlen(pszValue) + 1;
     381            break;
     382
     383         case 'u':
     384         case 'd':
     385         case 'x':
     386         case 'X':
     387            if (fLongLong)
     388               {
     389               *(ULONGLONG *)pBuf = va_arg(va, ULONGLONG);
     390               pBuf += sizeof(ULONGLONG);
     391               cbData += sizeof(ULONGLONG);
     392               }
     393            else if (fLong)
     394               {
     395               *(ULONG *)pBuf = va_arg(va, ULONG);
     396               pBuf += sizeof(ULONG);
     397               cbData += sizeof(ULONG);
     398               }
     399            else
     400               {
     401               *(USHORT *)pBuf = va_arg(va, USHORT);
     402               pBuf += sizeof(USHORT);
     403               cbData += sizeof(USHORT);
     404               }
     405            break;
     406         }
     407      }
     408
     409   if (minor)
     410      {
     411      rc = DevHelp_RAS(TRACE_MAJOR, minor, cbData, pData);
     412      }
     413
     414   return rc;
     415}
     416
     417APIRET Trace(const char *fmt, ...)
     418{
     419va_list va;
     420APIRET rc;
     421
     422   va_start(va, fmt);
     423   rc = trace(fmt, va);
     424   va_end(va);
     425   return rc;
     426}
  • trunk/src/ifs/ifsmem.c

    r284 r296  
    134134   }
    135135
    136    if (f32Parms.fMessageActive & LOG_MEM)
    137       Message("Malloc failed, calling gdtAlloc");
     136   MessageL(LOG_MEM, "Malloc failed, calling gdtAlloc%m", 0x4069);
    138137   pRet = gdtAlloc(tSize ? ( ULONG )tSize : 65536L, TRUE);
    139138
    140139malloc_exit:
    141140
    142    if (f32Parms.fMessageActive & LOG_MEM)
    143       Message("malloc %lu bytes at %lX", tSize ? ( ULONG )tSize : 65536L, pRet);
     141   MessageL(LOG_MEM, "malloc%m %lu bytes at %lX", 0x806a, tSize ? ( ULONG )tSize : 65536L, pRet);
    144142
    145143   ReleaseMemAccess();
     
    206204USHORT rc;
    207205
    208    if (f32Parms.fMessageActive & LOG_MEM)
    209       Message("free %lX", pntr);
     206   MessageL(LOG_MEM, "free%m %lX", 0x006c, pntr);
    210207
    211208   if (fRing3)
     
    334331    APIRET rc;
    335332
    336     if (f32Parms.fMessageActive & LOG_WAIT)
    337         Message("Waiting for a heap access");
     333    MessageL(LOG_WAIT, "Waiting for a heap access%m", 0x4070);
    338334
    339335    rc = FSH_SEMREQUEST(&ulMemSem,-1);
  • trunk/src/ifs/ifsmount.c

    r295 r296  
    9393   _asm sti;
    9494
    95    if (f32Parms.fMessageActive & LOG_FS)
    96       Message("FS_MOUNT for %c (%d):, flag = %d",
    97          pvpfsi->vpi_drive + 'A',
    98          pvpfsi->vpi_unit,
    99          usFlag);
     95   MessageL(LOG_FS, "FS_MOUNT%m for %c (%d):, flag = %d", 0x0001,
     96            pvpfsi->vpi_drive + 'A',
     97            pvpfsi->vpi_unit,
     98            usFlag);
    10099
    101100   switch (usFlag)
     
    124123            }
    125124
     125         Trace("tracepoint 1%m", 0x4071);
    126126         if (!hDupVBP)   /* initial mounting of the volume */
    127127            {
     
    142142            pVolInfo->bFatType = GetFatType(pSect);
    143143
     144            Trace("tracepoint 2%m", 0x4072);
    144145            if (pVolInfo->bFatType == FAT_TYPE_NONE)
    145146               {
     
    149150               }
    150151
     152            Trace("tracepoint 3%m", 0x4073);
    151153            if ( (pVolInfo->bFatType < FAT_TYPE_FAT32) &&
    152154                 ((! f32Parms.fFat) || ! (fat_mask & (1UL << pvpfsi->vpi_drive))) )
     
    157159               }
    158160
     161            Trace("tracepoint 4%m", 0x4074);
    159162            if ( (pVolInfo->bFatType == FAT_TYPE_FAT32) &&
    160163                 ! (fat32_mask & (1UL << pvpfsi->vpi_drive)) )
     
    166169
    167170#ifdef EXFAT
     171            Trace("tracepoint 5%m", 0x4075);
    168172            if ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) &&
    169173                 ((! f32Parms.fExFat) || ! (exfat_mask & (1UL << pvpfsi->vpi_drive))) )
     
    175179#endif
    176180
     181            Trace("tracepoint 6%m", 0x4076);
    177182            switch (pVolInfo->bFatType)
    178183               {
     
    207212               }
    208213
     214            Trace("tracepoint 7%m", 0x4077);
    209215            rc = FSH_FORCENOSWAP(SELECTOROF(pVolInfo));
    210216            if (rc)
     
    214220               goto FS_MOUNT_EXIT;
    215221               }
     222            Trace("tracepoint 8%m", 0x4078);
    216223            *((PVOLINFO *)pvpfsd->vpd_work) = pVolInfo;
    217224            *((ULONG *)pvpfsd->vpd_work + 1) = FAT32_VPB_MAGIC;
     
    219226            pVolInfo->pNextVolInfo = NULL;
    220227
     228            Trace("tracepoint 9%m", 0x4079);
    221229            if (!pGlobVolInfo)
    222230               {
     
    234242
    235243               // check for 0xf6 symbol (is the BPB erased?)
     244               Trace("tracepoint a%m", 0x407a);
    236245               for (i = 0; i < sizeof(BOOTSECT0); i++)
    237246                  {
     
    240249                  }
    241250
     251               Trace("tracepoint b%m", 0x407b);
    242252               if (i == sizeof(BOOTSECT0))
    243253                  {
     
    253263                  }
    254264
     265               Trace("tracepoint c%m", 0x407c);
    255266               if (i == sizeof(BOOTSECT0))
    256267                  {
     
    278289                  }
    279290
     291               Trace("tracepoint d%m", 0x407d);
    280292               if (! fValidBoot)
    281293                  {
     
    285297                  }
    286298
     299               Trace("tracepoint e%m", 0x407e);
    287300               if (! fNewBoot)
    288301                  {
     
    291304                  }
    292305
     306               Trace("tracepoint f%m", 0x407f);
    293307               if (pVolInfo->bFatType < FAT_TYPE_FAT32)
    294308                  {
     
    431445                     }
    432446
     447                     Trace("tracepoint 10%m", 0x4080);
    433448                     if (fValidBoot)
    434449                        {
     
    441456               else if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    442457                  {
     458                     Trace("tracepoint 11%m", 0x4081);
    443459                     if (fValidBoot)
    444460                        {
     
    452468               else if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    453469                  {
     470                     Trace("tracepoint 12%m", 0x4082);
    454471                     if (fValidBoot)
    455472                        {
     
    469486            for the n-th remount it's a reinitialization of the old VPB
    470487         */
     488         Trace("tracepoint 13%m", 0x4083);
    471489         memcpy(&pVolInfo->BootSect, pSect, sizeof (BOOTSECT));
    472490
     
    480498#endif
    481499
     500         Trace("tracepoint 14%m", 0x4084);
    482501#ifdef EXFAT
    483502         if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     
    500519            }
    501520
     521         Trace("tracepoint 15%m", 0x4085);
    502522         pVolInfo->pBootFSInfo = (PBOOTFSINFO)(pVolInfo + 1);
    503523         pVolInfo->pbFatSector = (PBYTE)(pVolInfo->pBootFSInfo + 1);
     
    505525         pVolInfo->pbFatBits = (PBYTE)pVolInfo->pbFatSector + SECTOR_SIZE * 8 * 3;
    506526         
     527         Trace("tracepoint 16%m", 0x4086);
    507528#ifdef EXFAT
    508529         if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
     
    537558
    538559         // size of a subcluster block
     560         Trace("tracepoint 17%m", 0x4087);
    539561         pVolInfo->ulBlockSize = min(pVolInfo->ulClusterSize, 32768UL);
    540562
     
    548570         pVolInfo->fFormatInProgress = FALSE;
    549571
     572         Trace("tracepoint 18%m", 0x4088);
    550573         if (usDefaultRASectors == 0xFFFF)
    551574            pVolInfo->usRASectors = (USHORT)(pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 2;
     
    561584#endif
    562585
     586         Trace("tracepoint 19=%m", 0x4089);
    563587         if (pVolInfo->bFatType == FAT_TYPE_FAT32 && pSect->bpb.FSinfoSec != 0xFFFF)
    564588            {
     
    569593            memset(pVolInfo->pBootFSInfo, 0, sizeof (BOOTFSINFO));
    570594
     595         Trace("tracepoint 1a%m", 0x408a);
    571596         if (pVolInfo->bFatType < FAT_TYPE_FAT32)
    572597            {
     
    590615            pVolInfo->BootSect.bpb.FSinfoSec = 0xFFFF;
    591616            }
     617         Trace("tracepoint 1b%m", 0x408b);
    592618         if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    593619            {
     
    608634               }
    609635
     636         Trace("tracepoint 1c%m", 0x408c);
    610637#ifdef INCL_LONGLONG
    611638            pVolInfo->BootSect.bpb.BigTotalSectors = (ULONG)((PBOOTSECT1)pSect)->ullVolumeLength; ////
     
    622649         pVolInfo->BootSect.ulVolSerial = pvpfsi->vpi_vid;
    623650
     651         Trace("tracepoint 1d%m", 0x408d);
    624652         if (! pVolInfo->BootSect.bpb.BigSectorsPerFat)
    625653            // if partition is small
    626654            pVolInfo->BootSect.bpb.BigSectorsPerFat = pVolInfo->BootSect.bpb.SectorsPerFat;
    627655
     656         Trace("tracepoint 1e%m", 0x408e);
    628657         pVolInfo->ulTotalClusters =
    629658            (pVolInfo->BootSect.bpb.BigTotalSectors - pVolInfo->ulStartOfData) / pVolInfo->SectorsPerCluster;
    630659
     660         Trace("tracepoint 1f%m", 0x408f);
    631661         if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    632662            {
     
    667697#endif
    668698
     699         Trace("tracepoint 20%m", 0x4090);
    669700         if (fValidBoot)
    670701            {
     
    672703            USHORT usSize = 11;
    673704
     705            Trace("tracepoint 21%m", 0x4091);
    674706            memset(pszVolLabel, 0, sizeof(pszVolLabel));
    675707            memset(pvpfsi->vpi_text, 0, sizeof(pvpfsi->vpi_text));
    676708
     709            Trace("tracepoint 22%m", 0x4092);
    677710            fGetSetVolLabel(pVolInfo, INFO_RETRIEVE, pszVolLabel, &usSize);
    678711            // prevent writing the FSInfo sector in pVolInfo->pbFatSector buffer
     
    681714            pVolInfo->ulCurFatSector = 0xffff;
    682715
     716            Trace("tracepoint 23%m", 0x4093);
    683717            if (! pszVolLabel || ! *pszVolLabel)
    684718               strcpy(pvpfsi->vpi_text, "UNLABELED  ");
     
    686720               strcpy(pvpfsi->vpi_text, pszVolLabel);
    687721           
     722            Trace("tracepoint 24%m", 0x4094);
    688723            memset(pVolInfo->BootSect.VolumeLabel, 0, sizeof(pVolInfo->BootSect.VolumeLabel));
    689724            memcpy(pVolInfo->BootSect.VolumeLabel, pvpfsi->vpi_text, sizeof(pVolInfo->BootSect.VolumeLabel));
    690725            }
    691726
     727         Trace("tracepoint 25%m", 0x4095);
    692728         rc = CheckWriteProtect(pVolInfo);
    693729         if (rc && rc != ERROR_WRITE_PROTECT)
     
    696732            goto FS_MOUNT_EXIT;
    697733            }
     734         Trace("tracepoint 26%m", 0x4096);
    698735         if (rc == ERROR_WRITE_PROTECT)
    699736            pVolInfo->fWriteProtected = TRUE;
    700737
     738         Trace("tracepoint 27%m", 0x4097);
    701739         if (f32Parms.fCalcFree ||
    702740            pVolInfo->pBootFSInfo->ulFreeClusters == 0xFFFFFFFF ||
     
    707745            }
    708746
     747         Trace("tracepoint 28%m", 0x4098);
    709748         pDevCaps  = pvpfsi->vpi_pDCS;
    710749         pVolChars = pvpfsi->vpi_pVCS;
     
    716755         //   }
    717756
     757         Trace("tracepoint 29%m", 0x4099);
    718758         if ( pVolChars && (pVolChars->VolDescriptor & VC_REMOVABLE_MEDIA) )
    719759            pVolInfo->fRemovable = TRUE;
    720760
     761         Trace("tracepoint 2a%m", 0x409a);
    721762         if (! pVolInfo->fRemovable)
    722763            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = GetDiskStatus(pVolInfo);
     
    725766            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = TRUE;
    726767
     768         Trace("tracepoint 2b%m", 0x409b);
    727769         if (!pVolInfo->fDiskCleanOnMount && f32Parms.fMessageActive & LOG_FS)
    728770            Message("DISK IS DIRTY!");
    729771
     772         Trace("tracepoint 2c%m", 0x409c);
    730773         if (pVolInfo->fWriteProtected)
    731774            pVolInfo->fDiskCleanOnMount = TRUE;
    732775
     776         Trace("tracepoint 2d%m", 0x409d);
    733777         if (pDevCaps && f32Parms.fMessageActive & LOG_FS)
    734778            {
     
    749793            }
    750794
     795         Trace("tracepoint 2e%m", 0x409e);
    751796         if (pDevCaps && pDevCaps->Strategy2)
    752797            {
     
    761806            }
    762807
     808         Trace("tracepoint 2f%m", 0x409f);
    763809         rc = 0;
    764810         break;
     
    926972
    927973FS_MOUNT_EXIT:
    928    if (f32Parms.fMessageActive & LOG_FS)
    929       Message("FS_MOUNT returned %u\n", rc);
     974   MessageL(LOG_FS, "FS_MOUNT%m returned %u", 0x8001, rc);
    930975
    931976   _asm pop es;
     
    942987USHORT usSectors = 1;
    943988
    944    if (f32Parms.fMessageActive & LOG_FUNCS)
    945       Message("CheckWriteProtect");
     989   MessageL(LOG_FUNCS, "CheckWriteProtect%m", 0x0100);
    946990
    947991   rc = FSH_DOVOLIO(DVIO_OPREAD, DVIO_ALLACK, pVolInfo->hVBP, pVolInfo->pbFatSector, &usSectors, 1L);
     
    10201064      return FAT_TYPE_FAT12;
    10211065
    1022    // a two-byte JMP instruction (opcode 0xeb) and one-byte
    1023    // NOP instruction (opcode 0x90) are mandatory before the BPB
    1024    if (pSect->bJmp[0] != 0xeb || pSect->bJmp[2] != 0x90)
    1025       {
    1026       return FAT_TYPE_NONE;
    1027       } /* endif */
    1028 
    10291066#ifdef EXFAT
    10301067   if (!memcmp(pSect->oemID, "EXFAT   ", 8))
     
    10401077      return FAT_TYPE_NONE;
    10411078      }
    1042 
    1043    //if (pbpb->BytesPerSector != SECTOR_SIZE)
    1044    //   {
    1045    //   return FAT_TYPE_NONE;
    1046    //   }
    10471079
    10481080   if (! pbpb->SectorsPerCluster)
     
    11441176    return d;
    11451177}
     1178
     1179#if 0
    11461180
    11471181#pragma optimize("eglt",off)
     
    12071241
    12081242#pragma optimize("",on)
     1243
     1244#endif
  • trunk/src/ifs/ifsswap.c

    r295 r296  
    6565   _asm push es;
    6666
    67    if (f32Parms.fMessageActive & LOG_FS)
    68       Message("FS_OPENPAGEFILE  pName=%s OpenMode=%x, OpenFlag=%x Attr=%x",
    69               pName, OpenMode, OpenFlag, Attr);
     67   MessageL(LOG_FS, "FS_OPENPAGEFILE%m  pName=%s OpenMode=%x, OpenFlag=%x Attr=%x",
     68            0x0002, pName, OpenMode, OpenFlag, Attr);
    7069
    7170   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    119118      *pcMaxReq = MAXPGREQ;
    120119
    121       //if ((*pFlags & PGIO_FIRSTOPEN) && (swap_open_count == 1))
    122       //   {
    123       //   // make swap file zero-aligned
    124       //   rc = FS_NEWSIZEL (psffsi, psffsd, 0LL, 0);
    125 
    126       //   if (rc)
    127       //      {
    128       //      goto FS_OPENPAGEFILE_EXIT;
    129       //      }
    130       //   }
     120      if (*pFlags & PGIO_FIRSTOPEN)
     121         {
     122         // make swap file zero-aligned
     123         rc = FS_NEWSIZEL (psffsi, psffsd, 0LL, 0x10);
     124
     125         if (rc)
     126            {
     127            goto FS_OPENPAGEFILE_EXIT;
     128            }
     129         }
    131130      }
    132131
    133132FS_OPENPAGEFILE_EXIT:
    134    if (f32Parms.fMessageActive & LOG_FS)
    135       Message("FS_OPENPAGEFILE returned %u\n", rc);
     133   MessageL(LOG_FS, "FS_OPENPAGEFILE%m returned %u\n", 0x8002, rc);
    136134
    137135   _asm pop es;
     
    163161   _asm push es;
    164162
    165    if (f32Parms.fMessageActive & LOG_FS)
    166       Message("FS_ALLOCATEPAGESPACE  size=%lu contig=%lu", ulSize, ulWantContig);
     163   MessageL(LOG_FS, "FS_ALLOCATEPAGESPACE%m  size=%lu contig=%lu", 0x0003, ulSize, ulWantContig);
    167164
    168165   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    186183      }
    187184
    188    rc = FS_NEWSIZEL(psffsi, psffsd, ullSize, 0x20);
     185   rc = FS_NEWSIZEL(psffsi, psffsd, ullSize, 0x10);
    189186
    190187   if (rc == 0)
     
    203200
    204201FS_ALLOCATEPAGESPACE_EXIT:
    205    if (f32Parms.fMessageActive & LOG_FS)
    206       Message("FS_ALLOCATEPAGESPACE returned %u\n", rc);
     202   MessageL(LOG_FS, "FS_ALLOCATEPAGESPACE%m returned %u\n", 0x8003, rc);
    207203
    208204   _asm pop es;
     
    232228   _asm push es;
    233229
    234    if (f32Parms.fMessageActive & LOG_FS)
    235       Message("FS_DOPAGEIO\n");
     230   MessageL(LOG_FS, "FS_DOPAGEIO%m\n", 0x0004);
    236231
    237232   /* Serialize on the swap file inode.
     
    403398
    404399FS_DOPAGEIO_EXIT:
    405    if (f32Parms.fMessageActive & LOG_FS)
    406       Message("FS_DOPAGEIO returned %u\n", rc);
     400   MessageL(LOG_FS, "FS_DOPAGEIO%m returned %u\n", 0x8004, rc);
    407401
    408402   //IWRITE_UNLOCK(ip);
     
    479473   if (f32Parms.fMessageActive & LOG_FS && pgreq->pr_hdr.Count)
    480474      Message("vCallStrategy2 drive %c:, %lu sectors",
    481          pgreq->pr_hdr.Block_Dev_Unit + 'A',
    482          pgreq->pr_hdr.Count);
     475              pgreq->pr_hdr.Block_Dev_Unit + 'A',
     476              pgreq->pr_hdr.Count);
    483477
    484478   if (!pgreq->pr_hdr.Count)
  • trunk/src/ifs/makefile.wcc

    r295 r296  
    33PATH=..\..\$(PROJ)
    44DIRS=..\include libc
    5 TARGETS=$(BINROOT)\os2\boot\fat32.ifs $(BINROOT)\os2\boot\fat32.sym
     5TARGETS=$(BINROOT)\os2\boot\fat32.ifs $(BINROOT)\os2\boot\fat32.sym &
     6        $(BINROOT)\os2\system\trace\trc00fe.tff
    67
    78!include ..\makefile.mk
     
    4243     $(PROJ_BLD)\ifsachk.obj &
    4344     $(PROJ_BLD)\helpers.obj
     45
     46$(BINROOT)\os2\system\trace\trc00fe.tff:
    4447
    4548$(BINROOT)\os2\boot\fat32.ifs:
     
    211214 @echo CC       $^.
    212215 @wcc386 $(COPT32) -fr=$^*.err -fo=$^@ $<
     216
     217
     218$(BINROOT)\os2\system\trace\trc00fe.tff: fat32.tsf
     219 @echo TRCUST   $^.
     220 @trcust $[@ >nul 2>&1
     221 @copy trc00fe.tff $^@ >nul 2>&1
     222 @del $^. >nul 2>&1
  • trunk/src/include/fat32ifs.h

    r260 r296  
    367367IMPORT USHORT GetProcInfo(PPROCINFO pProcInfo, USHORT usSize);
    368368IMPORT VOID cdecl _loadds Message(PSZ pszMessage, ...);
     369IMPORT VOID cdecl _loadds MessageL(USHORT usLevel, PSZ pszMessage, ...);
     370IMPORT APIRET Trace(const char *fmt, ...);
    369371IMPORT USHORT cdecl CritMessage(PSZ pszMessage, ...);
    370372IMPORT VOID cdecl FatalMessage(PSZ pszMessage, ...);
  • trunk/src/makefile.mk

    r272 r296  
    1010BLDDIRS  = $(BINROOT) $(BLDROOT) $(LIBROOT) &
    1111           $(BINROOT)\os2 $(BINROOT)\os2\boot $(BINROOT)\os2\dll &
     12           $(BINROOT)\os2\system $(BINROOT)\os2\system\trace &
    1213           $(BINROOT)\os2\book $(BINROOT)\os2\docs $(BINROOT)\os2\docs\fat32 &
    1314           $(BLDROOT)\util $(BLDROOT)\ifs $(BLDROOT)\ifs\libc $(BLDROOT)\partfilt $(BLDROOT)\ifsinf &
     
    6566
    6667sym      = &
    67  boot\fat32.sym dll\uunifat.sym &
     68 boot\fat32.sym system\trace\trc00fe.tff dll\uunifat.sym &
    6869 cachef32.sym f32parts.sym f32mon.sym &
    6970 f32stat.sym f32chk.sym fat32chk.sym fat32fmt.sym fat32sys.sym
     
    7778distlist = &
    7879!ifeq ROOT . # don't include autogenerated files to this list if make is run from a non-root
    79  $(p)os2\boot\fat32.ifs $(p)os2\boot\fat32.sym &
     80 $(p)os2\boot\fat32.ifs $(p)os2\boot\fat32.sym $(p)os2\system\trace\trc00fe.tff &
    8081 $(p)os2\boot\partfilt.flt $(p)os2\boot\partfilt.sym &
    8182 $(p)os2\dll\ufat32.dll $(p)os2\dll\uunifat.sym &
     
    146147
    147148.SUFFIXES:
    148 .SUFFIXES: .flt .ifs .dll .exe .lib .lnk .ols .obc .obd .obj .cpp .c .c16 .h .asm .sym .map .wmp .inf .ipf .bmp
     149.SUFFIXES: .tff .tsf .flt .ifs .dll .exe .lib .lnk .ols .obc .obd .obj .cpp .c .c16 .h .asm .sym .map .wmp .inf .ipf .bmp
    149150
    150151all: $(BLDROOT)\bld.flg $(PROJ_BLD)\makefile.wcc dirs copy targets &
Note: See TracChangeset for help on using the changeset viewer.