Changeset 770

Show
Ignore:
Timestamp:
07/09/08 18:46:57 (2 months ago)
Author:
mwhitworth
Message:

Fix buffer locking behaviour to avoid races.

Location:
Whitix/branches/fs/fs/vfs
Files:
4 modified

Legend:

Unmodified
Added
Removed

  • Whitix/branches/fs/fs/vfs/bcache.c

    r752 r770  
    9595        INIT_WAITQUEUE_ENTRY(bufferWait); 
    9696 
    97         WaitAddToQueue(&buffer->waitQueue, &bufferWait); 
    98  
    9997        do 
    10098        { 
     99                WaitAddToQueue(&buffer->waitQueue, &bufferWait); 
    101100                ThrSuspendThread(currThread); 
    102  
    103                 if (!BufferLocked(buffer)) 
    104                         break; 
    105  
    106101                ThrSchedule(); 
    107102        }while (BufferLocked(buffer)); 
    … …  
    157152 
    158153        INIT_WAITQUEUE_HEAD(&buff->waitQueue); 
     154        BufferLock(buff); 
    159155        BlockAddToHashTable(buff); 
    160156 
    … …  
    259255                return -EFAULT; 
    260256 
    261         /* The buffer will be unlocked in StorageEndRequest */ 
    262         BufferLock(buff); 
     257        /* Buffer should already be locked if we're coming from BlockRead */ 
    263258 
    264259        err=BlockSendRequestRaw(device,request); 
    … …  
    308303 
    309304        request=StorageBuildRequest(buff, REQUEST_READ); 
    310  
    311         BufferLock(buff); 
    312305 
    313306        StorageDoRequest(device,request); 
    … …  
    479472{ 
    480473        struct ListHead* head=BUFFER_HASH(device, blockNum); 
    481         struct Buffer* curr; 
     474        struct Buffer* curr, *ret=NULL; 
     475 
     476        PreemptDisable(); 
    482477 
    483478        ListForEachEntry(curr, head, list) 
    … …  
    485480                { 
    486481                        BufferGet(curr); 
    487                         return curr; 
     482                        ret=curr; 
     483                        goto out; 
    488484                } 
    489485 
    490         return NULL; 
     486out: 
     487        PreemptEnable(); 
     488        return ret; 
    491489} 
    492490 

  • Whitix/branches/fs/fs/vfs/dir.c

    r701 r770  
    372372                return -ENOTIMPL; 
    373373        } 
     374 
     375        VfsFileAccessed(file->vNode); 
    374376 
    375377        /* Check if an error occured during ReadDir. If not, return the total byte-count of 

  • Whitix/branches/fs/fs/vfs/file.c

    r746 r770  
    4848                return; 
    4949 
    50         vNode->aTime=currTime; 
    51         SetVNodeDirty(vNode); 
     50        /* TODO: Check granularity of vNode times on disk. No point dirtying a vNode if 
     51         * the time isn't updated. */ 
     52 
     53        if (vNode->aTime.seconds < currTime.seconds) 
     54        { 
     55                vNode->aTime=currTime; 
     56                SetVNodeDirty(vNode); 
     57        } 
    5258} 
    5359 
    … …  
    7480                return; 
    7581 
    76         vNode->mTime=currTime; 
    77  
    7882        /* Has the vNode just been created? If so, record its 
    7983        creation time */ 
    … …  
    8185                vNode->cTime=currTime; 
    8286 
    83         SetVNodeDirty(vNode); 
     87        /* See VfsFileAccessed comment. */ 
     88        if (vNode->mTime.seconds < currTime.seconds || create) 
     89        { 
     90                vNode->mTime=currTime; 
     91                SetVNodeDirty(vNode); 
     92        } 
    8493} 
    8594 
    … …  
    146155                copyOffset+=readSize; 
    147156                file->position+=readSize; 
     157 
    148158                BlockFree(buff); 
    149159        } 

  • Whitix/branches/fs/fs/vfs/load.c

    r701 r770  
    7272        int err; 
    7373 
    74         err=DoOpenFile(file,pathName,FILE_READ,0); 
     74        err=DoOpenFile(file, pathName, FILE_READ, 0); 
    7575 
    7676        if (err) 
    7777                return err; 
    78  
     78         
    7979        if (file->vNode->mode & VFS_ATTR_DIR) 
    8080                return -EISDIR; 
    … …  
    377377        ExecSetupContext(&execArgs,pathName,fds,argv); 
    378378 
    379         /* Open exectuable */ 
     379        /* Open executable */ 
    380380        err=ExecOpen(pathName,&execArgs.exec); 
    381381        if (err) 
    … …  
    708708        /* Should calculate total program header size. TODO: Memory map in. See linker code. */ 
    709709        buffer=(BYTE*)malloc(512); 
    710         if (!DoReadFile(&args->exec,buffer,512)) 
     710        if (!DoReadFile(&args->exec, buffer, 512)) 
    711711        { 
    712712                KePrint("Failed to read file %s\n",args->pathName); 
    … …  
    717717        header=(struct ElfHeader*)buffer; 
    718718 
    719         if (ElfCheckHeader(header,ELF_EXEC | ELF_DYN)) 
    720         { 
    721                 KePrint("%s: not a valid ELF executable\n",args->pathName); 
     719        if (ElfCheckHeader(header, ELF_EXEC | ELF_DYN)) 
     720        { 
     721                KePrint("%s: not a valid ELF executable\n", args->pathName); 
    722722                err=-EINVAL; 
    723723                goto freeBuffer;