inode.c

Go to the documentation of this file.

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/smp_lock.h>
#include <linux/backing-dev.h>
#include <linux/slab.h>
#include <linux/statfs.h>
#include <asm/uaccess.h>

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



#define MUMUFS_MAGIC    0x710110


MODULE_LICENSE( "GPL" );
MODULE_AUTHOR( "Sergey Satskiy" );
MODULE_DESCRIPTION( "MuMu filesystem supports multiple writers and multiple readers" );



struct kmem_cache *     mumufs_storage_cache;


static struct super_operations              mumufs_ops;
static struct address_space_operations      mumufs_aops;
static struct inode_operations              mumufs_file_inode_operations;
static struct inode_operations              mumufs_dir_inode_operations;
static struct file_operations               mumufs_file_operations;
static struct backing_dev_info              mumufs_backing_dev_info;


static struct backing_dev_info              mumufs_backing_dev_info =
{
    .ra_pages       = 0,                                                /* No readahead */
    .capabilities   = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
                      /*
                      BDI_CAP_MAP_DIRECT    | BDI_CAP_MAP_COPY |
                      BDI_CAP_READ_MAP      | BDI_CAP_WRITE_MAP,
                      */
};



static struct inode *  mumufs_get_inode( struct super_block *  sb,
                                         int                   mode,
                                         dev_t                 dev )
{
    if ( S_ISREG( mode ) || S_ISDIR( mode ) || S_ISLNK( mode ) )
    {
        struct inode *      inode = NULL;

        /* Check the mode - it cannot be executable for a regular file */
        if ( S_ISREG( mode ) && (mode & S_IXUGO) ) return NULL;

        inode = new_inode( sb );
        if ( inode != NULL )
        {
            inode->i_mode = mode;
            inode->i_uid = current_fsuid();
            inode->i_gid = current_fsgid();
            inode->i_blocks = 0;
            inode->i_mapping->a_ops = &mumufs_aops;
            inode->i_mapping->backing_dev_info = &mumufs_backing_dev_info;
            inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
            inode->i_private = NULL;

            switch ( mode & S_IFMT )
            {
                case S_IFREG:

                    {
                        int     records = atomic_read( & ((struct mumu_mount_data *)(sb->s_fs_info))->number_of_entries );
                        if ( records >= ((struct mumu_mount_data *)(sb->s_fs_info))->max_entries )
                        {
                            iput( inode );
                            return NULL;
                        }
                    }

                    inode->i_op = & mumufs_file_inode_operations;
                    inode->i_fop = & mumufs_file_operations;

                        /* Alloc the node storage */
                    inode->i_private = mumufs_allocate_storage();
                    if ( inode->i_private == NULL )
                    {
                        iput( inode );
                        return NULL;
                    }

                        /* Increment # of entries */
                    atomic_inc( & ((struct mumu_mount_data *)(sb->s_fs_info))->number_of_entries );
                    break;
                case S_IFDIR:
                    inode->i_op = & mumufs_dir_inode_operations;
                    inode->i_fop = & simple_dir_operations;
                        /* directory inodes start off with i_nlink == 2 (for "." entry) */
                    inode->i_nlink++;
                    break;
                case S_IFLNK:
                    inode->i_op = & page_symlink_inode_operations;
                    break;
                default:
                        /* It is impossible - we have 'if' at the beginning */
                    break;
            }
        }
        return inode;
    }

    return NULL;
}


static int mumufs_inode_unlink( struct inode *      dir,
                                struct dentry *     dentry )
{
    if ( (dentry->d_inode->i_private != NULL) &&
         ((dentry->d_inode->i_mode & S_IFMT) == S_IFREG) )
    {
            /* It was a regular file. We need to del all the related data:  */
            /* data buffer and the node itself from the list of SB nodes    */
        mumufs_free_storage( (struct mumufs_storage *)( dentry->d_inode->i_private ) );
        dentry->d_inode->i_private = NULL;

            /* Decrement # of entries               */
        atomic_dec( & ((struct mumu_mount_data *)(dir->i_sb->s_fs_info))->number_of_entries );
    }

        /* TODO: Do I need the following?   */
        /* d_invalidate( dentry );          */
        /* iput( dentry->d_inode );         */
    return simple_unlink( dir, dentry );
}




static int  mumufs_mknod( struct inode *     dir,
                          struct dentry *    dentry,
                          int                mode,
                          dev_t              dev )
{
    struct inode *      inode = mumufs_get_inode( dir->i_sb, mode, dev );

    if ( inode != NULL )
    {
        if ( dir->i_mode & S_ISGID )
        {
            inode->i_gid = dir->i_gid;
            if ( S_ISDIR( mode ) )
            {
                inode->i_mode |= S_ISGID;
            }
        }
        d_instantiate( dentry, inode );
        dget( dentry );        /* Extra count - pin the dentry in core */
        return 0;
    }
    return -ENOSPC;
}




static int mumufs_mkdir( struct inode *     dir,
                         struct dentry *    dentry,
                         int                mode )
{
    int         retval = mumufs_mknod( dir, dentry, mode | S_IFDIR, 0 );

    if ( !retval )
    {
        dir->i_nlink++;
    }
    return retval;
}




static int mumufs_create( struct inode *        dir,
                          struct dentry *       dentry,
                          int                   mode,
                          struct nameidata *    nd )
{
    return mumufs_mknod( dir, dentry, mode | S_IFREG, 0 );
}




static int mumufs_symlink( struct inode *   dir,
                           struct dentry *  dentry,
                           const char *     symname )
{
    struct inode *      inode = NULL;
    int                 error = -ENOSPC;

    inode = mumufs_get_inode( dir->i_sb, S_IFLNK | S_IRWXUGO, 0 );
    if ( inode != NULL )
    {
        error = page_symlink( inode, symname, strlen( symname ) + 1 );
        if ( !error )
        {
            if ( dir->i_mode & S_ISGID )
            {
                inode->i_gid = dir->i_gid;
            }
            d_instantiate( dentry, inode );
            dget( dentry );
        }
        else
        {
            iput( inode );
        }
    }

    return error;
}


static int  mumufs_inode_setattr( struct dentry *  dentry,
                                  struct iattr *   iattr)
{
    struct inode *      inode = dentry->d_inode;
    int                 ret;

    ret = inode_change_ok( inode, iattr );
    if ( ret != 0 )
    {
        return ret;
    }

    /* Forbid to make regular file executable                     */
    /* No need to check for file type because this function is    */
    /* used for regular inodes only                               */
    if ( iattr->ia_valid & ATTR_MODE )
    {
        if ( iattr->ia_mode & S_IXUGO ) return -EINVAL;
    }

    return inode_setattr( inode, iattr );
}


static loff_t  mumufs_no_llseek( struct file *  file,
                                 loff_t         offset,
                                 int            origin )
{
    /* seek operation is illegal for mumufs.                                 */
    /* There is ESPIPE return code which is used for illegal seek operations */
    /* for pipes however mumufs is not a pipe so it returns EINVAL           */
    return -EINVAL;
}


    /* Links will not work without this  */
static struct address_space_operations      mumufs_aops =
{
    .readpage       = simple_readpage,
    .write_begin    = simple_write_begin,
    .write_end      = simple_write_end,
};



static struct file_operations               mumufs_file_operations =
{
    .open       = mumufs_file_open,
    .read       = mumufs_file_read,
    .write      = mumufs_file_write,
    .release    = mumufs_file_release,
    .llseek     = mumufs_no_llseek,

    .poll       = mumufs_file_poll,     /* select & poll support */
};



static struct inode_operations              mumufs_file_inode_operations =
{
    .getattr    = simple_getattr,
    .setattr    = mumufs_inode_setattr,
};



static struct inode_operations              mumufs_dir_inode_operations =
{
    .create     = mumufs_create,
    .lookup     = simple_lookup,
    .link       = simple_link,
    .unlink     = mumufs_inode_unlink,
    .symlink    = mumufs_symlink,
    .mkdir      = mumufs_mkdir,
    .rmdir      = simple_rmdir,
    .mknod      = mumufs_mknod,
    .rename     = simple_rename,
};


static void mumufs_put_super( struct super_block *  sb )
{
    mumufs_remove_mount_info( sb );     /* /proc/ entry removal           */
    mumufs_umount_cleanup( sb );
    kfree( sb->s_fs_info );             /* mumu_mount_data removal        */

    /* TODO: Do I need to shrink this stuff?    */
    /*    shrink_dcache_sb( sb );               */
    /*    invalidate_inodes( sb );              */
}


static int mumufs_statfs( struct dentry *  dentry, struct kstatfs *  buf )
{
    struct super_block *        sb = dentry->d_sb;
    struct mumu_mount_data *    d = (struct mumu_mount_data *)( sb->s_fs_info );

    buf->f_type = MUMUFS_MAGIC;
    buf->f_bsize = 1;
    buf->f_blocks = d->max_entries;
    buf->f_bfree = d->max_entries - d->number_of_entries.counter;
    buf->f_bavail = buf->f_bfree;
    buf->f_files = buf->f_blocks;
    buf->f_ffree = buf->f_bfree;
    buf->f_namelen = NAME_MAX;
    buf->f_frsize = 1;

    return 0;
}

static struct super_operations              mumufs_ops =
{
    .statfs         = mumufs_statfs,
    .drop_inode     = generic_delete_inode,
    .put_super      = mumufs_put_super,
    .show_options   = mumufs_show_options,
};



static int mumufs_fill_super( struct super_block *      sb,
                              void *                    data,
                              int                       silent )
{
    struct inode *              inode;
    struct dentry *             root;
    struct mumu_mount_data *    mount_data;


    mount_data = kmalloc( sizeof( struct mumu_mount_data ), GFP_KERNEL );
    if ( mount_data == NULL )
    {
        return -ENOMEM;
    }

    memset( mount_data, 0, sizeof( struct mumu_mount_data ) );
    if ( mumufs_init_mount_data( mount_data ) != 0 )
    {
        kfree( mount_data );
        return -ENOMEM;
    }

    if ( !mumufs_parse_opt( (char *)data, mount_data ) )
    {
        kfree( mount_data );
        return -EINVAL;
    }

    sb->s_maxbytes = MAX_LFS_FILESIZE;
    sb->s_blocksize = 1;
    sb->s_magic = MUMUFS_MAGIC;
    sb->s_op = &mumufs_ops;
    sb->s_time_gran = 1;
    sb->s_fs_info = mount_data;

    inode = mumufs_get_inode( sb, S_IFDIR | 0755, 0 );
    if ( !inode )
    {
        kfree( mount_data );
        return -ENOMEM;
    }

    root = d_alloc_root( inode );
    if ( !root )
    {
        kfree( mount_data );
        iput( inode );
        return -ENOMEM;
    }
    sb->s_root = root;

        /* It is the point when a file system is mounted */
    {
        int     ret = mumufs_create_mount_info( sb );
        if ( ret != 0 )
        {
            kfree( mount_data );
            iput( inode );
            dput( root );
            return ret;
        }
    }

    return 0;
}



int  mumufs_get_sb( struct file_system_type *      fs_type,
                    int                            flags,
                    const char *                   dev_name,
                    void *                         data,
                    struct vfsmount *              mnt )
{
    int     ret;

    ret = get_sb_nodev( fs_type, flags, data, mumufs_fill_super, mnt );
    if ( ret == 0 )
    {
        struct super_block *        sb = mnt->mnt_sb;

        /* Memorize vfsmount pointer. It is required to display the mount */
        /* point in the /proc/mumufs/...                                  */
        ((struct mumu_mount_data *)(sb->s_fs_info))->mount = mnt;
    }
    return ret;
}


void  mumufs_kill_super( struct super_block *  sb )
{
    struct inode *      inode;
    struct inode *      next_i;

        /* Iterate over the fs inodes */
    list_for_each_entry_safe(inode, next_i, & sb->s_inodes, i_sb_list)
    {
        if ( inode->i_mode && S_IFREG )
        {
            if ( inode->i_private != NULL )
            {
                mumufs_free_storage( (struct mumufs_storage *)( inode->i_private ) );
            }
        }
    }

    return kill_litter_super( sb );
}


static struct file_system_type      mumufs_fs_type =
{
    .owner      = THIS_MODULE,
    .name       = "mumufs",
    .get_sb     = mumufs_get_sb,
    .kill_sb    = mumufs_kill_super,
};



static int __init init_mumufs_fs( void )
{
    int         ret;

    mumufs_storage_cache = kmem_cache_create( "mumu_storage", sizeof( struct mumufs_storage ),
                                              0, SLAB_HWCACHE_ALIGN, NULL );
    if ( mumufs_storage_cache == NULL )
    {
        return -EFAULT;
    }

    if ( mumufs_initialise_proc_entries() != 0 )
    {
        kmem_cache_destroy( mumufs_storage_cache );
        return -EFAULT;
    }

    ret = register_filesystem( &mumufs_fs_type );
    if ( ret != 0 )
    {
        kmem_cache_destroy( mumufs_storage_cache );
        mumufs_remove_proc_entries();
    }

    return ret;
}


static void __exit exit_mumufs_fs( void )
{
    mumufs_remove_proc_entries();
    unregister_filesystem( &mumufs_fs_type );
    kmem_cache_destroy( mumufs_storage_cache );
    return;
}


module_init( init_mumufs_fs )
module_exit( exit_mumufs_fs )