Subversion Repositories or1k

/* cnode related routines for the coda kernel code

   (C) 1996 Peter Braam

   */

#include <linux/types.h>

#include <linux/string.h>

#include <linux/time.h>

#include <linux/coda.h>

#include <linux/coda_linux.h>

#include <linux/coda_fs_i.h>

#include <linux/coda_psdev.h>

extern int coda_debug;

inline int coda_fideq(ViceFid *fid1, ViceFid *fid2)

{

        if (fid1->Vnode != fid2->Vnode)   return 0;

        if (fid1->Volume != fid2->Volume) return 0;

        if (fid1->Unique != fid2->Unique) return 0;

        return 1;

}

inline int coda_isnullfid(ViceFid *fid)

{

        if (fid->Vnode || fid->Volume || fid->Unique) return 0;

        return 1;

}

static int coda_inocmp(struct inode *inode, unsigned long ino, void *opaque)

{

        return (coda_fideq((ViceFid *)opaque, &(ITOC(inode)->c_fid)));

}

static struct inode_operations coda_symlink_inode_operations = {

        readlink:       page_readlink,

        follow_link:    page_follow_link,

        setattr:        coda_notify_change,

};

/* cnode.c */

static void coda_fill_inode(struct inode *inode, struct coda_vattr *attr)

{

        CDEBUG(D_SUPER, "ino: %ld\n", inode->i_ino);

        if (coda_debug & D_SUPER )

                print_vattr(attr);

        coda_vattr_to_iattr(inode, attr);

        if (S_ISREG(inode->i_mode)) {

                inode->i_op = &coda_file_inode_operations;

                inode->i_fop = &coda_file_operations;

        } else if (S_ISDIR(inode->i_mode)) {

                inode->i_op = &coda_dir_inode_operations;

                inode->i_fop = &coda_dir_operations;

        } else if (S_ISLNK(inode->i_mode)) {

                inode->i_op = &coda_symlink_inode_operations;

                inode->i_data.a_ops = &coda_symlink_aops;

                inode->i_mapping = &inode->i_data;

        } else

                init_special_inode(inode, inode->i_mode, attr->va_rdev);

}

struct inode * coda_iget(struct super_block * sb, ViceFid * fid,

                         struct coda_vattr * attr)

{

        struct inode *inode;

        struct coda_inode_info *cii;

        ino_t ino = coda_f2i(fid);

        struct coda_sb_info *sbi = coda_sbp(sb);

        down(&sbi->sbi_iget4_mutex);

        inode = iget4(sb, ino, coda_inocmp, fid);

        if ( !inode ) {

                CDEBUG(D_CNODE, "coda_iget: no inode\n");

                up(&sbi->sbi_iget4_mutex);

                return ERR_PTR(-ENOMEM);

        }

        /* check if the inode is already initialized */

        cii = ITOC(inode);

        if (coda_isnullfid(&cii->c_fid))

                /* new, empty inode found... initializing */

                cii->c_fid = *fid;

        up(&sbi->sbi_iget4_mutex);

        /* always replace the attributes, type might have changed */

        coda_fill_inode(inode, attr);

        return inode;

}

/* this is effectively coda_iget:

   - get attributes (might be cached)

   - get the inode for the fid using vfs iget

   - link the two up if this is needed

   - fill in the attributes

*/

int coda_cnode_make(struct inode **inode, ViceFid *fid, struct super_block *sb)

{

        struct coda_vattr attr;

        int error;

        /* We get inode numbers from Venus -- see venus source */

        error = venus_getattr(sb, fid, &attr);

        if ( error ) {

            CDEBUG(D_CNODE,

                   "coda_cnode_make: coda_getvattr returned %d for %s.\n",

                   error, coda_f2s(fid));

            *inode = NULL;

            return error;

        }

        *inode = coda_iget(sb, fid, &attr);

        if ( IS_ERR(*inode) ) {

                printk("coda_cnode_make: coda_iget failed\n");

                return PTR_ERR(*inode);

        }

        CDEBUG(D_DOWNCALL, "Done making inode: ino %ld, count %d with %s\n",

                (*inode)->i_ino, atomic_read(&(*inode)->i_count),

                coda_f2s(&ITOC(*inode)->c_fid));

        return 0;

}

void coda_replace_fid(struct inode *inode, struct ViceFid *oldfid,

                      struct ViceFid *newfid)

{

        struct coda_inode_info *cii;

        cii = ITOC(inode);

        if (!coda_fideq(&cii->c_fid, oldfid))

                BUG();

        /* replace fid and rehash inode */

        /* XXX we probably need to hold some lock here! */

        remove_inode_hash(inode);

        cii->c_fid = *newfid;

        inode->i_ino = coda_f2i(newfid);

        insert_inode_hash(inode);

}

/* convert a fid to an inode. */

struct inode *coda_fid_to_inode(ViceFid *fid, struct super_block *sb)

{

        ino_t nr;

        struct inode *inode;

        struct coda_inode_info *cii;

        struct coda_sb_info *sbi;

        if ( !sb ) {

                printk("coda_fid_to_inode: no sb!\n");

                return NULL;

        }

        CDEBUG(D_INODE, "%s\n", coda_f2s(fid));

        sbi = coda_sbp(sb);

        nr = coda_f2i(fid);

        down(&sbi->sbi_iget4_mutex);

        inode = iget4(sb, nr, coda_inocmp, fid);

        if ( !inode ) {

                printk("coda_fid_to_inode: null from iget, sb %p, nr %ld.\n",

                       sb, (long)nr);

                goto out_unlock;

        }

        cii = ITOC(inode);

        /* The inode could already be purged due to memory pressure */

        if (coda_isnullfid(&cii->c_fid)) {

                inode->i_nlink = 0;

                iput(inode);

                goto out_unlock;

        }

        CDEBUG(D_INODE, "found %ld\n", inode->i_ino);

        up(&sbi->sbi_iget4_mutex);

        return inode;

out_unlock:

        up(&sbi->sbi_iget4_mutex);

        return NULL;

}

/* the CONTROL inode is made without asking attributes from Venus */

int coda_cnode_makectl(struct inode **inode, struct super_block *sb)

{

        int error = 0;

        *inode = iget(sb, CTL_INO);

        if ( *inode ) {

                (*inode)->i_op = &coda_ioctl_inode_operations;

                (*inode)->i_fop = &coda_ioctl_operations;

                (*inode)->i_mode = 0444;

                error = 0;

        } else {

                error = -ENOMEM;

        }

        return error;

}