file.c

Go to the documentation of this file.

#include "file.h"
#include "storage.h"
#include "mountdata.h"


#include <linux/list.h>
#include <linux/rwsem.h>
#include <linux/fs.h>
#include <asm/uaccess.h>



int     mumufs_file_open( struct inode *  inode, struct file *  file )
{
    int     RetVal = generic_file_open( inode, file );
    if ( RetVal != 0 )
    {
        return RetVal;
    }

        /*
         * private_data stores the last read version of a block.
         * 0 - nothing has been read yet
         */
    file->private_data = 0;
    return 0;
}


int     mumufs_file_release( struct inode *  inode, struct file *  file )
{
    struct mumufs_storage *        storage = (struct mumufs_storage *)(inode->i_private);

    if ( storage == NULL )
    {
        /* It is basically a problem however there is nothing to do */
        #ifdef DEBUG
        printk( "MUMU: mumufs_storage is not available for a file when it is closed.\n" );
        #endif
        return 0;
    }

    return 0;
}


ssize_t mumufs_file_read( struct file *  file, char *  buffer, size_t  size, loff_t *  offset )
{
    struct inode *              node = file->f_dentry->d_inode;
    struct mumufs_storage *     storage = (struct mumufs_storage *)(node->i_private);

    #ifdef DEBUG
    mount_data->last_op     = MUMU_READ;
    mount_data->last_bytes  = size;
    mount_data->last_offset = *offset;
    #endif

    #ifdef DEBUG
    if ( storage == NULL )
    {
        /* It should never happened */
        return -EINVAL;
    }
    #endif

        /* I support block oriented read/write so the offset must be 0 */
    if ( *offset != 0 ) return -EINVAL;

  Loop:
    down_read( & storage->buffer_lock );

    if ( size < storage->buffer_size )
    {
        /* The user provided too small buffer */
        up_read( & storage->buffer_lock );
        return -EINVAL;
    }

    if ( (storage->buffer_version != 0) &&                   /* There are data available     */
         (file->private_data != storage->buffer_version) )   /* New data block is available  */
    {
        int     bytes_copied = storage->buffer_size;

        if ( copy_to_user( buffer, storage->buffer, bytes_copied ) != 0 )
        {
            bytes_copied = -EINVAL;
        }
        else
        {
                /* Save the version of the read block */
            file->private_data = storage->buffer_version;
            node->i_atime = CURRENT_TIME;
        }

        up_read( & storage->buffer_lock );
        return bytes_copied;
    }


        /*
         * There is nothing to read because: - 0 bytes available
         *                                   - no "fresh" data
         */
    if ( file->f_flags & O_NONBLOCK )   /* Not required to block */
    {
        up_read( & storage->buffer_lock );
        return -EAGAIN;
    }

        /* It is blocking I/O                                                 */
        /* I think it is safe to compare buffer version without taking a lock */
    up_read( & storage->buffer_lock );
    if ( wait_event_interruptible( storage->blocked_readers,
                                   (storage->buffer_version != file->private_data) ) != 0 )
    {
        return -ERESTARTSYS;
    }
    goto Loop;
}



ssize_t mumufs_file_write( struct file *  file, const char *  buffer, size_t  size, loff_t *  offset )
{
    struct inode *              node = file->f_dentry->d_inode;
    struct mumufs_storage *     storage = (struct mumufs_storage *)(node->i_private);
    struct mumu_mount_data *    mount_data = (struct mumu_mount_data *)(file->f_dentry->d_sb->s_fs_info);
    unsigned char *             kernel_buffer = NULL;

    #ifdef DEBUG
    mount_data->last_op     = MUMU_WRITE;
    mount_data->last_bytes  = size;
    mount_data->last_offset = *offset;
    #endif

    #ifdef DEBUG
    if ( storage == NULL )
    {
        /* It should never happened */
        return -EINVAL;
    }
    #endif

        /* I support block oriented read/write so the offset must be 0 */
    if ( *offset != 0 )                       return -EINVAL;
    if ( size > mount_data->max_block_size )  return -EINVAL;

        /* Buffer is required because the copying could be interrupted */
    kernel_buffer = kmalloc( size, GFP_KERNEL );
    if ( kernel_buffer == NULL )             return -ENOSPC;
    if ( copy_from_user( kernel_buffer, buffer, size ) != 0 )
    {
        kfree( kernel_buffer );
        return -EFAULT;
    }

    down_write( & storage->buffer_lock );

    if ( storage->buffer != NULL )
    {
        kfree( storage->buffer );
    }
    storage->buffer = kernel_buffer;
    storage->buffer_size = size;

        /* Update the block version */
    if ( ++(storage->buffer_version) == 0 )
    {
        ++(storage->buffer_version);
    }

    node->i_size = size;            /* File size update    */
    node->i_mtime = CURRENT_TIME;   /* Modification time   */
    node->i_blocks = 1;             /* Size in blocks      */
    node->i_bytes = size;           /* Used bytes          */

    up_write( & storage->buffer_lock );

        /* Wake up all the reades */
    wake_up_interruptible( & storage->blocked_readers );
    return size;
}



unsigned int  mumufs_file_poll( struct file *  file, struct poll_table_struct *  poll_table )
{
    unsigned int                mask = POLLOUT | POLLWRNORM;    /* Write operations are always welcomed */
    struct inode *              node = file->f_dentry->d_inode;
    struct mumufs_storage *     storage = (struct mumufs_storage *)(node->i_private);

    #ifdef DEBUG
    if ( storage == NULL )
    {
        return POLLERR;
    }
    #endif

        /* One of the required actions. */
    poll_wait( file, & storage->blocked_readers, poll_table );

    down_read( & storage->buffer_lock );
    if ( (storage->buffer_version != 0) &&                   /* There are data in the block */
         (file->private_data != storage->buffer_version) )   /* New block is available      */
    {
        mask |= POLLIN | POLLRDNORM;
    }
    up_read( & storage->buffer_lock );

    return mask;
}