FileSystem.cxx

Go to the documentation of this file.

 
#include "Devtab.hxx"
 
#include <fcntl.h>
#include <unistd.h>
 
FileSystem *FileSystem::first = NULL;
 
FileSystem::FileSystem()
    : FileIO(nullptr)
{
    mutex.lock();
    next = first;
    first = this;
    prev = NULL;
    if (next)
    {
        next->prev = this;
    }
    mutex.unlock();
}
 
FileSystem::~FileSystem()
{
    mutex.lock();
    if (first == this)
    {
        first = next;
    }
    else
    {
        prev->next = next;
    }
    if (next)
    {
        next->prev = prev;
    }
    mutex.unlock();
}
 
FileSystem *FileSystem::fs_lookup(const char *path)
{
    for (FileSystem *fs = first; fs != NULL; fs = fs->next)
    {
        if (fs->name == nullptr)        
        {
            /* mount path has no name, probably not mounted yet */
            continue;
        }
        size_t fs_name_len = strlen(fs->name);
        if (fs_name_len > strlen(path))
        {
            /* path less than mount path */
            continue;
        }
        if (strncmp(fs->name, path, fs_name_len))
        {
            /* no basename match */
            continue;
        }
        if (path[fs_name_len] != '/' && strcmp(fs->name, path))
        {
            /* not a directory break or exact name match*/
            continue;
        }
        return fs;
    }
 
    return nullptr;
}
 
int FileSystem::open(struct _reent *reent, const char *path, int flags, int mode)
{
    mutex.lock();
    int fd = fd_alloc();
    mutex.unlock();
    if (fd < 0)
    {
        errno = EMFILE;
        return -1;
    }
    files[fd].flags = flags;
 
    FileSystem *fs = fs_lookup(path);
 
    if (!fs)
    {
        // No device found.
        fd_free(fd);
        errno = ENODEV;
        return -1;
    }
 
    files[fd].dev = fs;
    files[fd].device = false;
    const char *subpath = path + strlen(fs->name) + 1;
    int result = files[fd].dev->open(&files[fd], subpath, flags, mode);
    if (result < 0)
    {
        fd_free(fd);
        errno = -result;
        return -1;
    }
    return fd;
}
 
int FileSystem::close(struct _reent *reent, int fd)
{
    File* f = file_lookup(fd);
    if (!f) 
    {
        /* errno should already be set appropriately */
        return -1;
    }
    if (fd >=0 && fd <= 2)
    {
        // stdin, stdout, and stderr never get closed
        return 0;
    }
    int result = f->dev->close(f);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    fd_free(fd);
    return 0;
}
 
int FileSystem::unlink(struct _reent *reent, const char *path)
{
    FileSystem *fs = fs_lookup(path);
    if (!fs)
    {
        errno = ENOENT;
        return -1;
    }
 
    const char *subpath = path + strlen(fs->name) + 1;
    int result = fs->unlink(subpath);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return 0;
}
 
int FileSystem::stat(struct _reent *reent, const char *path, struct stat *stat)
{
    FileSystem *fs = fs_lookup(path);
    if (!fs)
    {
        errno = ENOENT;
        return -1;
    }
 
    const char *subpath = path + strlen(fs->name) + 1;
    int result = fs->stat(subpath, stat);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return 0;
}
 
int FileSystem::fstat(File* file, struct stat *stat)
{
    memset(stat, 0, sizeof(*stat));
    return 0;
}
 
int FileSystem::fsync(int fd)
{
    File *file = file_lookup(fd);
    HASSERT(!file->device);
 
    if (!file)
    {
        errno = EBADF;
        return -1;
    }
 
    int result = static_cast<FileSystem*>(file->dev)->fsync(file);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
/*
 * FileSystem::closedir()
 */
int FileSystem::closedir(DIR *dirp)
{
    File *file = (File*)dirp;
    FileSystem *fs = static_cast<FileSystem*>(file->dev);
 
    if (!file->dir)
    {
        errno = EBADF;
        return -1;
    }
    int result = fs->closedir(file);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
/*
 * FileSystem::opendir()
 */
DIR *FileSystem::opendir(const char *name)
{
    mutex.lock();
    int fd = fd_alloc();
    mutex.unlock();
    if (fd < 0)
    {
        errno = EMFILE;
        return NULL;
    }
    files[fd].flags = 0;
    files[fd].dir = true;
 
    FileSystem *fs = fs_lookup(name);
    if (fs)
    {
        files[fd].dev = fs;
        files[fd].device = false;
        const char *subpath = name + strlen(fs->name) + 1;
        DIR *result = (DIR*)fs->opendir(&files[fd], subpath);
        if (result)
        {
            return result;
        }
    }
    // No device found.
    fd_free(fd);
    errno = ENOENT;
    return NULL;
}
 
/*
 * FileSystem::readdir()
 */
struct dirent *FileSystem::readdir(DIR *dirp)
{
    File *file = (File*)dirp;
    FileSystem *fs = static_cast<FileSystem*>(file->dev);
 
    HASSERT(file->dir);
 
    return fs->readdir(file);
}
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * closedir()
 */
int closedir(DIR *dirp)
{
    return FileSystem::closedir(dirp);
}
 
/*
 * opendir()
 */
DIR *opendir(const char *name)
{
    return FileSystem::opendir(name);
}
 
/*
 * readdir()
 */
struct dirent *readdir(DIR *dirp)
{
    return FileSystem::readdir(dirp);
}
 
#ifdef __cplusplus
}
#endif