root/morphix/trunk/mini_fo/file.c

/*
 * Copyright (c) 1997-2004 Erez Zadok <ezk@cs.stonybrook.edu>
 * Copyright (c) 2001-2004 Stony Brook University
 *
 * For specific licensing information, see the COPYING file distributed with
 * this package, or get one from ftp://ftp.filesystems.org/pub/fistgen/COPYING.
 *
 * This Copyright notice must be kept intact and distributed with all
 * fistgen sources INCLUDING sources generated by fistgen.
 */
/*
 *  $Id: file.c 1364 2004-12-04 10:18:10Z alextreme $
 *
 * Parts of this file have been copied from mini_fo 
 * Copyright (C) 2004 Markus Klotzbuecher <mk@creamnet.de>
 *
 * MODIFICATIONS:
 * 2004-08      Olivier Evalet  <evaleto at programmers dot ch>
 *                      implemented fsync
 *                      refactoring of readdir
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#ifdef FISTGEN
# include "fist_mini_fo.h"
#endif /* FISTGEN */
#include "fist.h"
#include "mini_fo.h"


/*******************
 * File Operations *
 *******************/


STATIC loff_t
mini_fo_llseek(file_t *file, loff_t offset, int origin)
{
        loff_t err;
        file_t *lower_file = NULL;

        print_entry_location();
        if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {
                /* Check if trying to llseek from a directory */
                err = -EISDIR;
                goto out;
        }
        if (FILE_TO_PRIVATE(file) != NULL) {     // XXX: ZH: this is wrong?: in this case ASSERT is not in ifndef... Put ASSERT before the if statement, kill if statement
                lower_file = FILE_TO_LOWER_STO(file);
                if(!lower_file)
                lower_file = FILE_TO_LOWER(file);
        }

        fist_dprint(6, "mini_fo_llseek: file=%p, offset=0x%x, origin=%d\n",
                    file, offset, origin);

        ASSERT(lower_file != NULL);

        /* always set lower position to this one */
        lower_file->f_pos = file->f_pos;


#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
        if (file->f_reada) { /* update readahead information if needed */
                lower_file->f_reada = file->f_reada;
                lower_file->f_ramax = file->f_ramax;
                lower_file->f_raend = file->f_raend;
                lower_file->f_ralen = file->f_ralen;
                lower_file->f_rawin = file->f_rawin;
        }
        ASSERT(lower_file->f_reada == file->f_reada);
        ASSERT(lower_file->f_ramax == file->f_ramax);
        ASSERT(lower_file->f_raend == file->f_raend);
        ASSERT(lower_file->f_ralen == file->f_ralen);
        ASSERT(lower_file->f_rawin == file->f_rawin);
#else
        memcpy(&(lower_file->f_ra), &(file->f_ra), sizeof(struct file_ra_state)); // XXX: ZH: this a new structure.
#endif

        if (lower_file->f_op && lower_file->f_op->llseek)
                err = lower_file->f_op->llseek(lower_file, offset, origin);
        else
                err     = generic_file_llseek(lower_file, offset, origin);

        if (err < 0)
                goto out;

        if (err != file->f_pos) {
                file->f_pos = err;
                // ION maybe this?
                //      file->f_pos = lower_file->f_pos;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
                file->f_reada = 0;
#endif
                file->f_version ++ ;//
        }
out:
        print_exit_status(err);
        return err;
}



STATIC ssize_t
mini_fo_read(file_t *file, char *buf, size_t count, loff_t *ppos)
{
        int err = -EINVAL;
        file_t *lower_file = NULL;
        loff_t pos = *ppos;

        print_entry_location();
//      printk ("file=%p count=%d pos=%p, pos=%d\n",file,count,ppos,*ppos);

        if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {
                /* Check if trying to read from a directory */
                /* printk(KERN_CRIT "mini_fo_read: ERROR: trying to read data from a directory.\n"); */
                err = -EISDIR;
                goto out;
        }

        if (FILE_TO_PRIVATE(file) != NULL){   // XXX: ZH: this is wrong?: in this case ASSERT is not in ifndef..Put ASSERT before the if statement, kill if statement
                lower_file = FILE_TO_LOWER_STO(file);
                if (!lower_file)
                        lower_file = FILE_TO_LOWER(file);
        }
        ASSERT(lower_file != NULL);

        if (!lower_file->f_op || !lower_file->f_op->read)
                goto out;

        err = lower_file->f_op->read(lower_file, buf, count, &pos);

        if (err >= 0) {
                /* atime should also be updated for reads of size zero or more */
                fist_copy_attr_atime(file->f_dentry->d_inode,
                                     lower_file->f_dentry->d_inode);
        }

        // MAJOR HACK
        /*
         * because pread() does not have any way to tell us that it is
         * our caller, then we don't know for sure if we have to update
         * the file positions.  This hack relies on read() having passed us
         * the "real" pointer of its struct file's f_pos field.
         */
        
        /*
         * oe: since the 2.6.8 the syscall as changed. !!FIXME!!
         *     fs/read_write.c L283     
         */
        if (ppos == &file->f_pos)
                lower_file->f_pos = *ppos = pos;
        else{
                lower_file->f_pos = *ppos = pos;
        }

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
        if (lower_file->f_reada) { /* update readahead information if needed */
                file->f_reada = lower_file->f_reada;
                file->f_ramax = lower_file->f_ramax;
                file->f_raend = lower_file->f_raend;
                file->f_ralen = lower_file->f_ralen;
                file->f_rawin = lower_file->f_rawin;
        }
#else
        memcpy(&(file->f_ra), &(lower_file->f_ra), sizeof(struct file_ra_state));
#endif

out:
        print_exit_status(err);
        return err;
}


/* this mini_fo_write() does not modify data pages! */
STATIC ssize_t
mini_fo_write(file_t *file, const char *buf, size_t count, loff_t *ppos)
{
        int err = -EINVAL;
        file_t *lower_file = NULL;
        inode_t *inode;
        inode_t *lower_inode;
        loff_t pos = *ppos;

        print_entry_location();
        if (FILE_TO_PRIVATE(file) != NULL){  // XXX: ZH: this is wrong?: in this case ASSERT is not in ifndef... Put ASSERT before the if statement, kill if statement
                lower_file = FILE_TO_LOWER_STO(file);
                if (!lower_file){
                        /* This is bad! We have no storage file to write to. This should never
                         * happen because if a file is opened for writing, a copy should have
                         * been made earlier.
                         */
                        printk(KERN_CRIT "mini_fo: write : ERROR, no storage file to write.\n");
                        err = -EPERM;
                        goto out;
                }
        }

        inode = file->f_dentry->d_inode;
        lower_inode = INODE_TO_LOWER_STO(inode);
        if(!lower_inode) {
                printk(KERN_CRIT "mini_fo: write: no sto inode found, not good.\n");
                goto out;
        }

        if (!lower_file->f_op || !lower_file->f_op->write)
                goto out;

        /* adjust for append -- seek to the end of the file */
        if (file->f_flags & O_APPEND)
                pos = inode->i_size;

        err = lower_file->f_op->write(lower_file, buf, count, &pos);

        /*
         * copy ctime and mtime from lower layer attributes
         * atime is unchanged for both layers
         */
        if (err >= 0  )
                fist_copy_attr_times(inode, lower_inode);

        /*
         * XXX: MAJOR HACK
         *
         * because pwrite() does not have any way to tell us that it is
         * our caller, then we don't know for sure if we have to update
         * the file positions.  This hack relies on write() having passed us
         * the "real" pointer of its struct file's f_pos field.
         */
        
        /*
         * oe: since the 2.6.9 the syscall as changed. !!FIXME!!
         *     fs/read_write.c L301     
         */
        
        if (ppos == &file->f_pos)
                lower_file->f_pos = *ppos = pos;
        else
                lower_file->f_pos = *ppos = pos;

        /* update this inode's size */
        if (pos > inode->i_size)
                inode->i_size = pos;

out:
        print_exit_status(err);
        return err;
}


/* Global variable to hold a file_t pointer.
 * This serves to allow mini_fo_filldir64 function to know which file is beeing
 * read, which is required for two reasons:
 *
 *   - be able to call wol functions in order to avoid listing deleted base files.
 *
 *   - if we're reading a directory which is in state 1, we need to maintain a list
 *     (in mini_fo_filldir64) of which files allready have been copied to userspace,
 *     to detect files existing in base and storage and not list them twice.
 */
STATIC file_t *mini_fo_filldir_file;

/* mainly copied from fs/readdir.c */
STATIC int
mini_fo_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
                  ino_t ino, unsigned int d_type)
{
        struct linux_dirent64 * dirent, d;
        struct mini_fo_getdents_callback * buf = (struct mini_fo_getdents_callback *) __buf;
        int reclen, err;
        file_t* file = buf->file;

        /* check if we are merging the contents of storage and base */
        if(file && DENTRY_TO_PRIVATE(file->f_dentry)->state == 1) {
                /* check if we are still reading storage contents, if
                 * yes, we just save the name of the file for duplicate
                 * checking later. */
                int tmp = strlen(WOL_FILENAME);
                if(tmp  == namlen) {
                        if(!strncmp(name, WOL_FILENAME, namlen))
                                return 0;
                }

                if(!FILE_TO_PRIVATE(file)->rd.sto_done) {
                        /* put file into ndl list */
                        if(ndl_add_entry(&FILE_TO_PRIVATE(file)->rd, name, namlen))
                                printk(KERN_CRIT "mini_fo_filldir64: Error adding to ndl.\n");
                } else {
                        /* check if file has been deleted */
                        if(wol_check_entry(file->f_dentry->d_inode, name, namlen)) {
                                return 0;
                        }
                        /* do duplicate checking */
                        if(ndl_check_entry(&FILE_TO_PRIVATE(file)->rd, name, namlen))
                                return 0;
                }
        }

#if 0
        reclen = ROUND_UP64(NAME_OFFSET(dirent) + namlen + 1);

        buf->getdents->error = -EINVAL;/* only used if we fail.. */
        if (reclen > buf->getdents->count)
                return -EINVAL;
        dirent = buf->getdents->previous;
        if (dirent) {
                d.d_off = offset;
                copy_to_user(&dirent->d_off, &d.d_off, sizeof(d.d_off));
        }
        dirent = buf->getdents->current_dir;
        buf->getdents->previous = dirent;
        memset(&d, 0, NAME_OFFSET(&d));
        d.d_ino = ino;
        d.d_reclen = reclen;
        d.d_type = d_type;
        copy_to_user(dirent, &d, NAME_OFFSET(&d));
        copy_to_user(dirent->d_name, name, namlen);
        put_user(0, dirent->d_name + namlen);
        ((char *) dirent) += reclen;
        //dirent=(struct linux_dirent64 *) ((char *) dirent) + reclen;
        buf->getdents->current_dir = dirent;
        buf->getdents->count -= reclen;
        return 0;
#else
        err = buf->filldir((void*)buf->getdents, name, namlen, offset, ino, d_type);
        if (err >= 0) {
                buf->entries_written++;
        }
        return err;     
        
#endif  
}



STATIC int
mini_fo_readdir(file_t *file, void *dirent, filldir_t filldir)
{
        int err = 0;/* mk: ??? -ENOTDIR; */
        file_t *lower_file = NULL;
        file_t *lower_sto_file = NULL;
        inode_t *inode;
        int oldcount;

#if defined(FIST_FILTER_NAME) || defined(FIST_FILTER_SCA) || 1
        struct mini_fo_getdents_callback buf;
#endif /* FIST_FILTER_NAME || FIST_FILTER_SCA */

        print_entry_location();

        buf.getdents= (struct getdents_callback64 *) dirent;
        buf.file        = file;
        buf.filldir     = filldir;
        
        oldcount = buf.getdents->count;
        inode = file->f_dentry->d_inode;

        FILE_TO_PRIVATE(file)->rd.sto_done = 0;
        if (FILE_TO_PRIVATE(file) != NULL) {
                if(FILE_TO_LOWER_STO(file)) { /* && (FILE_TO_LOWER_STO(file)->f_pos < INODE_TO_LOWER_STO(inode)->i_size)) { */
                        lower_sto_file = FILE_TO_LOWER_STO(file);
                        err = vfs_readdir(lower_sto_file, mini_fo_filldir64, (void *) &buf);
                        file->f_pos = lower_sto_file->f_pos;
                        if (err > 0)
                                fist_copy_attr_atime(inode, lower_sto_file->f_dentry->d_inode);

                }
                FILE_TO_PRIVATE(file)->rd.sto_done = 1;

                if(FILE_TO_LOWER(file)) { /* && (FILE_TO_LOWER(file)->f_pos < INODE_TO_LOWER(inode)->i_size)) { */
                        lower_file = FILE_TO_LOWER(file);
                        err = vfs_readdir(lower_file, mini_fo_filldir64, (void *) &buf);
                        file->f_pos = lower_file->f_pos;
                        if (err > 0)
                                fist_copy_attr_atime(inode, lower_file->f_dentry->d_inode);
                }
        }
        /* mk:
         * we need to check if all the directory data has been copied to userspace,
         * or if we will be called again by userspace to complete the operation.
         */
        if(buf.getdents->count == oldcount) {
                ndl_put_list(&FILE_TO_PRIVATE(file)->rd);
        }

        fist_checkinode(inode, "post mini_fo_readdir");
        print_exit_status(err);

        /* unset this, safe */
        mini_fo_filldir_file = NULL;    
        return err;
}


STATIC unsigned int
mini_fo_poll(file_t *file, poll_table *wait)
{
        unsigned int mask = DEFAULT_POLLMASK;
        file_t *lower_file = NULL;

        print_entry_location();
        if (FILE_TO_PRIVATE(file) != NULL){  // XXX: ZH: this is wrong?: in this case ASSERT is not in ifndef... Put ASSERT before the if statement, kill if statement          
                if(DENTRY_TO_PRIVATE(file->f_dentry)->state == STATE_FILE_UNMODIFIED) {
                        lower_file = FILE_TO_LOWER(file);
                }else{
                        lower_file = FILE_TO_LOWER_STO(file);
                }                       

        }
        ASSERT(lower_file != NULL);

        if (!lower_file->f_op || !lower_file->f_op->poll)
                goto out;

        mask = lower_file->f_op->poll(lower_file, wait);

out:
        print_exit_status(mask);
        return mask;
}


STATIC int
mini_fo_ioctl(inode_t *inode, file_t *file, unsigned int cmd, unsigned long arg)
{
        int err = 0;            /* don't fail by default */
        file_t *lower_file = NULL;
        vfs_t *this_vfs;
        vnode_t *this_vnode;
        int val;
#ifdef FIST_COUNT_WRITES
        extern unsigned long count_writes, count_writes_middle;
#endif /* FIST_COUNT_WRITES */

        print_entry_location();

        this_vfs = inode->i_sb;
        this_vnode = inode;

        /* check if asked for local commands */
        switch (cmd) {
        case FIST_IOCTL_GET_DEBUG_VALUE:
                val = fist_get_debug_value();
                printk("IOCTL GET: send arg %d\n", val);
                err = put_user(val, (int *) arg);
#ifdef FIST_COUNT_WRITES
                printk("COUNT_WRITES:%lu:%lu\n", count_writes, count_writes_middle);
#endif /* FIST_COUNT_WRITES */
                break;

        case FIST_IOCTL_SET_DEBUG_VALUE:
                err = get_user(val, (int *) arg);
                if (err)
                        break;
                fist_dprint(6, "IOCTL SET: got arg %d\n", val);
                if (val < 0 || val > 20) {
                        err = -EINVAL;
                        break;
                }
                fist_set_debug_value(val);
                break;

                /* add non-debugging fist ioctl's here */
                

    default:
                if (FILE_TO_PRIVATE(file) != NULL) {     // XXX: ZH: this is wrong?: in this case ASSERT is not in ifndef... Put ASSERT before the if statement, kill if statement
                        lower_file = FILE_TO_LOWER(file);
                }
                /* pass operation to lower filesystem, and return status */
                if (lower_file && lower_file->f_op && lower_file->f_op->ioctl)
                        err = lower_file->f_op->ioctl(INODE_TO_LOWER(inode), lower_file, cmd, arg);
                else
                        err     = -ENOTTY;      /* this is an unknown ioctl */
        } /* end of outer switch statement */

        print_exit_status(err);
        return err;
}


/* FIST-LITE special version of mmap */
STATIC int
mini_fo_mmap(file_t *file, vm_area_t *vma)
{
        int err = 0;
        file_t *lower_file = NULL;
        inode_t *inode;
        inode_t *lower_inode;

        print_entry_location();
        if (FILE_TO_PRIVATE(file) != NULL){   // XXX: ZH: this is wrong?: WHERE IS ASSERT IN THIS CASE??? Put ASSERT before the if statement, kill if statement
                lower_file = FILE_TO_LOWER_STO(file);
                if (!lower_file)
                        lower_file = FILE_TO_LOWER(file);
        }

        ASSERT(lower_file != NULL);
        ASSERT(lower_file->f_op != NULL);
        if (lower_file->f_op->mmap == NULL) {
            err = -1;
            return err;
        }
// These ASSERT's are insane: they don't abort and aren't used to abort!
        
        ASSERT(lower_file->f_op->mmap != NULL);

        vma->vm_file