FileSystemServer.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 Niek Linnenbank
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef __LIB_LIBFS_FILESYSTEMSERVER_H
#define __LIB_LIBFS_FILESYSTEMSERVER_H
 
#include <ChannelServer.h>
#include <Vector.h>
#include "Directory.h"
#include "Device.h"
#include "File.h"
#include "FileCache.h"
#include "FileSystem.h"
#include "FileSystemPath.h"
#include "FileSystemMessage.h"
#include "FileSystemRequest.h"
#include "FileSystemMount.h"
 
class FileSystemServer : public ChannelServer<FileSystemServer, FileSystemMessage>
{
  private:
 
    static const Size MaximumFileSystemMounts = 32;
 
    static const Size MaximumWaitSetCount = 32;
 
  public:
 
    FileSystemServer(Directory *root, const char *path);
 
    virtual ~FileSystemServer();
 
    const char * getMountPath() const;
 
    u32 getNextInode();
 
    FileSystem::Result mount();
 
    FileSystem::Result registerFile(File *file, const char *path);
 
    FileSystem::Result registerDirectory(Directory *dir,
                                         const char *path);
 
    FileSystem::Result unregisterFile(const char *path);
 
    virtual File * createFile(const FileSystem::FileType type);
 
    void pathHandler(FileSystemMessage *msg);
 
    void mountHandler(FileSystemMessage *msg);
 
    void getFileSystemsHandler(FileSystemMessage *msg);
 
    virtual bool retryRequests();
 
  protected:
 
    FileSystem::Result processRequest(FileSystemRequest &req);
 
    FileSystem::Result inodeHandler(FileSystemRequest &req);
 
    FileSystem::Result waitFileHandler(FileSystemRequest &req);
 
    void sendResponse(FileSystemMessage *msg) const;
 
    bool redirectRequest(const char *path, FileSystemMessage *msg);
 
    void setRoot(Directory *newRoot);
 
    Directory * getParentDirectory(const char *path);
 
    FileCache * lookupFile(const FileSystemPath &path);
 
    FileCache * findFileCache(const char *path) const;
 
    FileCache * findFileCache(const String &path) const;
 
    FileCache * findFileCache(const FileSystemPath &path) const;
 
    FileCache * insertFileCache(File *file, const char *pathFormat);
 
    void removeFileFromCache(FileCache *cache, File *file);
 
    void clearFileCache(FileCache *cache = ZERO);
 
  protected:
 
    const ProcessID m_pid;
 
    FileCache *m_root;
 
    HashTable<u32, File *> m_inodeMap;
 
    const char *m_mountPath;
 
    FileSystemMount *m_mounts;
 
    List<FileSystemRequest *> *m_requests;
};
 
#endif /* __LIB_LIBFS_FILESYSTEMSERVER_H */