Changeset 295


Ignore:
Timestamp:
Jul 19, 2017, 9:01:49 PM (3 years ago)
Author:
Valery V. Sedletski
Message:
  • Disable Lars Erdman's code for searching DevCaps? and Strat2 routine if it is normally not found. This found strat2 even in case no strat2 is presented by the disk driver (like hd4disk.add with an "/1" parameter).
  • Consider using fSilent flag when loading Unicode Translate Table, instead of being always verbose.
  • Set pVolInfo->fDiskClean to FALSE in WriteSector? if Dirty flag in the 1th FAT element is set to not do it on every WriteSector? call.
  • Swapping code updates
  • FS_FILEIO implementation


Location:
trunk/src
Files:
8 edited

Legend:

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

    r291 r295  
    1616
    1717PUBLIC BYTE  pascal FS_NAME[8]    ="FAT32";
    18 PUBLIC ULONG pascal FS_ATTRIBUTE = FSA_LVL7;
     18PUBLIC ULONG pascal FS_ATTRIBUTE = FSA_LVL7 | FSA_LOCK;
    1919
    2020PUBLIC ULONG     Device_Help = 0L;
     
    927927   if (rc)
    928928      goto FS_FLUSHEXIT;
    929 
    930    if (!f32Parms.usDirtySectors) // vs
    931       goto FS_FLUSHEXIT;         //
    932929
    933930   if (!UpdateFSInfo(pVolInfo))
     
    37733770           pVolInfo = (PVOLINFO)pVolInfo->pNextVolInfo)
    37743771         {
     3772            Message("disk: %c: fDiskCleanOnMount=%u",
     3773               pVolInfo->bDrive + 'a', pVolInfo->fDiskCleanOnMount);
     3774
    37753775            if (pVolInfo->fWriteProtected)
    37763776               continue;
     
    37803780
    37813781            usFlushVolume( pVolInfo, FLUSH_DISCARD, TRUE, PRIO_URGENT );
    3782 
    3783             //if (!f32Parms.usDirtySectors)
    3784             //   continue;
    37853782
    37863783            UpdateFSInfo(pVolInfo);
     
    69986995   pVolInfo = pVolInfo;
    69996996
    7000    Message("GetFatAccess: %s", pszName);
     6997   //Message("GetFatAccess: %s", pszName);
    70016998   rc = SemRequest(&ulSemRWFat, TO_INFINITE, pszName);
    70026999   if (rc)
     
    70137010{
    70147011   pVolInfo = pVolInfo;
    7015    Message("ReleaseFat");
     7012   //Message("ReleaseFat");
    70167013   FSH_SEMCLEAR(&ulSemRWFat);
    70177014}
  • trunk/src/ifs/ifscache.c

    r291 r295  
    373373
    374374   if (pVolInfo->fDiskClean)
     375      {
    375376      MarkDiskStatus(pVolInfo, FALSE);
     377      pVolInfo->fDiskClean = FALSE;
     378      }
    376379
    377380   if (ulSector + nSectors - 1 >= pVolInfo->BootSect.bpb.BigTotalSectors)
  • trunk/src/ifs/ifsfile.c

    r291 r295  
    40744074    struct sffsi far * psffsi,      /* psffsi   */
    40754075    struct sffsd far * psffsd,      /* psffsd   */
    4076     char far * cbCmdList,           /* cbCmdList    */
    4077     unsigned short pCmdLen,     /* pCmdLen  */
     4076    char far * pCmdList,            /* cbCmdList    */
     4077    unsigned short cbCmdList,       /* pCmdLen  */
    40784078    unsigned short far * poError,   /* poError  */
    4079     unsigned short IOFlag       /* IOflag   */
     4079    unsigned short IOFlag           /* IOflag   */
    40804080)
    40814081{
     4082struct CmdIO     *io_cmd;               /* ptr to IO cmd structure   */
     4083struct CmdSeek   *seek_cmd;             /* ptr to seek cmd struct    */
     4084struct CmdLock   *lock_cmd;             /* ptr to lock cmd struct    */
     4085struct CmdUnLock *unlock_cmd;           /* ptr to unlock cmd struct  */
     4086UCHAR    *curr_cmd;                     /* ptr to current command    */
     4087void far *user_buffer;                  /* flat ptr to user buffer   */
     4088USHORT buffer_len;
     4089struct filelockl LockRange;
     4090struct filelockl UnLockRange;
     4091APIRET rc;
     4092short error;
     4093int i;
     4094
     4095   _asm push es;
     4096
    40824097   if (f32Parms.fMessageActive & LOG_FS)
    4083       Message("FS_FILEIO - NOT SUPPORTED");
    4084    return ERROR_NOT_SUPPORTED;
    4085 
    4086    psffsi = psffsi;
    4087    psffsd = psffsd;
    4088    cbCmdList = cbCmdList;
    4089    pCmdLen = pCmdLen;
    4090    poError = poError;
    4091    IOFlag = IOFlag;
     4098      Message("FS_FILEIO");
     4099
     4100   //if (cbCmdList > 256)
     4101   //   {
     4102   //   /* Expensive system call, so only lock if its a large list */
     4103   //   rc = FSH_FORCENOSWAP(SELECTOROF(pCmdList));
     4104   //   if (rc != NO_ERROR)
     4105   //      {
     4106   //      error = 0;
     4107   //      *poError = error;
     4108   //      goto FS_FILEIO_EXIT;
     4109   //      }
     4110   //   }
     4111   //else
     4112   //   {
     4113      /* copy entire command list to kernel mem so we don't have to keep doing */
     4114      /* verify access calls                                                   */
     4115      rc = MY_PROBEBUF(PB_OPREAD, pCmdList, cbCmdList);
     4116   //   }
     4117
     4118   curr_cmd = pCmdList;
     4119
     4120   while ((rc == 0) && ((ULONG)curr_cmd < ((ULONG)pCmdList + cbCmdList)))
     4121      {
     4122      switch ((USHORT)*curr_cmd)
     4123         {
     4124         case FILEIO_LOCK:
     4125            {
     4126            struct Lock *lock = (struct Lock *)(curr_cmd + sizeof(struct CmdLock));
     4127            lock_cmd = (struct CmdLock *) curr_cmd;
     4128
     4129            for (i = 0; i < lock_cmd->LockCnt; i++, lock++)
     4130               {
     4131               LockRange.FileOffset  = lock->Start;
     4132               LockRange.RangeLength = lock->Length;
     4133
     4134               rc = FS_FILELOCKSL(psffsi,
     4135                                  psffsd,
     4136                                  NULL,
     4137                                  &LockRange,
     4138                                  lock_cmd->TimeOut,
     4139                                  lock->Share);
     4140               if (rc)
     4141                  break;
     4142               }
     4143            curr_cmd += (sizeof(struct CmdLock) +
     4144                        (lock_cmd->LockCnt * sizeof(struct Lock)));
     4145            }
     4146            break;
     4147         case FILEIO_UNLOCK:
     4148            {
     4149            struct UnLock *unlock = (struct UnLock *)(curr_cmd + sizeof(struct CmdUnLock));
     4150            unlock_cmd = (struct CmdUnLock *) curr_cmd;
     4151
     4152            for (i = 0; i < unlock_cmd->UnlockCnt; i++, unlock++)
     4153               {
     4154               UnLockRange.FileOffset  = unlock->Start;
     4155               UnLockRange.RangeLength = unlock->Length;
     4156
     4157               rc = FS_FILELOCKSL(psffsi,
     4158                                  psffsd,
     4159                                  &UnLockRange,
     4160                                  NULL,
     4161                                  0,
     4162                                  0);
     4163               if (rc)
     4164                  break;
     4165               }
     4166            curr_cmd += (sizeof(struct CmdUnLock) +
     4167                        (unlock_cmd->UnlockCnt * sizeof(struct UnLock)));
     4168            }
     4169            break;
     4170         case FILEIO_READ:
     4171            io_cmd = (struct CmdIO *) curr_cmd;
     4172            /* fs_read take an address of ulong for buffer size so   */
     4173            /* we need to copy the ushort from params to ulong       */
     4174            buffer_len  = io_cmd->BufferLen;
     4175            user_buffer = io_cmd->Buffer ;
     4176            rc = FS_READ(psffsi, psffsd, user_buffer, &buffer_len, IOFlag);
     4177            /* put the actual byte return field */
     4178            io_cmd->Actual = (USHORT) buffer_len;
     4179            /* move to next cmd */
     4180            curr_cmd += sizeof(struct CmdIO);
     4181            break;
     4182         case FILEIO_WRITE:
     4183            io_cmd = (struct CmdIO *) curr_cmd;
     4184            /* fs_write take an address of ulong for buffer size so  */
     4185            /* we need to copy the ushort from params to ulong       */
     4186            buffer_len  = io_cmd->BufferLen;
     4187            user_buffer = io_cmd->Buffer;
     4188            rc = FS_WRITE(psffsi, psffsd, user_buffer, &buffer_len, IOFlag);
     4189            /* put the actual byte return field */
     4190            io_cmd->Actual = (USHORT) buffer_len;
     4191            /* move to next cmd */
     4192            curr_cmd += sizeof(struct CmdIO);
     4193            break;
     4194         case FILEIO_SEEK:
     4195            seek_cmd = (struct CmdSeek *) curr_cmd;
     4196            rc = FS_CHGFILEPTRL(psffsi, psffsd, (long long)seek_cmd->Position,
     4197                                seek_cmd->Method, IOFlag);
     4198            if (!rc)
     4199               {
     4200               seek_cmd->Actual = seek_cmd->Position;
     4201               }
     4202            curr_cmd += sizeof(struct CmdSeek);
     4203            break;
     4204         default:
     4205            rc = ERROR_INVALID_PARAMETER;
     4206            break;
     4207
     4208         } /* end switch */
     4209      } /* end while */
     4210
     4211   if (rc)  /* if error occurred, update error pointer */
     4212      {
     4213      error = curr_cmd - pCmdList;
     4214      *poError = error;
     4215      }
     4216
     4217   //if (cbCmdList > 256)
     4218   //   {
     4219   //   rc2 = KernVMUnlock(&lockHandle);
     4220   //   ASSERT(rc2 == 0);
     4221   //   }
     4222   //else
     4223   //   {
     4224   //   /* Some fields (Actual) may have changed, so copy back to user's buffer */
     4225   //   (void) KernCopyOut(pCmdList, cmd_list, cbCmdList);
     4226   //   }
     4227
     4228//FS_FILEIO_EXIT:
     4229   if (f32Parms.fMessageActive & LOG_FS)
     4230      Message("FS_FILEIO returned %u", rc);
     4231
     4232   _asm pop es;
     4233
     4234   return rc;
    40924235}
    40934236
  • trunk/src/ifs/ifsmount.c

    r280 r295  
    710710         pVolChars = pvpfsi->vpi_pVCS;
    711711
    712          if (!pDevCaps)
    713             {
    714             Message("Strategy2 not found, searching Device Driver chain !");
    715             pDevCaps = ReturnDriverCaps(pvpfsi->vpi_unit);
    716             }
     712         //if (!pDevCaps)
     713         //   {
     714         //   Message("Strategy2 not found, searching Device Driver chain !");
     715         //   pDevCaps = ReturnDriverCaps(pvpfsi->vpi_unit);
     716         //   }
    717717
    718718         if ( pVolChars && (pVolChars->VolDescriptor & VC_REMOVABLE_MEDIA) )
     
    731731            pVolInfo->fDiskCleanOnMount = TRUE;
    732732
    733          if (f32Parms.fMessageActive & LOG_FS)
     733         if (pDevCaps && f32Parms.fMessageActive & LOG_FS)
    734734            {
    735735            if (pDevCaps->Capabilities & GDC_DD_Read2)
     
    749749            }
    750750
    751          if (pDevCaps->Strategy2)
     751         if (pDevCaps && pDevCaps->Strategy2)
    752752            {
    753753            if (f32Parms.fMessageActive & LOG_FS)
     
    841841         pVolChars = pvpfsi->vpi_pVCS;
    842842
    843          if (!pDevCaps)
    844             {
    845             Message("Strategy2 not found, searching Device Driver chain !");
    846             pDevCaps = ReturnDriverCaps(pvpfsi->vpi_unit);
    847             }
    848 
    849          if (f32Parms.fMessageActive & LOG_FS)
     843         //if (!pDevCaps)
     844         //   {
     845         //   Message("Strategy2 not found, searching Device Driver chain !");
     846         //   pDevCaps = ReturnDriverCaps(pvpfsi->vpi_unit);
     847         //   }
     848
     849         if (pDevCaps && f32Parms.fMessageActive & LOG_FS)
    850850            {
    851851            if (pDevCaps->Capabilities & GDC_DD_Read2)
     
    865865            }
    866866
    867          if (pDevCaps->Strategy2)
     867         if (pDevCaps && pDevCaps->Strategy2)
    868868            {
    869869            if (f32Parms.fMessageActive & LOG_FS)
  • trunk/src/ifs/ifsswap.c

    r291 r295  
    1515#include "fat32ifs.h"
    1616
    17 VOID vCallStrategy2(PVOLINFO pVolInfo, RQLIST far *pRQ);
     17VOID vCallStrategy2(PVOLINFO pVolInfo, struct pagereq far *pgreq);
    1818ULONG PositionToOffset(PVOLINFO pVolInfo, POPENINFO pOpenInfo, LONGLONG llOffset);
    1919int GetBlockNum(PVOLINFO pVolInfo, POPENINFO pOpenInfo, ULONG ulOffset, PULONG pulBlkNo);
     20void pageIOdone(struct pagereq far * prp);
    2021
    2122#define PSIZE           4096
    22 #define MAXPGREQ        16 // 8
    23 
    24 // swap file open count
    25 USHORT swap_open_count = 0;
     23#define MAXPGREQ        16
     24
    2625// hVPB of volume with a swap file
    2726unsigned short swap_hVPB = 0;
    2827
    29 RQLIST pgreq;
    30 
    31 //static ULONG ulSemRWSwap = 0;
     28/* Request list to be passed to the driver's strategy2 routine.
     29 */
     30struct pagereq
     31{
     32   Req_List_Header pr_hdr;     /* 20: */
     33   struct _pr_list
     34   {
     35      PB_Read_Write pr_rw;     /* 52: */
     36      SG_Descriptor pr_sg;     /* 8: */
     37   } pr_list[MAXPGREQ];        /* 480: (60*8) */
     38};                             /* (500) */
     39
     40struct pagereq pgreq;
     41
     42static ULONG ulSemRWSwap = 0;
    3243
    3344
     
    5263   PVOLINFO        pVolInfo;
    5364
     65   _asm push es;
     66
    5467   if (f32Parms.fMessageActive & LOG_FS)
    5568      Message("FS_OPENPAGEFILE  pName=%s OpenMode=%x, OpenFlag=%x Attr=%x",
    5669              pName, OpenMode, OpenFlag, Attr);
    57 
    58    _asm push es;
    5970
    6071   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    91102   if (rc == 0)
    92103      {
    93       swap_open_count++;
    94 
    95       //if (pVolInfo->pfnStrategy)
    96       //   {
    97       //      /*   Strat2 is supported.
    98       //       *   set return information:
    99       //       *   pageio requests require physical addresses;
    100       //       *   maximum request is 16 pages;
    101       //       */
    102       //      *pFlags |= PGIO_PADDR;
    103       //      *pcMaxReq = MAXPGREQ;
    104       //   }
    105       //else
    106       //   {
    107       //      // no Strat2
     104      if (pVolInfo->pfnStrategy)
     105         {
     106            /*   Strat2 is supported.
     107             *   set return information:
     108             *   pageio requests require physical addresses;
     109             *   maximum request is 16 pages;
     110             */
     111            *pFlags |= PGIO_PADDR;
     112         }
     113      else
     114         {
     115            // no Strat2
    108116            *pFlags |= PGIO_VADDR;
    109             *pcMaxReq = 0;
    110       //   }
     117         }
     118
     119      *pcMaxReq = MAXPGREQ;
    111120
    112121      //if ((*pFlags & PGIO_FIRSTOPEN) && (swap_open_count == 1))
     
    152161#endif
    153162
     163   _asm push es;
     164
    154165   if (f32Parms.fMessageActive & LOG_FS)
    155166      Message("FS_ALLOCATEPAGESPACE  size=%lu contig=%lu", ulSize, ulWantContig);
    156 
    157    _asm push es;
    158167
    159168   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    177186      }
    178187
    179    rc = FS_NEWSIZEL(psffsi, psffsd, ullSize, 0x10);
     188   rc = FS_NEWSIZEL(psffsi, psffsd, ullSize, 0x20);
    180189
    181190   if (rc == 0)
     
    213222   POPENINFO       pOpenInfo;
    214223   PVOLINFO        pVolInfo;
    215    //ULONG           ulStartCluster;
    216224   ULONG           fsbno;  /* starting block number to read/write */
    217225   struct PageCmd  *pgcmd; /* pointer to current command in list */
     
    219227   Req_Header      *rhp;   /* pointer to request header */
    220228   PB_Read_Write   *rwp;   /* pointer to request */
    221    int i, rc = NO_ERROR;
     229   int i, j, rc = NO_ERROR;
     230   USHORT usSectors;
     231
     232   _asm push es;
    222233
    223234   if (f32Parms.fMessageActive & LOG_FS)
    224235      Message("FS_DOPAGEIO\n");
    225236
    226    _asm push es;
    227 
    228    //FSH_SEMREQUEST(&ulSemRWSwap, TO_INFINITE);
     237   /* Serialize on the swap file inode.
     238    */
     239   //IWRITE_LOCK(ip);
    229240
    230241   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     
    243254
    244255   pOpenInfo = GetOpenInfo(psffsd);
    245    //ulStartCluster = pOpenInfo->pSHInfo->ulStartCluster;
    246 
    247    memset(&pgreq, 0, sizeof(pgreq));
    248 
    249    rlhp = &pgreq.rlh;
    250    rlhp->Count = pPageCmdList->OpCount;
    251    rlhp->Notify_Address = 0; //(PVOID)rlhNotify;
    252    rlhp->Request_Control = 0; //(pPageCmdList->InFlags & PGIO_FI_ORDER)
    253                             //? RLH_Notify_Done | RLH_Exe_Req_Seq
    254                             //: RLH_Notify_Done;
    255    rlhp->Block_Dev_Unit = pVolInfo->bUnit;
    256 
    257    for (i = 0, pgcmd = pPageCmdList->PageCmdList;
    258         i < (int)pPageCmdList->OpCount;
    259         i++, pgcmd++)
    260       {
    261       /* Fill in request header.
    262        * These fields are set to zero by memset, above:
    263        *        rhp->Req_Control
    264        *        rhp->Status
    265        *        rwp->RW_Flags
     256
     257   /* sectors per page */
     258   usSectors = PSIZE / pVolInfo->BootSect.bpb.BytesPerSector;
     259
     260   if (pVolInfo->pfnStrategy)
     261      {
     262      // use strat2 routine
     263      memset(&pgreq, 0, sizeof(pgreq));
     264
     265      rlhp = &pgreq.pr_hdr;
     266      rlhp->Count = pPageCmdList->OpCount;
     267      rlhp->Notify_Address = (void far *)pageIOdone;
     268      rlhp->Request_Control = (pPageCmdList->InFlags & PGIO_FI_ORDER)
     269                               ? RLH_Notify_Done | RLH_Exe_Req_Seq
     270                               : RLH_Notify_Done;
     271      rlhp->Block_Dev_Unit = pVolInfo->bUnit;
     272
     273      /* Fill in a request for each command in the input list.
    266274       */
    267        rhp = &pgreq.rgReq[i].pb.RqHdr;
    268        rhp->Length = sizeof(REQUEST);
    269        //rhp->Req_Control = RH_NOTIFY_ERROR; // | RH_NOTIFY_DONE;
    270        rhp->Old_Command = PB_REQ_LIST;
    271        rhp->Command_Code = pgcmd->Cmd;
    272        rhp->Head_Offset = (ULONG)rhp - (ULONG)rlhp;
    273        rhp->Priority = pgcmd->Priority;
    274        rhp->Hint_Pointer = -1;
    275        /* Fill in read/write request.
    276         */
    277        rwp = &pgreq.rgReq[i].pb;
    278        rc = GetBlockNum(pVolInfo, pOpenInfo, pgcmd->FileOffset, &fsbno);
    279        if (rc)
    280           {
    281           /* request is not valid, return error */
    282           goto FS_DOPAGEIO_EXIT;
    283           }
    284        rwp->Start_Block = fsbno;
    285        rwp->Block_Count = PSIZE >> 9;
    286        rwp->SG_Desc_Count = 1;
    287 
    288        /* Fill in the scatter/gather descriptor
    289         */
    290        pgreq.rgReq[i].sg.BufferPtr = (void *)pgcmd->Addr;
    291        pgreq.rgReq[i].sg.BufferSize = PSIZE;
    292        }
    293 
    294    /* Length in last request must be set to terminal value.
    295     */
    296    rhp->Length = RH_LAST_REQ;
    297 
    298    vCallStrategy2(pVolInfo, &pgreq);
    299 
    300    /* Check for errors and update status info in the command list.
    301     * Set return value to error code from first failing command.
    302     */
    303    rc = 0;
    304    for (i = 0; i < (int)pPageCmdList->OpCount; i++)
    305       {
    306       pgcmd = &pPageCmdList->PageCmdList[i];
    307       rhp = &pgreq.rgReq[i].pb.RqHdr;
    308 
    309       pgcmd->Status = rhp->Status;
    310       pgcmd->Error = rhp->Error_Code;
    311       if ((rc == 0) && (pgcmd->Error != 0))
    312          rc = pgcmd->Error;
     275      //assert(pPageCmdList->OpCount > 0);
     276
     277      for (i = 0, pgcmd = pPageCmdList->PageCmdList;
     278           i < (int)pPageCmdList->OpCount;
     279           i++, pgcmd++)
     280         {
     281         /* Fill in request header.
     282          * These fields are set to zero by memset, above:
     283          *     rhp->Req_Control
     284          *     rhp->Status
     285          *     rwp->RW_Flags
     286          */
     287         rhp = &pgreq.pr_list[i].pr_rw.RqHdr;
     288         rhp->Length = sizeof(struct _pr_list);
     289         rhp->Old_Command = PB_REQ_LIST;
     290         rhp->Command_Code = pgcmd->Cmd;
     291         rhp->Head_Offset = (ULONG)rhp - (ULONG)rlhp;
     292         rhp->Priority = pgcmd->Priority;
     293         rhp->Hint_Pointer = -1;
     294
     295         /* Fill in read/write request.
     296          */
     297         rwp = &pgreq.pr_list[i].pr_rw;
     298         rc = GetBlockNum(pVolInfo, pOpenInfo, pgcmd->FileOffset, &fsbno);
     299         if (rc)
     300            {
     301            /* request is not valid, return error */
     302            goto FS_DOPAGEIO_EXIT;
     303            }
     304         rwp->Start_Block = fsbno;
     305         rwp->Block_Count = usSectors;
     306         rwp->SG_Desc_Count = 1;
     307
     308         /* Fill in the scatter/gather descriptor
     309          */
     310         pgreq.pr_list[i].pr_sg.BufferPtr = (void *)pgcmd->Addr;
     311         pgreq.pr_list[i].pr_sg.BufferSize = PSIZE;
     312         }
     313
     314      /* Length in last request must be set to terminal value.
     315       */
     316      rhp->Length = RH_LAST_REQ;
     317
     318      //IS_QUIESCE(ip->i_ipmnt->i_cachedev);    /* Block if hard quiesce */
     319
     320      ulSemRWSwap = 0;
     321
     322      vCallStrategy2(pVolInfo, &pgreq);
     323
     324      /* Wait for the request to complete.
     325       */
     326      //PAGING_LOCK();
     327      //if (ulSemRWSwap)
     328      //   {
     329         rc = FSH_SEMREQUEST(&ulSemRWSwap, TO_INFINITE);
     330      //   PAGING_NOLOCK();
     331      //   }
     332      //else
     333      //   PAGING_UNLOCK();
     334
     335      /* If hard quiesce is in progress, and this is the last pending I/O,
     336       * wake up the quiescing thread
     337       */
     338      //ipri = IOCACHE_LOCK();
     339      //cdp = ip->i_ipmnt->i_cachedev;
     340      //if ((--cdp->cd_pending_requests == 0) && (cdp->cd_flag & CD_QUIESCE))
     341      //    IOCACHE_WAKEUP(&cdp->cd_iowait);
     342      //IOCACHE_UNLOCK(ipri);
     343
     344      /* Check for errors and update status info in the command list.
     345       * Set return value to error code from first failing command.
     346       */
     347      rc = 0;
     348      for (i = 0; i < (int)pPageCmdList->OpCount; i++)
     349         {
     350         pgcmd = &pPageCmdList->PageCmdList[i];
     351         rhp = &pgreq.pr_list[i].pr_rw.RqHdr;
     352
     353         pgcmd->Status = rhp->Status;
     354         pgcmd->Error = rhp->Error_Code;
     355         if ((rc == 0) && (pgcmd->Error != 0))
     356            rc = pgcmd->Error;
     357         }
     358      }
     359   else
     360      {
     361      // use strat1 routine
     362      for (i = 0, pgcmd = pPageCmdList->PageCmdList;
     363           i < (int)pPageCmdList->OpCount;
     364           i++, pgcmd++)
     365         {
     366         // read/write operation
     367         USHORT op;
     368
     369         switch (pgcmd->Cmd)
     370            {
     371            case PB_READ_X:
     372            case PB_PREFETCH_X:
     373               op = DVIO_OPREAD;
     374               break;
     375            case PB_WRITE_X:
     376               op = DVIO_OPWRITE;
     377               break;
     378            case PB_WRITEV_X:
     379               op = DVIO_OPWRITE | DVIO_OPVERIFY;
     380            }
     381
     382         op |= DVIO_OPNCACHE;
     383
     384         // get starting sector number
     385         rc = GetBlockNum(pVolInfo, pOpenInfo, pgcmd->FileOffset, &fsbno);
     386         if (rc)
     387            {
     388            /* request is not valid, return error */
     389            goto FS_DOPAGEIO_EXIT;
     390            }
     391
     392         // read it
     393         rc = FSH_DOVOLIO( op, DVIO_ALLACK, pVolInfo->hVBP, (char far *)pgcmd->Addr, &usSectors, fsbno );
     394         if (rc)
     395            {
     396            CritMessage("FAT32: DOPAGEIO of sector %ld (%d sectors) failed, rc = %u",
     397               fsbno, usSectors, rc);
     398            Message("ERROR: DOPAGEIO of sector %ld (%d sectors) failed, rc = %u",
     399               fsbno, usSectors, rc);
     400            }
     401         }
    313402      }
    314403
     
    317406      Message("FS_DOPAGEIO returned %u\n", rc);
    318407
    319    //FSH_SEMCLEAR(&ulSemRWSwap);
    320 
     408   //IWRITE_UNLOCK(ip);
    321409   _asm pop  es;
    322410
    323411   return rc;
    324412}
     413
     414
    325415
    326416/******************************************************************
     
    334424   int rc = NO_ERROR;
    335425
     426   _asm push es;
     427
    336428   if (f32Parms.fMessageActive & LOG_FS)
    337429      Message("FS_SETSWAP\n");
     
    339431   if (f32Parms.fMessageActive & LOG_FS)
    340432      Message("FS_SETSWAP returned %u\n", rc);
     433
     434   _asm pop  es;
    341435
    342436   return rc;
     
    350444   ULONG ulCluster;
    351445   LONGLONG llOffset;
    352    //ULONG ulClusterSize = pVolInfo->ulClusterSize;
    353    //int i;
    354446#ifdef INCL_LONGLONG
    355447   llOffset = (LONGLONG)ulOffset;
     
    358450#endif
    359451
    360    // get cluster at the ulOffset offset
    361    /* for (i = 0, ulCluster = ulStartCluster;
    362         i < ulOffset / ulClusterSize + 1;
    363         i++, ulCluster = GetNextCluster(pVolInfo, NULL, ulCluster))
    364       {
    365       if (ulCluster == pVolInfo->ulFatEof)
    366           return ERROR_SECTOR_NOT_FOUND;
    367       } */
    368 
    369452   // get cluster number from file offset
    370453   ulCluster = PositionToOffset(pVolInfo, pOpenInfo, llOffset);
     
    382465*
    383466******************************************************************/
    384 VOID vCallStrategy2(PVOLINFO pVolInfo, RQLIST far *pRQ)
     467void vCallStrategy2(PVOLINFO pVolInfo, struct pagereq far *pgreq)
    385468{
    386469   STRATFUNC pfnStrategy;
    387470   USHORT usSeg;
    388471   USHORT usOff;
    389    ULONG  ulIndex;
    390    RLH *pRLH;
    391    PB  *pPB;
    392 
    393    if (!pRQ)
     472
     473   if (!pgreq)
    394474      return;
    395475
    396    _asm push es; // vs
    397    _asm push bx; //
    398 
    399    if (f32Parms.fMessageActive & LOG_FS && pRQ->rlh.Count)
    400       Message("vCallStrategy2 drive %c:, %lu sectors, RQ %u",
    401          pRQ->rlh.Block_Dev_Unit + 'A',
    402          pRQ->rlh.Count,
    403          pRQ->usNr);
    404 
    405    pRLH = (RLH *)&pRQ->rlh;
    406 
    407    if (pRQ->rlh.Count == 1)
    408       pRQ->rlh.Lst_Status |= RLH_Single_Req;
    409 
    410    for (ulIndex = 0; ulIndex < pRQ->rlh.Count; ulIndex++)
    411       {
    412       pPB = (PB *)&pRQ->rgReq[ulIndex].pb;
    413 
    414       if (ulIndex + 1 < pRQ->rlh.Count)
    415          pPB->RqHdr.Length = sizeof (REQUEST);
    416 
    417       pPB->RqHdr.Head_Offset   = OFFSETOF(pPB) - OFFSETOF(pRLH);
    418       }
    419 
    420    usSeg = SELECTOROF(pRQ);
    421    usOff = OFFSETOF(pRQ) + offsetof(RQLIST, rlh);
     476   _asm push es;
     477   _asm push bx;
     478
     479   if (f32Parms.fMessageActive & LOG_FS && pgreq->pr_hdr.Count)
     480      Message("vCallStrategy2 drive %c:, %lu sectors",
     481         pgreq->pr_hdr.Block_Dev_Unit + 'A',
     482         pgreq->pr_hdr.Count);
     483
     484   if (!pgreq->pr_hdr.Count)
     485      {
     486      FSH_SEMCLEAR(&ulSemRWSwap);
     487      //DevHelp_ProcRun((ULONG)GetRequestList, &usCount);
     488      return;
     489      }
     490
     491   usSeg = SELECTOROF(pgreq);
     492   usOff = OFFSETOF(pgreq) + offsetof(struct pagereq, pr_hdr);
    422493
    423494   pfnStrategy = pVolInfo->pfnStrategy;
     
    428499   (*pfnStrategy)();
    429500
    430    _asm pop   bx; // vs
    431    _asm pop   es; //
    432 }
     501   _asm pop   bx;
     502   _asm pop   es;
     503}
     504
     505/*
     506 * This is called from on 16-bit stack from strat2
     507 */
     508void
     509pageIOdone(struct pagereq far * prp)
     510{
     511   FSH_SEMCLEAR(&ulSemRWSwap);
     512}
  • trunk/src/ifs/makefile.wcc

    r284 r295  
    8686    FS_FILEATTRIBUTE, &
    8787    FS_FILEINFO, &
    88 #      Not yet implemented
    8988    FS_FILEIO, &
    9089#      Not yet implemented
  • trunk/src/include/fsd.h

    r260 r295  
    521521);
    522522
     523/* FILEIO DEFINES */
     524#define FILEIO_LOCK    0
     525#define FILEIO_UNLOCK  1
     526#define FILEIO_SEEK    2
     527#define FILEIO_READ    3
     528#define FILEIO_WRITE   4
     529
     530#pragma pack(1)
     531
     532struct CmdLock
     533{
     534    USHORT Cmd;           /* 0 for Lock */
     535    USHORT LockCnt;       /* number of locks that follow */
     536    ULONG  TimeOut;       /* timeout in ms               */
     537};
     538
     539struct CmdUnLock
     540{
     541    USHORT Cmd;           /* 1 for UnLock */
     542    USHORT UnlockCnt;       /* number of locks that follow */
     543};
     544
     545struct CmdSeek
     546{
     547    USHORT Cmd;           /* 2 for seek                 */
     548    USHORT Method;        /* 0 for absolute             */
     549                          /* 1 for relative to current  */
     550                          /* 2 for relative to EOF      */
     551    LONG  Position;       /* position or delta          */
     552    LONG  Actual;         /* actual position seeked to  */
     553};
     554
     555struct CmdSeekL
     556{
     557    USHORT Cmd;           /* 2 for seek                 */
     558    USHORT Method;        /* 0 for absolute             */
     559                          /* 1 for relative to current  */
     560                          /* 2 for relative to EOF      */
     561    LONGLONG Position;    /* position or delta          */
     562    LONGLONG Actual;      /* actual position seeked to  */
     563};
     564
     565struct CmdIO
     566{
     567    USHORT Cmd;           /* 3 for read 4 for write     */
     568    void * _Seg16 Buffer; /* data buffer                */
     569    USHORT BufferLen;     /* buffer length              */
     570    USHORT Actual;        /* actual bytes transferred   */
     571
     572};
     573
     574/* lock structure to be passed into jfs_filelock function */
     575struct Lock {
     576  USHORT  Share;            /* on if lock is shared, else off */
     577  ULONG   Start;            /* start offset of lock           */
     578  ULONG   Length;           /* count of bytes to be locked    */
     579};
     580
     581/* unlock structure to be passed into jfs_lock function */
     582struct UnLock {
     583  ULONG   Start;            /* start offset of lock           */
     584  ULONG   Length;           /* count of bytes to be locked    */
     585};
     586
     587/* longlong lock structure to be passed into jfs_filelock function */
     588struct LockL {
     589  USHORT  Share;            /* on if lock is shared, else off */
     590  USHORT  Pad;              /* pad to 4 bytes */
     591  ULONGLONG Start;          /* start offset of lock           */
     592  ULONGLONG Length;         /* count of bytes to be locked    */
     593};
     594
     595/* longlong unlock structure to be passed into jfs_lock function */
     596struct UnLockL {
     597  ULONGLONG Start;          /* start offset of lock           */
     598  ULONGLONG Length;         /* count of bytes to be locked    */
     599};
     600
     601#pragma pack()
     602
    523603int far pascal _loadds
    524604FS_FILELOCKS(
     
    530610    unsigned long               /* flags        */
    531611);
     612
     613/* lock defines */
     614#define LOCK_EXPIRED   0x0L
     615#define LOCK_WAKEUP    0x1L
     616#define LOCK_CANCELED  0x2L
     617
     618struct filelock {
     619    long FileOffset;   /* offset where the lock/unlock begins  */
     620    long RangeLength;  /* length of region locked/unlocked     */
     621};
     622
     623struct filelockl {
     624    long long FileOffset;   /* offset where the lock/unlock begins  */
     625    long long RangeLength;  /* length of region locked/unlocked     */
     626};
    532627
    533628int far pascal _loadds
  • trunk/src/util/cachef32.c

    r249 r295  
    516516          }
    517517
    518    if ( fForeGround && (*pLoadTranslateTable)(FALSE, TRUE))
     518   if ( fForeGround && (*pLoadTranslateTable)(fSilent, TRUE))
    519519          fSetParms = TRUE;
    520520
Note: See TracChangeset for help on using the changeset viewer.