root/morphix/trunk/mini_fo/dentry.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: dentry.c 1364 2004-12-04 10:18:10Z 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"

/* HL
   d_revalidate: check for lower_dentry!=NULL


*/

/*
 * THIS IS A BOOLEAN FUNCTION: returns 1 if valid, 0 otherwise.
 */
STATIC int
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
mini_fo_d_revalidate(dentry_t *dentry, struct nameidata *nd)
#else
mini_fo_d_revalidate(dentry_t *dentry, int flags)
#endif
{
        int err         = 1; // default is valid (1); invalid is 0.
        int err_sto = 1; // default is valid (1); invalid is 0.
        dentry_t *lower_dentry;
        dentry_t *lower_sto_dentry;

        print_entry_location();

        lower_dentry  = DENTRY_TO_LOWER(dentry); //mini_fo_lower_dentry(dentry); /* CPW: Moved to after print_entry_location */
        lower_sto_dentry  = DENTRY_TO_LOWER_STO(dentry);   //mini_fo_lower_sto_dentry(dentry); /* CPW: Moved to after print_entry_location */

        if (lower_dentry && lower_dentry->d_op && lower_dentry->d_op->d_revalidate)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
                err = lower_dentry->d_op->d_revalidate(lower_dentry, nd);
#else
                err = lower_dentry->d_op->d_revalidate(lower_dentry, flags);
#endif

        if (lower_sto_dentry && lower_sto_dentry->d_op && lower_sto_dentry->d_op->d_revalidate)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
                err_sto = lower_sto_dentry->d_op->d_revalidate(lower_sto_dentry, nd);
#else
                err_sto = lower_sto_dentry->d_op->d_revalidate(lower_sto_dentry, flags);
#endif

out:
        /* mk: if one of the lower level dentries are vaid,
         * the mini_fo dentry is too.
         */
        err=(err || err_sto);
        print_exit_status(err);
        return (err);
}


STATIC int
mini_fo_d_hash(dentry_t *dentry, qstr_t *name)
{
        int err = 0;
        dentry_t *lower_dentry;
        dentry_t *lower_sto_dentry;

        print_entry_location();
        /* lower_dentry = mini_fo_lower_dentry(dentry);
         * lower_sto_dentry = mini_fo_lower_sto_dentry(dentry); */

        /* state 1, 3, 5: build the hash for the storage dentry */
        if ((DENTRY_TO_PRIVATE(dentry)->state == 1) || 
                (DENTRY_TO_PRIVATE(dentry)->state == 3) || 
                (DENTRY_TO_PRIVATE(dentry)->state == 5)) {
                lower_sto_dentry = mini_fo_lower_sto_dentry(dentry);
                if(lower_sto_dentry &&
                   lower_sto_dentry->d_op &&
                   lower_sto_dentry->d_op->d_hash) {
                        err = lower_sto_dentry->d_op->d_hash(lower_sto_dentry, name);
                }
                goto out;
        }
        /* state 2 or 4: build the hash for the base dentry */
        if((DENTRY_TO_PRIVATE(dentry)->state == 2) || (DENTRY_TO_PRIVATE(dentry)->state == 4)) {
                lower_dentry = mini_fo_lower_dentry(dentry);
                if(lower_dentry &&
                   lower_dentry->d_op &&
                   lower_dentry->d_op->d_hash) {
                        err = lower_dentry->d_op->d_hash(lower_dentry, name);
                }
                goto out;
        }
        /* state 6: build hash for the dentry that exists */
        if(DENTRY_TO_PRIVATE(dentry)->state == 6) {
                lower_sto_dentry = DENTRY_TO_LOWER_STO(dentry);
                if(lower_sto_dentry &&
                   lower_sto_dentry->d_op &&
                   lower_sto_dentry->d_op->d_hash) {
                        err = lower_sto_dentry->d_op->d_hash(lower_sto_dentry, name);
                        goto out;
                }
                lower_dentry = DENTRY_TO_LOWER(dentry);
                if(lower_dentry &&
                   lower_dentry->d_op &&
                   lower_dentry->d_op->d_hash) {
                        err = lower_dentry->d_op->d_hash(lower_dentry, name);
                        goto out;
                }
        }

        printk(KERN_CRIT "mini_fo: d_hash: invalid state detected.\n");

 out:
        print_exit_status(err);
        return err;
}


STATIC int
mini_fo_d_compare(dentry_t *dentry, qstr_t *a, qstr_t *b)
{
        int err;
        dentry_t *lower_dentry;

        print_entry_location();

        //lower_dentry = mini_fo_lower_dentry(dentry);  /* CPW: Moved to after print_entry_location */
        lower_dentry= DENTRY_TO_LOWER_STO(dentry);
        if (!lower_dentry)
                lower_dentry= DENTRY_TO_LOWER(dentry);

        if (lower_dentry && lower_dentry->d_op && lower_dentry->d_op->d_compare) {
                // XXX: WRONG: should encode_filename on a&b strings
                err = lower_dentry->d_op->d_compare(lower_dentry, a, b);
        } else {
                err = ((a->len != b->len) || memcmp(a->name, b->name, b->len));
        }

        print_exit_status(err);
        return err;
}


int
mini_fo_d_delete(dentry_t *dentry)
{

        dentry_t *lower_dentry = 0;
        dentry_t *lower_sto_dentry = 0;
        int err = 0;

        print_entry_location();


    /* dentry can be NULL */
    if (!dentry)
        goto out;

        /* this could be a negative dentry, so check first */
        if (!DENTRY_TO_PRIVATE(dentry)) {
                fist_dprint(6, "dentry without private data: %*s", dentry->d_name.len, dentry->d_name.name);
                goto out;
        }

/* mk: fan out (after) */
        lower_dentry = DENTRY_TO_LOWER(dentry);
        lower_sto_dentry = DENTRY_TO_LOWER_STO(dentry);

        if(lower_dentry) {
                if(lower_dentry->d_op &&
                   lower_dentry->d_op->d_delete) {
                        err = lower_dentry->d_op->d_delete(lower_dentry);
                }
        }
        if(lower_sto_dentry) {
                if(lower_sto_dentry->d_op &&
                   lower_sto_dentry->d_op->d_delete) {
                        err = lower_sto_dentry->d_op->d_delete(lower_sto_dentry);
                }
        }
out:
        //fist_dprint(8, "exit d_delete\n");
        print_exit_status(err);
        return err;
}


void
mini_fo_d_release(dentry_t *dentry)
{
        dentry_t *lower_dentry          =NULL;
        dentry_t *lower_sto_dentry      =NULL;

        print_entry_location();
        fist_print_dentry("mini_fo_d_release IN dentry", dentry);

        /* this could be a null dentry, so check first */
        if (!dentry) {
                fist_dprint(6, "null dentry");
                goto out;
        }
        /* this could be a negative dentry, so check first */
        if (!DENTRY_TO_PRIVATE(dentry)) {
                fist_dprint(6, "dentry without private data: %*s", dentry->d_name.len, dentry->d_name.name);
                goto out;
        }
        lower_dentry = DENTRY_TO_LOWER(dentry);
        lower_sto_dentry = DENTRY_TO_LOWER_STO(dentry);

        fist_print_dentry("mini_fo_d_release IN lower_dentry", lower_dentry);


        /* decrement lower dentry's counter and free its inode */
        if (lower_dentry) 
                dput(lower_dentry);

        if (lower_sto_dentry) 
                dput(lower_sto_dentry);

        /* free private data (mini_fo_dentry_info) here */
        KFREE(DENTRY_TO_PRIVATE(dentry));
        DENTRY_TO_PRIVATE_SM(dentry) = NULL;    /* just to be safe */
out:
        print_exit_location();
}


/*
 * we don't really need mini_fo_d_iput, because dentry_iput will call iput() if
 * mini_fo_d_iput is not defined. We left this implemented for ease of
 * tracing/debugging.
 */
void
mini_fo_d_iput(dentry_t *dentry, inode_t *inode)
{
        print_entry_location();
        iput(inode);
        print_exit_location();
}


struct dentry_operations mini_fo_dops = {
        d_revalidate:   mini_fo_d_revalidate,
        d_hash:         mini_fo_d_hash,
        d_compare:      mini_fo_d_compare,
        d_release:      mini_fo_d_release,
        d_delete:       mini_fo_d_delete,
        d_iput:     mini_fo_d_iput,
};


/*
 * Local variables:
 * c-basic-offset: 4
 * End:
 */