Subversion Repositories or1k

/*

 *  linux/fs/affs/namei.c

 *

 *  (c) 1996  Hans-Joachim Widmaier - Rewritten

 *

 *  (C) 1993  Ray Burr - Modified for Amiga FFS filesystem.

 *

 *  (C) 1991  Linus Torvalds - minix filesystem

 */

#include <linux/sched.h>

#include <linux/affs_fs.h>

#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/stat.h>

#include <linux/fcntl.h>

#include <linux/locks.h>

#include <linux/amigaffs.h>

#include <asm/uaccess.h>

#include <linux/errno.h>

typedef int (*toupper_t)(int);

extern struct inode_operations affs_symlink_inode_operations;

static int       affs_toupper(int ch);

static int       affs_hash_dentry(struct dentry *, struct qstr *);

static int       affs_compare_dentry(struct dentry *, struct qstr *, struct qstr *);

static int       affs_intl_toupper(int ch);

static int       affs_intl_hash_dentry(struct dentry *, struct qstr *);

static int       affs_intl_compare_dentry(struct dentry *, struct qstr *, struct qstr *);

struct dentry_operations affs_dentry_operations = {

        d_hash:         affs_hash_dentry,

        d_compare:      affs_compare_dentry,

};

struct dentry_operations affs_intl_dentry_operations = {

        d_hash:         affs_intl_hash_dentry,

        d_compare:      affs_intl_compare_dentry,

};

/* Simple toupper() for DOS\1 */

static int

affs_toupper(int ch)

{

        return ch >= 'a' && ch <= 'z' ? ch -= ('a' - 'A') : ch;

}

/* International toupper() for DOS\3 ("international") */

static int

affs_intl_toupper(int ch)

{

        return (ch >= 'a' && ch <= 'z') || (ch >= 0xE0

                && ch <= 0xFE && ch != 0xF7) ?

                ch - ('a' - 'A') : ch;

}

static inline toupper_t

affs_get_toupper(struct super_block *sb)

{

        return AFFS_SB->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;

}

/*

 * Note: the dentry argument is the parent dentry.

 */

static inline int

__affs_hash_dentry(struct dentry *dentry, struct qstr *qstr, toupper_t toupper)

{

        const u8 *name = qstr->name;

        unsigned long hash;

        int i;

        i = affs_check_name(qstr->name,qstr->len);

        if (i)

                return i;

        hash = init_name_hash();

        i = min(qstr->len, 30u);

        for (; i > 0; name++, i--)

                hash = partial_name_hash(toupper(*name), hash);

        qstr->hash = end_name_hash(hash);

        return 0;

}

static int

affs_hash_dentry(struct dentry *dentry, struct qstr *qstr)

{

        return __affs_hash_dentry(dentry, qstr, affs_toupper);

}

static int

affs_intl_hash_dentry(struct dentry *dentry, struct qstr *qstr)

{

        return __affs_hash_dentry(dentry, qstr, affs_intl_toupper);

}

static inline int

__affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b, toupper_t toupper)

{

        const u8 *aname = a->name;

        const u8 *bname = b->name;

        int len;

        /* 'a' is the qstr of an already existing dentry, so the name

         * must be valid. 'b' must be validated first.

         */

        if (affs_check_name(b->name,b->len))

                return 1;

        /* If the names are longer than the allowed 30 chars,

         * the excess is ignored, so their length may differ.

         */

        len = a->len;

        if (len >= 30) {

                if (b->len < 30)

                        return 1;

                len = 30;

        } else if (len != b->len)

                return 1;

        for (; len > 0; len--)

                if (toupper(*aname++) != toupper(*bname++))

                        return 1;

        return 0;

}

static int

affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)

{

        return __affs_compare_dentry(dentry, a, b, affs_toupper);

}

static int

affs_intl_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)

{

        return __affs_compare_dentry(dentry, a, b, affs_intl_toupper);

}

/*

 * NOTE! unlike strncmp, affs_match returns 1 for success, 0 for failure.

 */

static inline int

affs_match(struct dentry *dentry, const u8 *name2, toupper_t toupper)

{

        const u8 *name = dentry->d_name.name;

        int len = dentry->d_name.len;

        if (len >= 30) {

                if (*name2 < 30)

                        return 0;

                len = 30;

        } else if (len != *name2)

                return 0;

        for (name2++; len > 0; len--)

                if (toupper(*name++) != toupper(*name2++))

                        return 0;

        return 1;

}

int

affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len)

{

        toupper_t toupper = affs_get_toupper(sb);

        int hash;

        hash = len = min(len, 30u);

        for (; len > 0; len--)

                hash = (hash * 13 + toupper(*name++)) & 0x7ff;

        return hash % AFFS_SB->s_hashsize;

}

static struct buffer_head *

affs_find_entry(struct inode *dir, struct dentry *dentry)

{

        struct super_block *sb = dir->i_sb;

        struct buffer_head *bh;

        toupper_t toupper = affs_get_toupper(sb);

        u32 key;

        pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);

        bh = affs_bread(sb, dir->i_ino);

        if (!bh)

                return ERR_PTR(-EIO);

        key = be32_to_cpu(AFFS_HEAD(bh)->table[affs_hash_name(sb, dentry->d_name.name, dentry->d_name.len)]);

        for (;;) {

                affs_brelse(bh);

                if (key == 0)

                        return NULL;

                bh = affs_bread(sb, key);

                if (!bh)

                        return ERR_PTR(-EIO);

                if (affs_match(dentry, AFFS_TAIL(sb, bh)->name, toupper))

                        return bh;

                key = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain);

        }

}

struct dentry *

affs_lookup(struct inode *dir, struct dentry *dentry)

{

        struct super_block *sb = dir->i_sb;

        struct buffer_head *bh;

        struct inode *inode = NULL;

        pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);

        affs_lock_dir(dir);

        bh = affs_find_entry(dir, dentry);

        affs_unlock_dir(dir);

        if (IS_ERR(bh))

                return ERR_PTR(PTR_ERR(bh));

        if (bh) {

                u32 ino = bh->b_blocknr;

                /* store the real header ino in d_fsdata for faster lookups */

                dentry->d_fsdata = (void *)(long)ino;

                switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {

                //link to dirs disabled

                //case ST_LINKDIR:

                case ST_LINKFILE:

                        ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original);

                }

                affs_brelse(bh);

                inode = iget(sb, ino);

                if (!inode)

                        return ERR_PTR(-EACCES);

        }

        dentry->d_op = AFFS_SB->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;

        d_add(dentry, inode);

        return NULL;

}

int

affs_unlink(struct inode *dir, struct dentry *dentry)

{

        pr_debug("AFFS: unlink(dir=%d, \"%.*s\")\n", (u32)dir->i_ino,

                 (int)dentry->d_name.len, dentry->d_name.name);

        if (!dentry->d_inode)

                return -ENOENT;

        return affs_remove_header(dentry);

}

int

affs_create(struct inode *dir, struct dentry *dentry, int mode)

{

        struct super_block *sb = dir->i_sb;

        struct inode    *inode;

        int              error;

        pr_debug("AFFS: create(%lu,\"%.*s\",0%o)\n",dir->i_ino,(int)dentry->d_name.len,

                 dentry->d_name.name,mode);

        inode = affs_new_inode(dir);

        if (!inode)

                return -ENOSPC;

        inode->i_mode = mode;

        mode_to_prot(inode);

        mark_inode_dirty(inode);

        inode->i_op = &affs_file_inode_operations;

        inode->i_fop = &affs_file_operations;

        inode->i_mapping->a_ops = (AFFS_SB->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;

        error = affs_add_entry(dir, inode, dentry, ST_FILE);

        if (error) {

                inode->i_nlink = 0;

                iput(inode);

                return error;

        }

        return 0;

}

int

affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)

{

        struct inode            *inode;

        int                      error;

        pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%o)\n",dir->i_ino,

                 (int)dentry->d_name.len,dentry->d_name.name,mode);

        inode = affs_new_inode(dir);

        if (!inode)

                return -ENOSPC;

        inode->i_mode = S_IFDIR | mode;

        mode_to_prot(inode);

        inode->i_op = &affs_dir_inode_operations;

        inode->i_fop = &affs_dir_operations;

        error = affs_add_entry(dir, inode, dentry, ST_USERDIR);

        if (error) {

                inode->i_nlink = 0;

                mark_inode_dirty(inode);

                iput(inode);

                return error;

        }

        return 0;

}

int

affs_rmdir(struct inode *dir, struct dentry *dentry)

{

        pr_debug("AFFS: rmdir(dir=%u, \"%.*s\")\n", (u32)dir->i_ino,

                 (int)dentry->d_name.len, dentry->d_name.name);

        if (!dentry->d_inode)

                return -ENOENT;

        return affs_remove_header(dentry);

}

int

affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)

{

        struct super_block      *sb = dir->i_sb;

        struct buffer_head      *bh;

        struct inode            *inode;

        char                    *p;

        int                      i, maxlen, error;

        char                     c, lc;

        pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,

                 (int)dentry->d_name.len,dentry->d_name.name,symname);

        maxlen = AFFS_SB->s_hashsize * sizeof(u32) - 1;

        error = -ENOSPC;

        inode  = affs_new_inode(dir);

        if (!inode)

                return -ENOSPC;

        inode->i_op = &affs_symlink_inode_operations;

        inode->i_data.a_ops = &affs_symlink_aops;

        inode->i_mode = S_IFLNK | 0777;

        mode_to_prot(inode);

        error = -EIO;

        bh = affs_bread(sb, inode->i_ino);

        if (!bh)

                goto err;

        i  = 0;

        p  = (char *)AFFS_HEAD(bh)->table;

        lc = '/';

        if (*symname == '/') {

                while (*symname == '/')

                        symname++;

                while (AFFS_SB->s_volume[i])    /* Cannot overflow */

                        *p++ = AFFS_SB->s_volume[i++];

        }

        while (i < maxlen && (c = *symname++)) {

                if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {

                        *p++ = '/';

                        i++;

                        symname += 2;

                        lc = '/';

                } else if (c == '.' && lc == '/' && *symname == '/') {

                        symname++;

                        lc = '/';

                } else {

                        *p++ = c;

                        lc   = c;

                        i++;

                }

                if (lc == '/')

                        while (*symname == '/')

                                symname++;

        }

        *p = 0;

        mark_buffer_dirty_inode(bh, inode);

        affs_brelse(bh);

        mark_inode_dirty(inode);

        error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK);

        if (error)

                goto err;

        return 0;

err:

        inode->i_nlink = 0;

        mark_inode_dirty(inode);

        iput(inode);

        return error;

}

int

affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)

{

        struct inode *inode = old_dentry->d_inode;

        int error;

        pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,

                 (int)dentry->d_name.len,dentry->d_name.name);

        if (S_ISDIR(inode->i_mode))

                return -EPERM;

        error = affs_add_entry(dir, inode, dentry, S_ISDIR(inode->i_mode) ? ST_LINKDIR : ST_LINKFILE);

        if (error) {

                inode->i_nlink = 0;

                mark_inode_dirty(inode);

                iput(inode);

                return error;

        }

        return 0;

}

int

affs_rename(struct inode *old_dir, struct dentry *old_dentry,

            struct inode *new_dir, struct dentry *new_dentry)

{

        struct super_block *sb = old_dir->i_sb;

        struct buffer_head *bh = NULL;

        int retval;

        pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",

                 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,

                 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);

        if ((retval = affs_check_name(new_dentry->d_name.name,new_dentry->d_name.len)))

                goto done;

        /* Unlink destination if it already exists */

        if (new_dentry->d_inode) {

                retval = affs_remove_header(new_dentry);

                if (retval)

                        return retval;

        }

        retval = -EIO;

        bh = affs_bread(sb, old_dentry->d_inode->i_ino);

        if (!bh)

                goto done;

        /* Remove header from its parent directory. */

        affs_lock_dir(old_dir);

        retval = affs_remove_hash(old_dir, bh);

        affs_unlock_dir(old_dir);

        if (retval)

                goto done;

        /* And insert it into the new directory with the new name. */

        affs_copy_name(AFFS_TAIL(sb, bh)->name, new_dentry);

        affs_fix_checksum(sb, bh);

        affs_lock_dir(new_dir);

        retval = affs_insert_hash(new_dir, bh);

        affs_unlock_dir(new_dir);

        /* TODO: move it back to old_dir, if error? */

done:

        mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir);

        affs_brelse(bh);

        return retval;

}