root/morphix/trunk/mini_fo/main.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.
 */
/*
 * Copyright (C) 2004 Markus Klotzbuecher <mk@creamnet.de>
 *
 * 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.
 */

/*
 *  $Id: main.c 1345 2004-11-30 23:18:53Z alextreme $
 */

#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"
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
#include <linux/module.h>
#endif

/* This definition must only appear after we include <linux/module.h> */
#ifndef MODULE_LICENSE
#define MODULE_LICENSE(bison)
#endif /* not MODULE_LICENSE */



/* sb we pass is mini_fo's super_block */
/*
 * This is the mini_fo tri interpose function, which extends the functionality
 * of the regular interpose by interposing a higher level inode on top of two
 * lower level ones: the base filesystem inode and the storage filesystem inode.
 *
 * The regular interpose functions is still needed, as not every lower base
 * inode has a corresponding storage inode. This is due to the approach used of
 * structuring the meta-data.
 *
 *  sb we pass is mini_fo's super_block
 */
int
mini_fo_tri_interpose(dentry_t *lower_dentry, dentry_t *lower_sto_dentry, dentry_t *dentry, super_block_t *sb, int flag)
{
        inode_t *lower_inode = NULL;
        inode_t *lower_sto_inode = NULL; /* store corresponding storage inode */
        int err = 0;
        inode_t *inode;

        /* Pointer to lower_sto_inode if exists, else to lower_inode.
         * This is used to copy the attributes of the correct inode. */
        inode_t *master_inode;

        print_entry_location();

        if(lower_dentry)
            lower_inode = lower_dentry->d_inode;
        if(lower_sto_dentry)
            lower_sto_inode = lower_sto_dentry->d_inode;

        ASSERT(dentry->d_inode == NULL);

        /* mk: One of the inodes associated with the dentrys is likely to
         * be NULL, so carefull:
         */
        ASSERT((lower_inode != NULL) || (lower_sto_inode != NULL));

        if(lower_sto_inode)
            master_inode = lower_sto_inode;
        else
            master_inode = lower_inode;

        /*
         * We allocate our new inode below, by calling iget.
         * iget will call our read_inode which will initialize some
         * of the new inode's fields
         */

        /* check that the lower file system didn't cross a mount point
         *
         * mk: taken this out, not reasonable for fanout:
         */

        /*
         * original: inode = iget(sb, lower_inode->i_ino);
         */
        inode = iget(sb, iunique(sb, 25));
        if (!inode) {
                err = -EACCES;          /* should be impossible??? */
                goto out;
        }

        /*
         * interpose the inode if not already interposed
         *   this is possible if the inode is being reused
         * XXX: what happens if we get_empty_inode() but there's another already?
         * for now, ASSERT() that this can't happen; fix later.
         */
        if (INODE_TO_LOWER(inode) != NULL) {
                printk(KERN_CRIT "MINI_FO: WARNING: mini_fo_interpose INODE_TO_LOWER(inode) is not NULL\n");
        }
        if (INODE_TO_LOWER_STO(inode) != NULL) {
                printk(KERN_CRIT "MINI_FO: WARNING: mini_fo_interpose INODE_TO_LOWER_STO(inode) is not NULL\n");
        }

        /* mk: Carefull, igrab can't handle NULL inodes (ok, why should it?), so
         * we need to check here:
         */
        if(lower_inode)
            INODE_TO_LOWER(inode) = igrab(lower_inode);
        else
            INODE_TO_LOWER(inode) = NULL;

        if(lower_sto_inode)
            INODE_TO_LOWER_STO(inode) = igrab(lower_sto_inode);
        else
            INODE_TO_LOWER_STO(inode) = NULL;


        /* Use different set of inode ops for symlinks & directories*/
        if (S_ISLNK(master_inode->i_mode))
                inode->i_op = &mini_fo_symlink_iops;
        else if (S_ISDIR(master_inode->i_mode))
                inode->i_op = &mini_fo_dir_iops;

        /* Use different set of file ops for directories */
        if (S_ISDIR(master_inode->i_mode))
                inode->i_fop = &mini_fo_dir_fops;

        /* properly initialize special inodes */
        if (S_ISBLK(master_inode->i_mode) || S_ISCHR(master_inode->i_mode) ||
            S_ISFIFO(master_inode->i_mode) || S_ISSOCK(master_inode->i_mode)) {
                init_special_inode(inode, master_inode->i_mode, master_inode->i_rdev);
        }

        /* Fix our inode's address operations to that of the lower inode */
        if (inode->i_mapping->a_ops != master_inode->i_mapping->a_ops) {
                fist_dprint(7, "fixing inode 0x%x a_ops (0x%x -> 0x%x)\n",
                            (int) inode, (int) inode->i_mapping->a_ops,
                            (int) master_inode->i_mapping->a_ops);
                inode->i_mapping->a_ops = master_inode->i_mapping->a_ops;
        }

        /* only (our) lookup wants to do a d_add */
        if (flag)
                d_add(dentry, inode);
        else
                d_instantiate(dentry, inode);


        ASSERT(DENTRY_TO_PRIVATE(dentry) != NULL);

        /* all well, copy inode attributes */
        fist_copy_attr_all(inode, master_inode);

 out:
        print_exit_status(err);
        return err;
}

/*
 * This is the original interpose function
 *
 * sb we pass is mini_fo's super_block
 */
int
mini_fo_interpose(dentry_t *lower_dentry, dentry_t *dentry, super_block_t *sb, int flag)
{
        inode_t *lower_inode;
        int err = 0;
        inode_t *inode;

        print_entry_location();

        lower_inode = lower_dentry->d_inode; /* CPW: moved after print_entry_location */

        ASSERT(lower_inode != NULL);
        ASSERT(dentry->d_inode == NULL);

        /*
         * We allocate our new inode below, by calling iget.
         * iget will call our read_inode which will initialize some
         * of the new inode's fields
         */
        /* check that the lower file system didn't cross a mount point */
// mk: take this out, not reasonable for fanout:
//      if (lower_inode->i_sb != SUPERBLOCK_TO_LOWER(sb)) {
//              err = -EXDEV;
//              goto out;
//      }
        /* mk
         * original: inode = iget(sb, hidden_inode->i_ino);
         *
         * this seems to work
         */
        //inode = iget(sb, iunique(sb, 25));
        inode = iget(sb, lower_inode->i_ino);
        
        if (!inode) {
                err = -EACCES;          /* should be impossible??? */
                goto out;
        }

        /*
         * interpose the inode if not already interposed
         * this is possible if the inode is being reused
         * XXX: what happens if we get_empty_inode() but there's another already?
         * for now, ASSERT() that this can't happen; fix later.
         */
        if (INODE_TO_LOWER(inode) == NULL)
                INODE_TO_LOWER(inode) = igrab(lower_inode);

        /* Use different set of inode ops for symlinks & directories*/
        if (S_ISLNK(lower_inode->i_mode))
                inode->i_op = &mini_fo_symlink_iops;
        else if (S_ISDIR(lower_inode->i_mode))
                inode->i_op = &mini_fo_dir_iops;
        /* Use different set of file ops for directories */
        if (S_ISDIR(lower_inode->i_mode))
                inode->i_fop = &mini_fo_dir_fops;

        /* properly initialize special inodes */
        if (S_ISBLK(lower_inode->i_mode) || S_ISCHR(lower_inode->i_mode) ||
            S_ISFIFO(lower_inode->i_mode) || S_ISSOCK(lower_inode->i_mode)) {
                init_special_inode(inode, lower_inode->i_mode, lower_inode->i_rdev);
        }

        /* Fix our inode's address operations to that of the lower inode */
        if (inode->i_mapping->a_ops != lower_inode->i_mapping->a_ops) {
                fist_dprint(7, "fixing inode 0x%x a_ops (0x%x -> 0x%x)\n",
                            (int) inode, (int) inode->i_mapping->a_ops,
                            (int) lower_inode->i_mapping->a_ops);
                inode->i_mapping->a_ops = lower_inode->i_mapping->a_ops;
        }

        /* only (our) lookup wants to do a d_add */
        if (flag)
                d_add(dentry, inode);
        else
                d_instantiate(dentry, inode);

        ASSERT(DENTRY_TO_PRIVATE(dentry) != NULL);

        /* all well, copy inode attributes */
        fist_copy_attr_all(inode, lower_inode);

out:
        print_exit_status(err);
        return err;
}


/* find lower dentry given this mini_fo dentry */
dentry_t *
__mini_fo_lower_dentry(const char *file, const char *func, int line, dentry_t *dentry)
{
        dentry_t *lower_dentry;

        ASSERT2(dentry != NULL);
        ASSERT2(dentry->d_op != NULL);
        ASSERT2(dentry->d_op == &mini_fo_dops);

        ASSERT2(dentry->d_sb->s_op == &mini_fo_sops);
        if (dentry->d_inode) {
                ASSERT2(dentry->d_inode->i_op == &mini_fo_main_iops ||
                        dentry->d_inode->i_op == &mini_fo_dir_iops ||
                        dentry->d_inode->i_op == &mini_fo_symlink_iops);
        }
        lower_dentry = DENTRY_TO_LOWER(dentry);
        ASSERT2(lower_dentry != NULL);
        return lower_dentry;
}


/* find lower storage dentry given this mini_fo dentry */
dentry_t *
__mini_fo_lower_sto_dentry(const char *file, const char *func, int line, dentry_t *dentry)
{
        dentry_t *lower_sto_dentry;

        ASSERT2(dentry != NULL);
        ASSERT2(dentry->d_op != NULL);
        ASSERT2(dentry->d_op == &mini_fo_dops);

        ASSERT2(dentry->d_sb->s_op == &mini_fo_sops);
        if (dentry->d_inode) {
                ASSERT2(dentry->d_inode->i_op == &mini_fo_main_iops ||
                        dentry->d_inode->i_op == &mini_fo_dir_iops ||
                        dentry->d_inode->i_op == &mini_fo_symlink_iops);
        }
        lower_sto_dentry = DENTRY_TO_LOWER_STO(dentry);
        ASSERT2(lower_sto_dentry != NULL);
        return lower_sto_dentry;
}

/*
 * Parse mount options: dir=XXX and debug=N
 *
 * Returns the dentry object of the lower-level (lower) directory;
 * We want to mount our stackable file system on top of that lower directory.
 *
 * Sets default debugging level to N, if any.
 * dir1 = readonly directory
 * dir2 = storage directory
 * mount target is the union directory
 */
dentry_t *
mini_fo_parse_options(super_block_t *sb, char *options)
{
        dentry_t *lower_root   = ERR_PTR(-EINVAL);
        dentry_t *lower_root2 = ERR_PTR(-EINVAL);
        struct nameidata nd, nd2;
        char *name, *tmp, *end;
        int err = -1;

        print_entry_location();

        /* We don't want to go off the end of our arguments later on. */
        for (end = options; *end; end++);

        while (options < end) {
                tmp = options;
                while (*tmp && *tmp != ',')
                        tmp++;
                *tmp = '\0';
                if (!strncmp("dir=", options, 4)) {
                        /* note: the name passed need not be encoded */
                        name = options + 4;
                        printk(KERN_CRIT "base dir: %s, ", name);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
                        if (path_init(name, LOOKUP_FOLLOW, &nd))
                                err = path_walk(name, &nd);
#else
                        err = path_lookup(name, LOOKUP_FOLLOW, &nd);
#endif
                        if (err) {
                                printk("mini_fo: error accessing lower directory '%s'\n", name);
                                lower_root = ERR_PTR(err);
                                goto out;
                        }
                        lower_root = nd.dentry;
                        SUPERBLOCK_TO_PRIVATE(sb)->lower_mnt = nd.mnt;
                        fist_dprint(6, "parse_options: new s_root, inode: 0x%lx, 0x%lx\n", (long) lower_root, (long) lower_root->d_inode);

                        fist_print_dentry("lower_root: ", lower_root);
                        fist_print_dentry("nd.mnt->mnt_root: ", nd.mnt->mnt_root);
                        fist_print_inode("lower_inode:", lower_root->d_inode);
                        fist_print_sb("lower_super:", lower_root->d_sb);

                }else if(!strncmp("dir2=", options, 5)) {
                        /* parse the storage dir */
                        name = options + 5;
                        printk(KERN_CRIT "storage dir: %s\n", name);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
                        if(path_init(name, LOOKUP_FOLLOW, &nd2))
                                err = path_walk(name, &nd2);
#else
                        err = path_lookup(name, LOOKUP_FOLLOW, &nd2);
#endif
                        if(err) {
                                printk("mini_fo: error accessing lower storage directory '%s'\n", name);
                                lower_root2 = ERR_PTR(err);
                                goto out;
                        }
                        lower_root2 = nd2.dentry;
                        SUPERBLOCK_TO_PRIVATE(sb)->lower_mnt2 = nd2.mnt;
                        SUPERBLOCK_TO_LOWER_STO(sb) = lower_root2->d_sb;

                        /* mk: save the storage_dir_dentry, ugly*/
                        SUPERBLOCK_TO_PRIVATE(sb)->storage_dir_dentry = lower_root2;

                        fist_print_dentry("lower_root2: ", lower_root2);
                        fist_print_dentry("nd2.mnt->mnt_root: ", nd2.mnt->mnt_root);
                        fist_print_inode("lower_inode2:", lower_root2->d_inode);
                        fist_print_sb("lower_super2:", lower_root2->d_sb);

                        /* validate storage dir, this is done in mini_fo_read_super for
                         * the base directory.
                         */
                        if (IS_ERR(lower_root2)) {
                                printk(KERN_WARNING "mini_fo_parse_options: storage dentry lookup failed (err = %ld)\n", PTR_ERR(lower_root2));
                                goto out;
                        }
                        if (!lower_root2->d_inode) {
                                printk(KERN_WARNING "mini_fo_parse_options: no storage dir to interpose on.\n");
                                goto out;
                        }
                        SUPERBLOCK_TO_LOWER_STO(sb) = lower_root2->d_sb;
                        // deprecated: mini_fo_storage_dentry = lower_root2;



                }else if (!strncmp("debug=", options, 6)) {
                        int debug = simple_strtoul(options + 6, NULL, 0);
                        fist_set_debug_value(debug);
                } else {
                        printk(KERN_WARNING "mini_fo: unrecognized option '%s'\n", options);
                }
                options = tmp + 1;
        }

out:
        print_exit_location();
        return lower_root;
}

#ifdef FIST_MALLOC_DEBUG
/* for malloc debugging */
static atomic_t mini_fo_malloc_counter;

void *
mini_fo_KMALLOC(size_t len, int flag, int line, const char *file)
{
        void *ptr = (void *) KMALLOC(len, flag);
        if (ptr) {
                atomic_inc(&mini_fo_malloc_counter);
                printk("KM:%d:%p:%d:%s\n", atomic_read(&mini_fo_malloc_counter),ptr, line, file);
        }
        return ptr;
}

void
mini_fo_KFREE(void *ptr, int line, const char *file)
{
        atomic_inc(&mini_fo_malloc_counter);
        printk("KF:%d:%p:%d:%s\n", atomic_read(&mini_fo_malloc_counter), ptr, line, file);
        KFREE(ptr);
}
#endif /* FIST_MALLOC_DEBUG */

/**
 * Not really clean but people want both version 2.4 and 2.6
 */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
/* for attach mode, we use a different ->read_super() in attach.c */
super_block_t *
mini_fo_read_super(super_block_t *sb, void *raw_data, int silent)
{
        super_block_t *ret_sb = NULL;
        dentry_t *lower_root;

        print_entry_location();


        if (!raw_data) {
                printk(KERN_WARNING "mini_fo_read_super: missing data argument\n");
                goto out;
        }
        /*
         * Allocate superblock private data
         */
        SUPERBLOCK_TO_PRIVATE(sb) = kmalloc(sizeof(struct mini_fo_sb_info), GFP_KERNEL);
        if (!SUPERBLOCK_TO_PRIVATE(sb)) {
                printk(KERN_WARNING "%s: out of memory\n", __FUNCTION__);
                goto out;
        }
        SUPERBLOCK_TO_LOWER(sb) = NULL;

        lower_root = mini_fo_parse_options(sb, raw_data);
        if (IS_ERR(lower_root)) {
                printk(KERN_WARNING "mini_fo_read_super: lookup_dentry failed (err = %ld)\n", PTR_ERR(lower_root));
                goto out_free;
        }
        if (!lower_root->d_inode) {
                printk(KERN_WARNING "mini_fo_read_super: no directory to interpose on\n");
                goto out_free;
        }
        SUPERBLOCK_TO_LOWER(sb) = lower_root->d_sb;

        /*
         * Linux 2.4.2-ac3 and beyond has code in
         * mm/filemap.c:generic_file_write() that requires sb->s_maxbytes
         * to be populated.  If not set, all write()s under that sb will
         * return 0.
         *
         * Linux 2.4.4+ automatically sets s_maxbytes to MAX_NON_LFS;
         * the filesystem should override it only if it supports LFS.
         */
        /* non-SCA code is good to go with LFS */
        sb->s_maxbytes = lower_root->d_sb->s_maxbytes;

        sb->s_op = &mini_fo_sops;
        /*
         * we can't use d_alloc_root if we want to use
         * our own interpose function unchanged,
         * so we simply replicate *most* of the code in d_alloc_root here
         */
        sb->s_root = d_alloc(NULL, &(const struct qstr) { "/", 1, 0 });
        if (IS_ERR(sb->s_root)) {
                printk(KERN_WARNING "mini_fo_read_super: d_alloc failed\n");
                goto out_dput;
        }

        sb->s_root->d_op = &mini_fo_dops;
        sb->s_root->d_sb = sb;
        sb->s_root->d_parent = sb->s_root;
        /* link the upper and lower dentries */
        DENTRY_TO_PRIVATE(sb->s_root) = (struct mini_fo_dentry_info *) kmalloc(sizeof(struct mini_fo_dentry_info), GFP_KERNEL);
        if (!DENTRY_TO_PRIVATE(sb->s_root)) {
                goto out_dput2;
        }
        DENTRY_TO_PRIVATE(sb->s_root)->state = 1;
        DENTRY_TO_LOWER(sb->s_root) = lower_root;
        /* fanout relevant, interpose on storage root dentry too */
        DENTRY_TO_LOWER_STO(sb->s_root) = SUPERBLOCK_TO_PRIVATE(sb)->storage_dir_dentry;
        /* ...and call tri-interpose to interpose root dir inodes
         * if (mini_fo_interpose(lower_root, sb->s_root, sb, 0))
         */
        if(mini_fo_tri_interpose(lower_root, DENTRY_TO_LOWER_STO(sb->s_root), sb->s_root, sb, 0))
                goto