OSDev.org

Code: Select all

void myVFS(void) {
    for(;;) {
        getMessage();
        switch(message.type) {
            case REQUEST_OPEN:
                handleOpen();
                break;
            case FS_RESPONSE_DIRECTORY;
                handleFSdirectory();
                break;
            case REQUEST_CLOSE:
                handleClose();
                break;
            case REQUEST_READ:
                handleRead();
                break;
            case FS_RESPONSE_READ;
                handleFSread();
                break;
        }
    }
}


void handleOpen(void) {
    DIR_INFO *directoryInfo;

    directoryInfo = findFileInfoInDirectoryCache(message.fileName);
    if(directoryInfo != NULL) {
        if(directoryInfo.status != PENDING) {
            satisfyOpenRequest(directoryInfo, message.sender, message.openType);
            return;
        }
        createFileInfoInDirectoryCache(message.fileName, PENDING);
        sendMessage(file_system, FS_REQUEST_DIRECTORY, message.fileName);
    }
    createOPENrequestStructure(message.sender, message.fileName, message.openType);
}


void satisfyOpenRequest(DIR_INFO *directoryInfo, THREAD_ID client, int openType) {
    int status;
    int handle;

    status = checkFilePermissionsAndStuff(directoryInfo, openType);
    if(status != OK) {
        sendMessage(client, RESPONSE_OPEN, status);
        return;
    }
    handle = createFileHandle(client, directoryInfo, openType);
    sendMessage(client, RESPONSE_OPEN, OK, handle);
}


void handleFSdirectory(void) {
     DIR_INFO *directoryInfo;
     OPEN_REQUEST_STRUCTURE *request;

    insertReceivedDirectoryDataIntoDirectoryCache();

    request = firstOPENrequestStructure;
    while(request != NULL) {
        directoryInfo = findFileInfoInDirectoryCache(request.fileName);

        if(directoryInfo != NULL) {
            if(directoryInfo.status != PENDING) {
                satisfyOpenRequest(directoryInfo, request.client, request.openType);
            }
        }
        request = request.next;
    }
}


void handleClose(void) {
    int status;

    status = destroyFileHandle(message.sender, message.fileHandle);
    sendMessage(message.sender, RESPONSE_CLOSE, status, message.fileHandle);
}


void handleRead(void) {
    int status;
    int handle;
    void *data;
    int size;

    status = findFileHandle(&handle, message.sender, message.fileHandle);
    if(status != OK) {
        sendMessage(message.sender, RESPONSE_READ, status, message.fileHandle);
        return;
    }
    status = getFileData( getHandleFileName(handle), &data, &size);
    if(status == OK) {
        sendMessage(message.sender, RESPONSE_READ, OK, data, size);
        return;
    }
    sendMessage(file_system, FS_REQUEST_READ, getHandleFileName(handle));
    createREADrequestStructure(handle);
}


void handleFSread(void) {
    READ_REQUEST_STRUCTURE *request;
    int status;
    int handle;
    void *data;
    int size;

    insertReceivedFileDataIntoFileDataCache();

    request = firstREADrequestStructure;
    while(request != NULL) {
        status = getFileData( getHandleFileName(handle), &data, &size);
        if(status == OK) {
            sendMessage(request.client, RESPONSE_READ, OK, data, size);
            return;
        }
        request = request.next;
    }
}

Code: Select all

int _write(int fd, unsigned char *buffer, unsigned int size, unsigned int flags){
    /// lookup where the page is in memory for the current file position in
    /// the file referenced by the file descriptor identifier.
    ......
    /// memcpy the data onto this page.
    ......
    /// flush the block pages that we dirtied.
    .....
}
int write(int fd, unsigned char *buffer, unsigned int size){
    /// might support a NO_FLUSH flag or such.
    return _write(fd, buffer, size, 0);
}