Subversion Repositories freemyipod

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id: file.c 26191 2010-05-20 12:59:12Z funman $
 *
 * Copyright (C) 2002 by Björn Stenberg
 *
 * 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 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "global.h"
#include "libc/include/errno.h"
#include "libc/include/string.h"
#include "file.h"
#include "fat.h"
#include "dir.h"
#include "util.h"
#include "thread.h"

/*
  These functions provide a roughly POSIX-compatible file IO API.

  Since the fat32 driver only manages sectors, we maintain a one-sector
  cache for each open file. This way we can provide byte access without
  having to re-read the sector each time.
  The penalty is the RAM used for the cache and slightly more complex code.
*/

struct filedesc {
    unsigned char cache[SECTOR_SIZE];
    int cacheoffset; /* invariant: 0 <= cacheoffset <= SECTOR_SIZE */
    long fileoffset;
    long size;
    int attr;
    struct fat_file fatfile;
    struct filedesc* next;
    struct scheduler_thread* process;
    bool write;
    bool dirty;
    bool trunc;
};

static struct mutex file_mutex;
static struct filedesc* openfiles;

static int flush_cache(int fd);

int file_creat(const char *pathname)
{
    return open(pathname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
}

static int open_internal(const char* pathname, int flags, bool ignoredir)
{
    DIR* dir;
    struct dirent* entry;
    char pathnamecopy[MAX_PATH];
    char* name;
    struct filedesc* file;
    int rc;

    DEBUGF("open(\"%s\",%d)",pathname,flags);

    if ( pathname[0] != '/' ) {
        DEBUGF("'%s' is not an absolute path.", pathname);
        DEBUGF("Only absolute pathnames supported at the moment");
        errno = EINVAL;
        return 0;
    }

    file = (struct filedesc*)memalign(0x10, sizeof(struct filedesc));
    if (!file)
    {
        errno = EMFILE;
        return 0;
    }
    reownalloc(file, KERNEL_OWNER(KERNEL_OWNER_FILE_HANDLE));
    memset(file, 0, sizeof(struct filedesc));
    file->process = current_thread;
    if (flags & (O_RDWR | O_WRONLY)) {
        file->write = true;

        if (flags & O_TRUNC)
            file->trunc = true;
    }

    strlcpy(pathnamecopy, pathname, sizeof(pathnamecopy));

    /* locate filename */
    name=strrchr(pathnamecopy+1,'/');
    if ( name ) {
        *name = 0; 
        dir = opendir(pathnamecopy);
        *name = '/';
        name++;
    }
    else {
        dir = opendir("/");
        name = pathnamecopy+1;
    }
    if (!dir) {
        DEBUGF("Failed opening dir");
        errno = EIO;
        free(file);
        return 0;
    }

    if(name[0] == 0) {
        DEBUGF("Empty file name");
        errno = EINVAL;
        free(file);
        closedir(dir);
        return 0;
    }

    /* scan dir for name */
    while ((entry = readdir(dir))) {
        if ( !strcasecmp(name, entry->d_name) ) {
            fat_open(IF_MV2(dir->fatdir.file.volume,)
                     entry->startcluster,
                     &(file->fatfile),
                     &(dir->fatdir));
            file->size = file->trunc ? 0 : entry->size;
            file->attr = entry->attribute;
            break;
        }
    }

    if ( !entry ) {
        if ( file->write && (flags & O_CREAT) ) {
            rc = fat_create_file(name,
                                 &(file->fatfile),
                                 &(dir->fatdir));
            if (rc < 0) {
                DEBUGF("Couldn't create %s", pathnamecopy);
                errno = EIO;
                free(file);
                closedir(dir);
                return 0;
            }
            DEBUGF("File %s doesn't exist, creating it", pathnamecopy);
            file->size = 0;
            file->attr = 0;
        }
        else {
            DEBUGF("Couldn't find %s", pathnamecopy);
            errno = ENOENT;
            free(file);
            closedir(dir);
            return 0;
        }
    } else {
        if (file->attr & FAT_ATTR_DIRECTORY && !ignoredir) {
            errno = EISDIR;
            free(file);
            closedir(dir);
            return 0;
        }
    }
    closedir(dir);

    file->cacheoffset = -1;
    file->fileoffset = 0;

    if (file->write && (flags & O_APPEND)) {
        rc = lseek((int)file,0,SEEK_END);
        if (rc < 0 )
        {
            free(file);
            errno = EIO;
            return 0;
        }
    }

    mutex_lock(&file_mutex, TIMEOUT_BLOCK);
    file->next = openfiles;
    openfiles = file;
    mutex_unlock(&file_mutex);

    return (int)file;
}

int file_open(const char* pathname, int flags)
{
    return open_internal(pathname, flags, false);
}

void reown_file(int fd, struct scheduler_thread* owner)
{
    struct filedesc* f = (struct filedesc*)fd;
    f->process = owner;
}

int close(int fd)
{
    int rc = 0;
    struct filedesc* f = (struct filedesc*)fd;
    DEBUGF("close(%d)", fd);
    if (!f)
    {
        errno = EBADF;
        return -2;
    }
    if (f->write)
    {
        rc = fsync(fd);
        if (rc < 0)
            return rc * 10 - 3;
    }
    mutex_lock(&file_mutex, TIMEOUT_BLOCK);
    if (openfiles == f) openfiles = openfiles->next;
    else
        for (f = openfiles; f; f = f->next)
            if ((int)(f->next) == fd)
                f->next = f->next->next;
    mutex_unlock(&file_mutex);
    free((void*)fd);
    return 0;
}

int close_all_of_process(struct scheduler_thread* process)
{
    struct filedesc* f;
    struct filedesc* prev;
    int closed = 0;
    mutex_lock(&file_mutex, TIMEOUT_BLOCK);
    while (openfiles && openfiles->process == process)
    {
        prev = openfiles;
        openfiles = openfiles->next;
        if (openfiles->write) fsync((int)openfiles);
        free(prev);
        closed++;
    }
    for (f = openfiles; f; f = f->next)
        while (f->next && f->next->process == process)
        {
            prev = f->next;
            f->next = f->next->next;
            free(prev);
            closed++;
        }
    mutex_unlock(&file_mutex);
    return closed; /* return how many we did */
}

int fsync(int fd)
{
    struct filedesc* file = (struct filedesc*)fd;
    int rc = 0;

    DEBUGF("fsync(%d)", fd);

    if (!file) {
        errno = EBADF;
        return -2;
    }
    if (file->write) {
        /* flush sector cache */
        if ( file->dirty ) {
            rc = flush_cache(fd);
            if (rc < 0)
            {
                /* when failing, try to close the file anyway */
                fat_closewrite(&(file->fatfile), file->size, file->attr);
                return rc * 10 - 3;
            }
        }

        /* truncate? */
        if (file->trunc) {
            rc = ftruncate(fd, file->size);
            if (rc < 0)
            {
                /* when failing, try to close the file anyway */
                fat_closewrite(&(file->fatfile), file->size, file->attr);
                return rc * 10 - 4;
            }
        }

        /* tie up all loose ends */
        rc = fat_closewrite(&(file->fatfile), file->size, file->attr);
        if (rc < 0)
            return rc * 10 - 5;
    }
    return 0;
}

int remove(const char* name)
{
    int rc;
    int fd = open_internal(name, O_WRONLY, false);
    if (!fd) return - 1;

    struct filedesc* file = (struct filedesc*)fd;
    rc = fat_remove(&(file->fatfile));
    if ( rc < 0 ) {
        DEBUGF("Failed removing file: %d", rc);
        errno = EIO;
        return rc * 10 - 3;
    }

    file->size = 0;

    rc = close(fd);
    if (rc<0)
        return rc * 10 - 4;

    return 0;
}

int rename(const char* path, const char* newpath)
{
    int rc, fd;
    DIR* dir;
    char* nameptr;
    char* dirptr;
    struct filedesc* file;
    char newpath2[MAX_PATH];

    /* verify new path does not already exist */
    /* If it is a directory, errno == EISDIR if the name exists */
    fd = open_internal(newpath, O_RDONLY, true);
    if (fd) {
        close(fd);
        errno = EBUSY;
        return -1;
    }

    fd = open_internal(path, O_RDONLY, true);
    if (!fd) {
        errno = EIO;
        return -2;
    }

    /* extract new file name */
    nameptr = strrchr(newpath,'/');
    if (nameptr)
        nameptr++;
    else {
        close(fd);
        return - 3;
    }

    /* Extract new path */
    strcpy(newpath2, newpath);

    dirptr = strrchr(newpath2,'/');
    if(dirptr)
        *dirptr = 0;
    else {
        close(fd);
        return - 4;
    }

    dirptr = newpath2;

    if(strlen(dirptr) == 0) {
        dirptr = "/";
    }

    dir = opendir(dirptr);
    if(!dir) {
        close(fd);
        return - 5;
    }

    file = (struct filedesc*)fd;

    rc = fat_rename(&file->fatfile, &dir->fatdir, nameptr,
                    file->size, file->attr);
#ifdef HAVE_MULTIVOLUME
    if ( rc == -1) {
        close(fd);
        closedir(dir);
        DEBUGF("Failed renaming file across volumnes: %d", rc);
        errno = EXDEV;
        return -6;
    }
#endif
    if ( rc < 0 ) {
        close(fd);
        closedir(dir);
        DEBUGF("Failed renaming file: %d", rc);
        errno = EIO;
        return rc * 10 - 7;
    }

    rc = close(fd);
    if (rc<0) {
        closedir(dir);
        errno = EIO;
        return rc * 10 - 8;
    }

    rc = closedir(dir);
    if (rc<0) {
        errno = EIO;
        return rc * 10 - 9;
    }

    return 0;
}

int ftruncate(int fd, off_t size)
{
    int rc, sector;
    struct filedesc* file = (struct filedesc*)fd;

    sector = size / SECTOR_SIZE;
    if (size % SECTOR_SIZE)
        sector++;

    rc = fat_seek(&(file->fatfile), sector);
    if (rc < 0) {
        errno = EIO;
        return rc * 10 - 1;
    }

    rc = fat_truncate(&(file->fatfile));
    if (rc < 0) {
        errno = EIO;
        return rc * 10 - 2;
    }

    file->size = size;

    return 0;
}

static int flush_cache(int fd)
{
    int rc;
    struct filedesc* file = (struct filedesc*)fd;
    long sector = file->fileoffset / SECTOR_SIZE;

    DEBUGF("Flushing dirty sector cache");

    /* make sure we are on correct sector */
    rc = fat_seek(&(file->fatfile), sector);
    if ( rc < 0 )
        return rc * 10 - 3;

    rc = fat_readwrite(&(file->fatfile), 1, file->cache, true );

    if ( rc < 0 ) {
        if(file->fatfile.eof)
            errno = ENOSPC;

        return rc * 10 - 2;
    }

    file->dirty = false;

    return 0;
}

static int readwrite(int fd, void* buf, long count, bool write)
{
    long sectors;
    long i;
    long nread=0;
    struct filedesc* file;
    int rc, rc2;

    file = (struct filedesc*)fd;

    if (!file) {
        errno = EBADF;
        return -1;
    }

    if(file->attr & FAT_ATTR_DIRECTORY) {
        errno = EISDIR;
        return -1;
    }

    DEBUGF( "readwrite(%d,%lx,%ld,%s)",
             fd,(long)buf,count,write?"write":"read");

    /* attempt to read past EOF? */
    if (!write && count > file->size - file->fileoffset)
        count = file->size - file->fileoffset;

    /* any head bytes? */
    if ( file->cacheoffset != -1 ) {
        int offs = file->cacheoffset;
        int headbytes = MIN(count, SECTOR_SIZE - offs);

        if (write) {
            memcpy( file->cache + offs, buf, headbytes );
            file->dirty = true;
        }
        else {
            memcpy( buf, file->cache + offs, headbytes );
        }

        if (offs + headbytes == SECTOR_SIZE) {
            if (file->dirty) {
                rc = flush_cache(fd);
                if ( rc < 0 ) {
                    errno = EIO;
                    return rc * 10 - 2;
                }
            }
            file->cacheoffset = -1;
        }
        else {
            file->cacheoffset += headbytes;
        }

        nread = headbytes;
        count -= headbytes;
    }

    /* If the buffer has been modified, either it has been flushed already
     * (if (offs+headbytes == SECTOR_SIZE)...) or does not need to be (no
     * more data to follow in this call). Do NOT flush here. */

    /* read/write whole sectors right into/from the supplied buffer */
    sectors = count / SECTOR_SIZE;
    rc = 0;
    if ( sectors ) {
        if (((uint32_t)buf + nread) & (CACHEALIGN_SIZE - 1))
            for (i = 0; i < sectors; i++)
            {
                if (write) memcpy(file->cache, buf+nread+i*SECTOR_SIZE, SECTOR_SIZE);
                rc2 = fat_readwrite(&(file->fatfile), 1, file->cache, write );
                if (rc2 < 0)
                {
                    rc = rc2;
                    break;
                }
                else rc += rc2;
                if (!write) memcpy(buf+nread+i*SECTOR_SIZE, file->cache, SECTOR_SIZE);
            }
        else rc = fat_readwrite(&(file->fatfile), sectors, (unsigned char*)buf+nread, write );
        if ( rc < 0 ) {
            DEBUGF("Failed read/writing %ld sectors",sectors);
            errno = EIO;
            if(write && file->fatfile.eof) {
                DEBUGF("No space left on device");
                errno = ENOSPC;
            } else {
                file->fileoffset += nread;
            }
            file->cacheoffset = -1;
            /* adjust file size to length written */
            if ( write && file->fileoffset > file->size )
            {
                file->size = file->fileoffset;
            }
            return nread ? nread : rc * 10 - 4;
        }
        else {
            if ( rc > 0 ) {
                nread += rc * SECTOR_SIZE;
                count -= sectors * SECTOR_SIZE;

                /* if eof, skip tail bytes */
                if ( rc < sectors )
                    count = 0;
            }
            else {
                /* eof */
                count=0;
            }

            file->cacheoffset = -1;
        }
    }

    /* any tail bytes? */
    if ( count ) {
        if (write) {
            if ( file->fileoffset + nread < file->size ) {
                /* sector is only partially filled. copy-back from disk */
                DEBUGF("Copy-back tail cache");
                rc = fat_readwrite(&(file->fatfile), 1, file->cache, false );
                if ( rc < 0 ) {
                    DEBUGF("Failed writing");
                    errno = EIO;
                    file->fileoffset += nread;
                    file->cacheoffset = -1;
                    /* adjust file size to length written */
                    if ( file->fileoffset > file->size )
                    {
                        file->size = file->fileoffset;
                    }
                    return nread ? nread : rc * 10 - 5;
                }
                /* seek back one sector to put file position right */
                rc = fat_seek(&(file->fatfile), 
                              (file->fileoffset + nread) /
                              SECTOR_SIZE);
                if ( rc < 0 ) {
                    DEBUGF("fat_seek() failed");
                    errno = EIO;
                    file->fileoffset += nread;
                    file->cacheoffset = -1;
                    /* adjust file size to length written */
                    if ( file->fileoffset > file->size )
                    {
                        file->size = file->fileoffset;
                    }
                    return nread ? nread : rc * 10 - 6;
                }
            }
            memcpy( file->cache, (unsigned char*)buf + nread, count );
            file->dirty = true;
        }
        else {
            rc = fat_readwrite(&(file->fatfile), 1, file->cache,false);
            if (rc < 1 ) {
                DEBUGF("Failed caching sector");
                errno = EIO;
                file->fileoffset += nread;
                file->cacheoffset = -1;
                return nread ? nread : rc * 10 - 7;
            }
            memcpy( (unsigned char*)buf + nread, file->cache, count );
        }

        nread += count;
        file->cacheoffset = count;
    }

    file->fileoffset += nread;
    DEBUGF("fileoffset: %ld", file->fileoffset);

    /* adjust file size to length written */
    if ( write && file->fileoffset > file->size )
    {
        file->size = file->fileoffset;
    }

    return nread;
}

ssize_t write(int fd, const void* buf, size_t count)
{
    if (!((struct filedesc*)fd)->write) {
        errno = EACCES;
        return -1;
    }
    return readwrite(fd, (void *)buf, count, true);
}

ssize_t read(int fd, void* buf, size_t count)
{
    return readwrite(fd, buf, count, false);
}


off_t lseek(int fd, off_t offset, int whence)
{
    off_t pos;
    long newsector;
    long oldsector;
    int sectoroffset;
    int rc;
    struct filedesc* file = (struct filedesc*)fd;

    DEBUGF("lseek(%d,%ld,%d)",fd,offset,whence);

    if (!file) {
        errno = EBADF;
        return -1;
    }

    switch ( whence ) {
        case SEEK_SET:
            pos = offset;
            break;

        case SEEK_CUR:
            pos = file->fileoffset + offset;
            break;

        case SEEK_END:
            pos = file->size + offset;
            break;

        default:
            errno = EINVAL;
            return -2;
    }
    if ((pos < 0) || (pos > file->size)) {
        errno = EINVAL;
        return -3;
    }

    /* new sector? */
    newsector = pos / SECTOR_SIZE;
    oldsector = file->fileoffset / SECTOR_SIZE;
    sectoroffset = pos % SECTOR_SIZE;

    if ( (newsector != oldsector) ||
         ((file->cacheoffset==-1) && sectoroffset) ) {

        if ( newsector != oldsector ) {
            if (file->dirty) {
                rc = flush_cache(fd);
                if (rc < 0)
                    return rc * 10 - 5;
            }

            rc = fat_seek(&(file->fatfile), newsector);
            if ( rc < 0 ) {
                errno = EIO;
                return rc * 10 - 4;
            }
        }
        if ( sectoroffset ) {
            rc = fat_readwrite(&(file->fatfile), 1, file->cache ,false);
            if ( rc < 0 ) {
                errno = EIO;
                return rc * 10 - 6;
            }
            file->cacheoffset = sectoroffset;
        }
        else
            file->cacheoffset = -1;
    }
    else
        if ( file->cacheoffset != -1 )
            file->cacheoffset = sectoroffset;

    file->fileoffset = pos;

    return pos;
}

off_t filesize(int fd)
{
    struct filedesc* file = (struct filedesc*)fd;

    if (!file) {
        errno = EBADF;
        return -1;
    }

    return file->size;
}


#ifdef HAVE_HOTSWAP
/* release all file handles on a given volume "by force", to avoid leaks */
int release_files(int volume)
{
    struct filedesc* prev;
    int closed = 0;
    mutex_lock(&file_mutex, TIMEOUT_BLOCK);
#ifdef HAVE_MULTIVOLUME
    struct filedesc* f;
    while (openfiles && openfiles->fatfile.volume == volume)
    {
        prev = openfiles;
        openfiles = openfiles->next;
        free(prev);
        closed++;
    }
    for (f = openfiles; f; f = f->next)
        while (f->next && f->next->fatfile.volume == volume)
        {
            prev = f->next;
            f->next = f->next->next;
            free(prev);
            closed++;
        }
#else
    (void)volume;
    while (openfiles)
    {
        prev = openfiles;
        openfiles = openfiles->next;
        free(prev);
        closed++;
    }
#endif
    mutex_unlock(&file_mutex);
    return closed; /* return how many we did */
}
#endif /* #ifdef HAVE_HOTSWAP */