procfs.c

Go to the documentation of this file.

#include <linux/proc_fs.h>
#include <asm/uaccess.h>


#include "procfs.h"
#include "mountdata.h"


#ifndef CONFIG_PROC_FS
    #error The module must be compiled with the /proc filesystem configured
#endif



static const char *             mumufs_proc_entry_point = "mumu";

static const char *             mumufs_version = "0.1.1";

static struct proc_dir_entry *  mumufs_main_proc_entry = NULL;



static int mumufs_read_version( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );
static int mumufs_read_max_block_size( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );
static int mumufs_read_entries( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );
static int mumufs_read_max_entries( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );
static int mumufs_read_mount_point( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );


#ifdef DEBUG
static int mumufs_read_debug( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data );
#endif





int  mumufs_initialise_proc_entries( void )
{
    struct proc_dir_entry *     entry;
    int                         flags;

    mumufs_main_proc_entry = proc_mkdir( mumufs_proc_entry_point, NULL );
    if ( mumufs_main_proc_entry == NULL )
    {
        return -ENOMEM;
    }

    flags = S_IFREG | S_IRUGO;              // Anybody can read the file
    entry = create_proc_entry( "version", flags, mumufs_main_proc_entry );
    entry->read_proc = mumufs_read_version;

    return 0;
}



int mumufs_remove_proc_entries( void )
{
    remove_proc_entry( "version", mumufs_main_proc_entry );
    remove_proc_entry( mumufs_proc_entry_point, NULL );

    return 0;
}



int  mumufs_create_mount_info( struct super_block *  sb )
{
    struct proc_dir_entry *     mount_entry = NULL;
    struct proc_dir_entry *     entry = NULL;
    char                        buffer[16];

    if ( mumufs_main_proc_entry == NULL )
    {
        return -EINVAL;
    }

    sprintf( buffer, "0x%p", sb );
    mount_entry = proc_mkdir( buffer, mumufs_main_proc_entry );
    if ( mount_entry == NULL )
    {
        return -ENOMEM;
    }
    ((struct mumu_mount_data *)(sb->s_fs_info))->parent = mount_entry;

    entry = create_proc_entry( "maxblocksize", S_IFREG | S_IRUGO | S_IWUGO, mount_entry );
    if ( entry == NULL )
    {
        remove_proc_entry( buffer, mumufs_main_proc_entry );
        return -ENOMEM;
    }
    entry->read_proc = mumufs_read_max_block_size;
    entry->data      = sb->s_fs_info;

    entry = create_proc_entry( "maxentries", S_IFREG | S_IRUGO | S_IWUGO, mount_entry );
    if ( entry == NULL )
    {
        remove_proc_entry( "maxblocksize", mount_entry );
        remove_proc_entry( buffer, mumufs_main_proc_entry );
        return -ENOMEM;
    }
    entry->read_proc = mumufs_read_max_entries;
    entry->data      = sb->s_fs_info;

    entry = create_proc_entry( "entries", S_IFREG | S_IRUGO | S_IWUGO, mount_entry );
    if ( entry == NULL )
    {
        remove_proc_entry( "maxentries", mount_entry );
        remove_proc_entry( "maxblocksize", mount_entry );
        remove_proc_entry( buffer, mumufs_main_proc_entry );
        return -ENOMEM;
    }
    entry->read_proc = mumufs_read_entries;
    entry->data      = sb->s_fs_info;

    entry = create_proc_entry( "mountpoint", S_IFREG | S_IRUGO | S_IWUGO, mount_entry );
    if ( entry == NULL )
    {
        remove_proc_entry( "entries", mount_entry );
        remove_proc_entry( "maxentries", mount_entry );
        remove_proc_entry( "maxblocksize", mount_entry );
        remove_proc_entry( buffer, mumufs_main_proc_entry );
        return -ENOMEM;
    }
    entry->read_proc = mumufs_read_mount_point;
    entry->data      = sb->s_fs_info;

    #ifdef DEBUG
    entry = create_proc_entry( "debug", S_IFREG | S_IRUGO | S_IWUGO, mount_entry );
    if ( entry == NULL )
    {
        remove_proc_entry( "mountpoint", mount_entry );
        remove_proc_entry( "entries", mount_entry );
        remove_proc_entry( "maxentries", mount_entry );
        remove_proc_entry( "maxblocksize", mount_entry );
        remove_proc_entry( buffer, mumufs_main_proc_entry );
        return -ENOMEM;
    }
    entry->read_proc = mumufs_read_debug;
    entry->data      = sb->s_fs_info;
    #endif

    return 0;
}


int  mumufs_remove_mount_info( struct super_block *  sb )
{
    char                        buffer[16];

    if ( mumufs_main_proc_entry == NULL )
    {
        return 1;
    }

    #ifdef DEBUG
    remove_proc_entry( "debug", ((struct mumu_mount_data *)(sb->s_fs_info))->parent );
    #endif

    remove_proc_entry( "entries", ((struct mumu_mount_data *)(sb->s_fs_info))->parent );
    remove_proc_entry( "maxentries", ((struct mumu_mount_data *)(sb->s_fs_info))->parent );
    remove_proc_entry( "maxblocksize", ((struct mumu_mount_data *)(sb->s_fs_info))->parent );
    remove_proc_entry( "mountpoint", ((struct mumu_mount_data *)(sb->s_fs_info))->parent );

    sprintf( buffer, "0x%p", sb );
    remove_proc_entry( buffer, mumufs_main_proc_entry );
    return 0;
}


static int mumufs_read_version( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    return snprintf( page, count - 1, "%s\n", mumufs_version ) + 1;
}


    /* See remarks to the mumufs_read_version function. They are pretty much the same */
static int mumufs_read_max_block_size( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    return snprintf( page, count - 1, "%u\n", ((struct mumu_mount_data *)data)->max_block_size ) + 1;
}


    /* See remarks to the mumufs_read_version function. They are pretty much the same */
static int mumufs_read_entries( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    int     val = atomic_read( & ((struct mumu_mount_data *)data)->number_of_entries );
    return snprintf( page, count - 1, "%d\n", val ) + 1;
}


    /* See remarks to the mumufs_read_version function. They are pretty much the same */
static int mumufs_read_max_entries( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    return snprintf( page, count - 1, "%u\n", ((struct mumu_mount_data *)data)->max_entries ) + 1;
}

    /* See remarks to the mumufs_read_version function. They are pretty much the same */
static int mumufs_read_mount_point( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    char                        buf[ NAME_MAX*2 ];
    struct vfsmount *           mount = ((struct mumu_mount_data *)data)->mount;
    struct path                 p;

    if ( mount != NULL )
    {
        /* Fill the path structure fields to get the mount point path */
        p.mnt = mount->mnt_parent;
        p.dentry = mount->mnt_mountpoint;

        return snprintf( page, count - 1, "%s\n", d_path( &p, buf, 512 ) ) + 1;
    }

    return snprintf( page, count - 1, "Unknown\n" ) + 1;
}


#ifdef DEBUG
int mumufs_read_debug( char *  page, char **  start, off_t  offset, int  count, int *  eof, void *  data )
{
    struct mumu_mount_data *        d = (struct mumu_mount_data *)data;
    switch ( d->last_op )
    {
        case 1:
            return snprintf( page, count - 1,
                             "Last operation: READ\n"
                             "Bytes:          %d\n"
                             "Offset:         %lld\n", d->last_bytes, d->last_offset ) + 1;
        case 2:
            return snprintf( page, count - 1,
                             "Last operation: WRITE\n"
                             "Bytes:          %d\n"
                             "Offset:         %lld\n", d->last_bytes, d->last_offset ) + 1;
    }

    return snprintf( page, count - 1, "Unknown last operation.\n" ) + 1;
}
#endif