Subversion Repositories or1k

/*

 *  linux/fs/hpfs/namei.c

 *

 *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999

 *

 *  adding & removing files & directories

 */

#include <linux/string.h>

#include "hpfs_fn.h"

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

{

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

        unsigned len = dentry->d_name.len;

        struct quad_buffer_head qbh0;

        struct buffer_head *bh;

        struct hpfs_dirent *de;

        struct fnode *fnode;

        struct dnode *dnode;

        struct inode *result;

        fnode_secno fno;

        dnode_secno dno;

        int r;

        struct hpfs_dirent dee;

        int err;

        if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;

        if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;

        if (!(dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1))) goto bail1;

        memset(&dee, 0, sizeof dee);

        dee.directory = 1;

        if (!(mode & 0222)) dee.read_only = 1;

        /*dee.archive = 0;*/

        dee.hidden = name[0] == '.';

        dee.fnode = fno;

        dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);

        hpfs_lock_inode(dir);

        r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);

        if (r == 1) goto bail2;

        if (r == -1) {

                brelse(bh);

                hpfs_brelse4(&qbh0);

                hpfs_free_sectors(dir->i_sb, fno, 1);

                hpfs_free_dnode(dir->i_sb, dno);

                hpfs_unlock_inode(dir);

                return -EEXIST;

        }

        fnode->len = len;

        memcpy(fnode->name, name, len > 15 ? 15 : len);

        fnode->up = dir->i_ino;

        fnode->dirflag = 1;

        fnode->btree.n_free_nodes = 7;

        fnode->btree.n_used_nodes = 1;

        fnode->btree.first_free = 0x14;

        fnode->u.external[0].disk_secno = dno;

        fnode->u.external[0].file_secno = -1;

        dnode->root_dnode = 1;

        dnode->up = fno;

        de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);

        de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);

        if (!(mode & 0222)) de->read_only = 1;

        de->first = de->directory = 1;

        /*de->hidden = de->system = 0;*/

        de->fnode = fno;

        mark_buffer_dirty(bh);

        brelse(bh);

        hpfs_mark_4buffers_dirty(&qbh0);

        hpfs_brelse4(&qbh0);

        dir->i_nlink++;

        hpfs_lock_iget(dir->i_sb, 1);

        if ((result = iget(dir->i_sb, fno))) {

                result->i_hpfs_parent_dir = dir->i_ino;

                result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);

                result->i_hpfs_ea_size = 0;

                if (dee.read_only) result->i_mode &= ~0222;

                if (result->i_uid != current->fsuid ||

                    result->i_gid != current->fsgid ||

                    result->i_mode != (mode | S_IFDIR)) {

                        result->i_uid = current->fsuid;

                        result->i_gid = current->fsgid;

                        result->i_mode = mode | S_IFDIR;

                        hpfs_write_inode_nolock(result);

                }

                d_instantiate(dentry, result);

        }

        hpfs_unlock_iget(dir->i_sb);

        hpfs_unlock_inode(dir);

        return 0;

        bail2:

        hpfs_brelse4(&qbh0);

        hpfs_free_dnode(dir->i_sb, dno);

        hpfs_unlock_inode(dir);

        bail1:

        brelse(bh);

        hpfs_free_sectors(dir->i_sb, fno, 1);

        bail:

        return -ENOSPC;

}

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

{

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

        unsigned len = dentry->d_name.len;

        struct inode *result = NULL;

        struct buffer_head *bh;

        struct fnode *fnode;

        fnode_secno fno;

        int r;

        struct hpfs_dirent dee;

        int err;

        if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;

        if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;

        memset(&dee, 0, sizeof dee);

        if (!(mode & 0222)) dee.read_only = 1;

        dee.archive = 1;

        dee.hidden = name[0] == '.';

        dee.fnode = fno;

        dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);

        hpfs_lock_inode(dir);

        r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);

        if (r == 1) goto bail1;

        if (r == -1) {

                brelse(bh);

                hpfs_free_sectors(dir->i_sb, fno, 1);

                hpfs_unlock_inode(dir);

                return -EEXIST;

        }

        fnode->len = len;

        memcpy(fnode->name, name, len > 15 ? 15 : len);

        fnode->up = dir->i_ino;

        mark_buffer_dirty(bh);

        brelse(bh);

        hpfs_lock_iget(dir->i_sb, 2);

        if ((result = iget(dir->i_sb, fno))) {

                hpfs_decide_conv(result, (char *)name, len);

                result->i_hpfs_parent_dir = dir->i_ino;

                result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);

                result->i_hpfs_ea_size = 0;

                if (dee.read_only) result->i_mode &= ~0222;

                if (result->i_blocks == -1) result->i_blocks = 1;

                if (result->i_size == -1) {

                        result->i_size = 0;

                        result->i_data.a_ops = &hpfs_aops;

                        result->u.hpfs_i.mmu_private = 0;

                }

                if (result->i_uid != current->fsuid ||

                    result->i_gid != current->fsgid ||

                    result->i_mode != (mode | S_IFREG)) {

                        result->i_uid = current->fsuid;

                        result->i_gid = current->fsgid;

                        result->i_mode = mode | S_IFREG;

                        hpfs_write_inode_nolock(result);

                }

                d_instantiate(dentry, result);

        }

        hpfs_unlock_iget(dir->i_sb);

        hpfs_unlock_inode(dir);

        return 0;

        bail1:

        brelse(bh);

        hpfs_free_sectors(dir->i_sb, fno, 1);

        hpfs_unlock_inode(dir);

        bail:

        return -ENOSPC;

}

int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)

{

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

        unsigned len = dentry->d_name.len;

        struct buffer_head *bh;

        struct fnode *fnode;

        fnode_secno fno;

        int r;

        struct hpfs_dirent dee;

        struct inode *result = NULL;

        int err;

        if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;

        if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;

        if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;

        memset(&dee, 0, sizeof dee);

        if (!(mode & 0222)) dee.read_only = 1;

        dee.archive = 1;

        dee.hidden = name[0] == '.';

        dee.fnode = fno;

        dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);

        hpfs_lock_inode(dir);

        r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);

        if (r == 1) goto bail1;

        if (r == -1) {

                brelse(bh);

                hpfs_free_sectors(dir->i_sb, fno, 1);

                hpfs_unlock_inode(dir);

                return -EEXIST;

        }

        fnode->len = len;

        memcpy(fnode->name, name, len > 15 ? 15 : len);

        fnode->up = dir->i_ino;

        mark_buffer_dirty(bh);

        hpfs_lock_iget(dir->i_sb, 2);

        if ((result = iget(dir->i_sb, fno))) {

                result->i_hpfs_parent_dir = dir->i_ino;

                result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);

                result->i_hpfs_ea_size = 0;

                /*if (result->i_blocks == -1) result->i_blocks = 1;

                if (result->i_size == -1) result->i_size = 0;*/

                result->i_uid = current->fsuid;

                result->i_gid = current->fsgid;

                result->i_nlink = 1;

                result->i_size = 0;

                result->i_blocks = 1;

                init_special_inode(result, mode, rdev);

                hpfs_write_inode_nolock(result);

                d_instantiate(dentry, result);

        }

        hpfs_unlock_iget(dir->i_sb);

        hpfs_unlock_inode(dir);

        brelse(bh);

        return 0;

        bail1:

        brelse(bh);

        hpfs_free_sectors(dir->i_sb, fno, 1);

        hpfs_unlock_inode(dir);

        bail:

        return -ENOSPC;

}

extern struct address_space_operations hpfs_symlink_aops;

int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)

{

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

        unsigned len = dentry->d_name.len;

        struct buffer_head *bh;

        struct fnode *fnode;

        fnode_secno fno;

        int r;

        struct hpfs_dirent dee;

        struct inode *result;

        int err;

        if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;

        if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;

        if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;

        memset(&dee, 0, sizeof dee);

        dee.archive = 1;

        dee.hidden = name[0] == '.';

        dee.fnode = fno;

        dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);

        hpfs_lock_inode(dir);

        r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);

        if (r == 1) goto bail1;

        if (r == -1) {

                brelse(bh);

                hpfs_free_sectors(dir->i_sb, fno, 1);

                hpfs_unlock_inode(dir);

                return -EEXIST;

        }

        fnode->len = len;

        memcpy(fnode->name, name, len > 15 ? 15 : len);

        fnode->up = dir->i_ino;

        mark_buffer_dirty(bh);

        brelse(bh);

        hpfs_lock_iget(dir->i_sb, 2);

        if ((result = iget(dir->i_sb, fno))) {

                result->i_hpfs_parent_dir = dir->i_ino;

                result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);

                result->i_hpfs_ea_size = 0;

                /*if (result->i_blocks == -1) result->i_blocks = 1;

                if (result->i_size == -1) result->i_size = 0;*/

                result->i_mode = S_IFLNK | 0777;

                result->i_uid = current->fsuid;

                result->i_gid = current->fsgid;

                result->i_blocks = 1;

                result->i_size = strlen(symlink);

                result->i_op = &page_symlink_inode_operations;

                result->i_data.a_ops = &hpfs_symlink_aops;

                if ((fnode = hpfs_map_fnode(dir->i_sb, fno, &bh))) {

                        hpfs_set_ea(result, fnode, "SYMLINK", (char *)symlink, strlen(symlink));

                        mark_buffer_dirty(bh);

                        brelse(bh);

                }

                hpfs_write_inode_nolock(result);

                d_instantiate(dentry, result);

        }

        hpfs_unlock_iget(dir->i_sb);

        hpfs_unlock_inode(dir);

        return 0;

        bail1:

        brelse(bh);

        hpfs_free_sectors(dir->i_sb, fno, 1);

        hpfs_unlock_inode(dir);

        bail:

        return -ENOSPC;

}

int hpfs_unlink(struct inode *dir, struct dentry *dentry)

{

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

        unsigned len = dentry->d_name.len;

        struct quad_buffer_head qbh;

        struct hpfs_dirent *de;

        struct inode *inode = dentry->d_inode;

        dnode_secno dno;

        fnode_secno fno;

        int r;

        int rep = 0;

        hpfs_adjust_length((char *)name, &len);

        again:

        hpfs_lock_2inodes(dir, inode);

        if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {

                hpfs_unlock_2inodes(dir, inode);

                return -ENOENT;

        }

        if (de->first) {

                hpfs_brelse4(&qbh);

                hpfs_unlock_2inodes(dir, inode);

                return -EPERM;

        }

        if (de->directory) {

                hpfs_brelse4(&qbh);

                hpfs_unlock_2inodes(dir, inode);

                return -EISDIR;

        }

        fno = de->fnode;

        if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1) hpfs_error(dir->i_sb, "there was error when removing dirent");

        if (r != 2) {

                inode->i_nlink--;

                hpfs_unlock_2inodes(dir, inode);

        } else {        /* no space for deleting, try to truncate file */

                struct iattr newattrs;

                int err;

                hpfs_unlock_2inodes(dir, inode);

                if (rep)

                        goto ret;

                d_drop(dentry);

                if (atomic_read(&dentry->d_count) > 1 ||

                    permission(inode, MAY_WRITE) ||

                    get_write_access(inode)) {

                        d_rehash(dentry);

                        goto ret;

                }

                /*printk("HPFS: truncating file before delete.\n");*/

                down(&inode->i_sem);

                newattrs.ia_size = 0;

                newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;

                err = notify_change(dentry, &newattrs);

                up(&inode->i_sem);

                put_write_access(inode);

                if (err)

                        goto ret;

                rep = 1;

                goto again;

        }

        ret:

        return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;

}

int hpfs_rmdir(struct inode *dir, struct dentry *dentry)

{

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

        unsigned len = dentry->d_name.len;

        struct quad_buffer_head qbh;

        struct hpfs_dirent *de;

        struct inode *inode = dentry->d_inode;

        dnode_secno dno;

        fnode_secno fno;

        int n_items = 0;

        int r;

        hpfs_adjust_length((char *)name, &len);

        hpfs_lock_2inodes(dir, inode);

        if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {

                hpfs_unlock_2inodes(dir, inode);

                return -ENOENT;

        }

        if (de->first) {

                hpfs_brelse4(&qbh);

                hpfs_unlock_2inodes(dir, inode);

                return -EPERM;

        }

        if (!de->directory) {

                hpfs_brelse4(&qbh);

                hpfs_unlock_2inodes(dir, inode);

                return -ENOTDIR;

        }

        hpfs_count_dnodes(dir->i_sb, inode->i_hpfs_dno, NULL, NULL, &n_items);

        if (n_items) {

                hpfs_brelse4(&qbh);

                hpfs_unlock_2inodes(dir, inode);

                return -ENOTEMPTY;

        }

        fno = de->fnode;

        if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1)

                hpfs_error(dir->i_sb, "there was error when removing dirent");

        if (r != 2) {

                dir->i_nlink--;

                inode->i_nlink = 0;

                hpfs_unlock_2inodes(dir, inode);

        } else hpfs_unlock_2inodes(dir, inode);

        return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;

}

int hpfs_symlink_readpage(struct file *file, struct page *page)

{

        char *link = kmap(page);

        struct inode *i = page->mapping->host;

        struct fnode *fnode;

        struct buffer_head *bh;

        int err;

        err = -EIO;

        lock_kernel();

        if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))

                goto fail;

        err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);

        brelse(bh);

        if (err)

                goto fail;

        unlock_kernel();

        SetPageUptodate(page);

        kunmap(page);

        UnlockPage(page);

        return 0;

fail:

        unlock_kernel();

        SetPageError(page);

        kunmap(page);

        UnlockPage(page);

        return err;

}

int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,

                struct inode *new_dir, struct dentry *new_dentry)

{

        char *old_name = (char *)old_dentry->d_name.name;

        int old_len = old_dentry->d_name.len;

        char *new_name = (char *)new_dentry->d_name.name;

        int new_len = new_dentry->d_name.len;

        struct inode *i = old_dentry->d_inode;

        struct inode *new_inode = new_dentry->d_inode;

        struct quad_buffer_head qbh, qbh1;

        struct hpfs_dirent *dep, *nde;

        struct hpfs_dirent de;

        dnode_secno dno;

        int r;

        struct buffer_head *bh;

        struct fnode *fnode;

        int err;

        if ((err = hpfs_chk_name((char *)new_name, &new_len))) return err;

        err = 0;

        hpfs_adjust_length((char *)old_name, &old_len);

        hpfs_lock_3inodes(old_dir, new_dir, i);

        /* Erm? Moving over the empty non-busy directory is perfectly legal */

        if (new_inode && S_ISDIR(new_inode->i_mode)) {

                err = -EINVAL;

                goto end1;

        }

        if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {

                hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");

                err = -ENOENT;

                goto end1;

        }

        copy_de(&de, dep);

        de.hidden = new_name[0] == '.';

        if (new_inode) {

                int r;

                if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {

                        if ((nde = map_dirent(new_dir, new_dir->i_hpfs_dno, (char *)new_name, new_len, NULL, &qbh1))) {

                                new_inode->i_nlink = 0;

                                copy_de(nde, &de);

                                memcpy(nde->name, new_name, new_len);

                                hpfs_mark_4buffers_dirty(&qbh1);

                                hpfs_brelse4(&qbh1);

                                goto end;

                        }

                        hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");

                        err = -EFSERROR;

                        goto end1;

                }

                err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;

                goto end1;

        }

        if (new_dir == old_dir) hpfs_brelse4(&qbh);

        hpfs_lock_creation(i->i_sb);

        if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {

                hpfs_unlock_creation(i->i_sb);

                if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");

                err = r == 1 ? -ENOSPC : -EFSERROR;

                if (new_dir != old_dir) hpfs_brelse4(&qbh);

                goto end1;

        }

        if (new_dir == old_dir)

                if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {

                        hpfs_unlock_creation(i->i_sb);

                        hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");

                        err = -ENOENT;

                        goto end1;

                }

        if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {

                hpfs_unlock_creation(i->i_sb);

                hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");

                err = r == 2 ? -ENOSPC : -EFSERROR;

                goto end1;

        }

        hpfs_unlock_creation(i->i_sb);

        end:

        i->i_hpfs_parent_dir = new_dir->i_ino;

        if (S_ISDIR(i->i_mode)) {

                new_dir->i_nlink++;

                old_dir->i_nlink--;

        }

        if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {

                fnode->up = new_dir->i_ino;

                fnode->len = new_len;

                memcpy(fnode->name, new_name, new_len>15?15:new_len);

                if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);

                mark_buffer_dirty(bh);

                brelse(bh);

        }

        i->i_hpfs_conv = i->i_sb->s_hpfs_conv;

        hpfs_decide_conv(i, (char *)new_name, new_len);

        end1:

        hpfs_unlock_3inodes(old_dir, new_dir, i);

        return err;

}