Fileio.cxx

Go to the documentation of this file.

 
#include "Devtab.hxx"
 
#include <cstdarg>
#include <fcntl.h>
#include <reent.h>
#include <unistd.h>
#include <sys/select.h>
 
OSMutex FileIO::mutex;
 
int FileIO::fd_alloc(void)
{
    for (unsigned int i = 0; i < numOpenFiles; i++)
    {
        if (files[i].inuse == false)
        {
            files[i].inuse = true;
            files[i].inshdn = false;
            files[i].device = true;
            files[i].dir = false;
            files[i].dirty = false;
            files[i].priv = nullptr;
            files[i].dev = nullptr;
            files[i].offset = 0;
            files[i].flags = 0;
            return i;
        }
    }
    return -1;
}
 
void FileIO::fd_free(int fd)
{
    files[fd].inuse = false;
}
 
File* FileIO::file_lookup(int fd)
{
    if (fd < 0 || fd >= (int)numOpenFiles)
    {
        errno = EBADF;
        return nullptr;
    }
    if (files[fd].inuse == 0 || files[fd].inshdn == 1)
    {
        errno = EBADF;
        return nullptr;
    }
    return &files[fd];
}
 
int FileIO::fd_lookup(File *file)
{
    HASSERT(file >= files && file <= (files + numOpenFiles) && file->inuse);
 
    return (file - files);
}
 
ssize_t FileIO::read(struct _reent *reent, int fd, void *buf, size_t count)
{
    File* f = file_lookup(fd);
    if (!f)
    {
        /* errno should already be set appropriately */
        return -1;
    }
    ssize_t result = f->dev->read(f, buf, count);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
ssize_t FileIO::write(struct _reent *reent, int fd, const void *buf, size_t count)
{
    File* f = file_lookup(fd);
    if (!f)
    {
        /* errno should already be set appropriately */
        return -1;
    }
    ssize_t result = f->dev->write(f, buf, count);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
_off_t FileIO::lseek(struct _reent *reent, int fd, _off_t offset, int whence)
{
    File* f = file_lookup(fd);
    if (!f)
    {
        /* errno should already be set appropriately */
        return (_off_t) -1;
    }
    off_t result = f->dev->lseek(f, offset, whence);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
int FileIO::fstat(struct _reent *reent, int fd, struct stat *stat)
{
    File* f = file_lookup(fd);
    if (!f)
    {
        /* errno should already be set appropriately */
        return -1;
    }
    ssize_t result = f->dev->fstat(f, stat);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
int FileIO::ioctl(int fd, unsigned long int key, unsigned long data)
{
    File* f = file_lookup(fd);
    if (!f)
    {
        /* errno should already be set appropriately */
        return -1;
    }
    int result = f->dev->ioctl(f, key, data);
    if (result < 0)
    {
        errno = -result;
        return -1;
    }
    return result;
}
 
int FileIO::fcntl(int fd, int cmd, unsigned long data)
{
    File *file = file_lookup(fd);
 
    if (!file)
    {
        errno = EBADF;
        return -1;
    }
 
    switch (cmd)
    {
        case F_GETFL:
            return file->flags;
        case F_SETFL:
            /* on this platform, we ignore O_ASYNC, O_DIRECT, and O_NOATIME */
            data &= (O_APPEND | O_NONBLOCK);
            file->flags &= ~(O_APPEND | O_NONBLOCK);
            file->flags |= data;
            /* fall through */
        default:
        {
            File* f = file_lookup(fd);
            if (!f)
            {
                /* errno should already be set appropriately */
                return -1;
            }
            int result = f->dev->fcntl(f, cmd, data);
            if (result < 0)
            {
                errno = -result;
                return -1;
            }
            return result;
        }
    }
}
 
off_t FileIO::lseek(File* f, off_t offset, int whence)
{
    switch (whence)
    {
        case SEEK_SET:
            f->offset = offset;
            return offset;
        case SEEK_CUR:
            f->offset += offset;
            return f->offset;
    }
    return (off_t)-EINVAL;
}
 
int FileIO::ioctl(File *, unsigned long int, unsigned long) {
    return -EINVAL;
}
 
int FileIO::fcntl(File *file, int cmd, unsigned long data)
{
    if (cmd == F_SETFL)
    {
        return 0;
    }
    else
    {
        return -EINVAL;
    }
}
 
extern "C" {
 
int _open_r(struct _reent *reent, const char *path, int flags, int mode)
{
    int result = Device::open(reent, path, flags, mode);
    if (result < 0 && errno == ENODEV)
    {
        return FileSystem::open(reent, path, flags, mode);
    }
 
    return result;
}
 
int _close_r(struct _reent *reent, int fd)
{
    return FileIO::is_device(fd) ?     Device::close(reent, fd) :
                                   FileSystem::close(reent, fd);
}
 
ssize_t _read_r(struct _reent *reent, int fd, void *buf, size_t count)
{
    return FileIO::read(reent, fd, buf, count);
}
 
ssize_t _write_r(struct _reent *reent, int fd, const void *buf, size_t count)
{
    return FileIO::write(reent, fd, buf, count);
}
 
int _stat_r(struct _reent *reent, const char *path, struct stat *stat)
{
    int result = Device::stat(reent, path, stat);
    if (result < 0 && errno == ENOENT)
    {
        return FileSystem::stat(reent, path, stat);
    }
 
    return result;
}
 
int _fstat_r(struct _reent *reent, int fd, struct stat *stat)
{
    return FileIO::fstat(reent, fd, stat);
}
 
int _isatty_r(struct _reent *reent, int fd)
{
    return 1;
}
 
int _unlink_r(struct _reent *reent, const char *path)
{
    return FileSystem::unlink(reent, path);
}
 
_off_t _lseek_r(struct _reent *reent, int fd, _off_t offset, int whence)
{
    return FileIO::lseek(reent, fd, offset, whence);
}
 
int fsync(int fd)
{
    return FileSystem::fsync(fd);
}
 
int ioctl(int fd, unsigned long int key, ...)
{
    va_list ap;
    va_start(ap, key);
 
    int result = FileIO::ioctl(fd, key, va_arg(ap, unsigned long));
    
    va_end(ap);
    return result;
}
 
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout)
{
    long long time_value = -1;
    if (timeout) {
        time_value = timeout->tv_sec;
        time_value *= 1000000;
        time_value += timeout->tv_usec;
        time_value *= 1000;
    }
    Device::select_clear();
    return Device::select(nfds, readfds, writefds, exceptfds, time_value);
}
 
int fcntl(int fd, int cmd, ...)
{
    va_list ap;
    va_start(ap, cmd);
 
    int result = FileIO::fcntl(fd, cmd, va_arg(ap, unsigned long));
 
    va_end(ap);
    return result;
}
 
}